using arrays with functions c
Alt du trenger å vite om matriser med funksjoner i C ++:
I denne opplæringen vil vi diskutere hvordan matriser kan brukes med funksjoner i C ++. Generelt kan matriser overføres til funksjoner som argumenter på samme måte som vi overfører variablene til funksjoner.
Men vurderingen av formelle parametere er litt annerledes når det gjelder matriser. Før vi faktisk utforsker overføring av matriser til funksjoner, må vi kort diskutere konseptet med en peker til en matrise.
=> Sjekk In-Depth C ++ Training Tutorials Here.
Hva du vil lære:
- Pointer To An Array
- Overføring av arrays for å fungere
- Returarrays fra funksjoner
- Konklusjon
- Anbefalt lesing
Pointer To An Array
Tenk på følgende matrise som inneholder de fem første tallene i Fibonacci-sekvensen.
int fibSeq(5) = {1,1,2,3,5};
La oss erklære en peker fibPtr for å peke denne matrisen.
int* fibPtr; fibPtr = fibSeq;
Når vi skriver ut innholdet i fibPtr, vil utdataene være det første elementet i fibSeq-matrisen. Dette er fordi navnet på matrisen uten firkantede parenteser evalueres til en peker til det første elementet i matrisen. Således i eksemplet ovenfor peker navnet “fibSeq” mot det første elementet i matrisen “fibSeq”.
Nedenfor er en illustrasjon av det samme:
Som vist i den ovennevnte illustrasjonsrepresentasjonen, peker fibPtr mot det første elementet i matrisen. Dermed kan vi bruke pekearitmetikken til å skrive ut alle elementene i matrisen ved å bare bruke fibPtr.
For eksempel, uttrykk * (fibPtr + 1) vil peke på det andre elementet i matrisen og så videre.
java j2ee intervju spørsmål og svar
La oss sette dette i et program og sjekke utdataene fra “fibSeq” og “fibPtr”:
#include #include using namespace std; int main() { int fibSeq(5) = {1,1,2,3,5}; int* fibPtr; fibPtr = fibSeq; cout<<'
fibSeq points to :'<<*fibSeq; cout<<'
fibSeq(0): '<<*fibPtr; cout<<'
fibSeq(1): '<<*(fibPtr + 1); cout<<'
fibSeq(2): '<<*(fibPtr + 2); cout<<'
fibSeq(3): '<<*(fibPtr + 3); cout<<'
fibSeq(4): '<<*(fibPtr + 4); } }
Produksjon:
fibSeq peker på: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
I eksemplet ovenfor erklærer vi en pekervariabel fibPtr og får den til å peke matrisen ved å tilordne navnet på matrisen til fibPtr. Når vi gjør dette, får vi fibPtr til å peke på det første elementet i matrisen. Deretter skriver vi ut alle verdiene til en matrise ved hjelp av fibPtr.
Overføring av arrays for å fungere
Når vi har å gjøre med funksjoner, overfører vi matriser til funksjonen på samme måte som vi overfører variabler til funksjon. Men vi overfører ikke arrayvariabelen av typen ().
I stedet sender vi pekeren til matrisen, dvs. navnet på matrisen som peker mot det første elementet i matrisen. Da er den formelle parameteren som godtar denne pekeren, faktisk en arrayvariabel. Når vi passerer pekeren, kan vi endre matrisen direkte i funksjonen.
Tenk på følgende program som beregner kvadratet til hvert element av de fem første elementene i Fibonacci-sekvensen for å demonstrere at et array går over til å fungere.
#include #include using namespace std; void fibSeqSquare(int fibSeq()) { for(int i=0;i<5;i++) { fibSeq(i) *= fibSeq(i); } } int main() { int fibSeq(5) = {1,1,2,3,5}; fibSeqSquare(fibSeq); for(int i=0;i<5;i++) { cout<I eksemplet ovenfor beregner vi kvadratet til hvert element i en Fibonacci-sekvens. Denne firkanten beregnes i en funksjon. Derfor overfører vi matrisenavnet til funksjonen “fibSeqSquare” mens vi kaller funksjonen fra main. Inne i funksjonen beregner vi kvadratene til hvert element.
Når vi har gitt referansen til matrisen ved hjelp av en peker, uansett hvilke modifikasjoner vi gjør i matrisen inne i funksjonen, vil den gjenspeile matrisen. Derfor når vi skriver ut matrisen i hovedfunksjonen, får vi kvadratene til hvert element som utdata.
I eksemplet ovenfor har vi sett at arrayargumentet (formell parameter) for funksjonen fibSeqSquare ikke spesifiserer størrelsen på arrayet, men bare firkantede parenteser (()) for å indikere at det er en array. Dette er en måte å spesifisere matrixargumentene på.
En annen måte å spesifisere matrixargumentet i den formelle parameterlisten er ved å spesifisere størrelsen på matrisen innenfor parentes. Begge argumentene fungerer på samme måte. Dette er ganske enkelt de to måtene vi spesifiserer arrayargumentene på.
Følgende eksempel viser et Array-argument spesifisert med størrelse.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<Ovennevnte eksempel har en funksjon for å vise Fibonacci-sekvensen. Funksjonen har en parameter som en matrise hvor vi også har spesifisert størrelsen på matrisen.
Vi kan også overføre flerdimensjonale matriser til funksjoner på samme måte som vist ovenfor.
beste VM-programvare for Windows 10
Returarrays fra funksjoner
Når det gjelder å returnere en matrise fra funksjonen, tillater ikke C ++ oss å returnere en hel matrise fra funksjonen. Vi kan imidlertid lage en funksjon for å returnere en peker til matrisen. Men det er en fangst i den.
Vurder følgende kode:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Selv om programmet ovenfor bare peker tilbake til det første elementet i en matrise fra funksjonen, fungerer det ikke som forventet. Vi kan ikke garantere at programmet gir oss riktig resultat. Det gir eller ikke gir riktig utgang.
Dette er fordi vi returnerer den lokale variabelen fra funksjon, og vi er ikke sikre på om den vil være i omfang når den returneres eller ikke.
Dermed, i et nøtteskall, favoriserer ikke C ++ retur av matriser fra funksjoner.
Hvis vi i det hele tatt trenger å returnere matriser fra funksjonen, må vi bruke en av følgende metoder:
# 1) Returnerer dynamisk tildelte matriser
Vi kan returnere matrisepekeren fra den dynamisk tildelte matrisen. Vi bruker operatøren ‘ny’ for å dynamisk tildele matrisen. Siden det er en dynamisk matrise, vil den være i omfang med mindre vi 'sletter' matrisen. Derfor vil programmet gå bra når vi returnerer matrisen.
Dette er vist i det følgende eksemplet.
#include #include using namespace std; int* funcArray() { int* arr = new int(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Produksjon:
1 2 3
# 2) Returnerer statiske matriser
Ettersom statiske variabler / matriser har omfang i hele programmet, kan vi også returnere statiske matriser fra funksjoner. Vi kan ta et eksempel for å demonstrere dette. Dette er det samme som forrige eksempel, med den eneste forskjellen at vi i dette eksemplet har brukt en statisk matrise i stedet for den dynamisk tildelte matrisen.
#include #include using namespace std; int* funcArray() { static int arr(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Produksjon:
hvordan du konfigurerer maven i formørkelse
1 2 3
Merk : Vi kan også bruke en struktur til å pakke inn matrisen i den og deretter returnere den strukturen. På denne måten vil vi naturligvis returnere en matrise fra en funksjon. Men dette er ikke en veldig gjennomførbar metode for å returnere matriser.
Konklusjon
Derfor har vi i denne opplæringen diskutert matriser med hensyn til funksjoner i detalj. Vi håper denne opplæringen ville ha bidratt til å fjerne all tvil og misforståelse om C ++ matriser og funksjoner.
=> Sjekk ut den perfekte C ++ treningsguiden her.
Anbefalt lesing