using arrays with functions c
Alt hvad du behøver at vide om arrays med funktioner i C ++:
I denne vejledning vil vi diskutere, hvordan arrays kan bruges med funktioner i C ++. Generelt kan arrays overføres til funktioner som argumenter på samme måde som vi overfører variablerne til funktioner.
Men vurderingen af formelle parametre er lidt anderledes, når det kommer til arrays. Før vi faktisk udforsker videregivelse af arrays til funktioner, skal vi kort diskutere begrebet en markør til en matrix.
=> Tjek dybdegående C ++ træningsvejledninger her.
Hvad du lærer:
- Markør til en række
- Videregive arrays til at fungere
- Returnering af arrays fra funktioner
- Konklusion
- Anbefalet læsning
Markør til en række
Overvej følgende array, der indeholder de første fem numre i Fibonacci-sekvensen.
int fibSeq(5) = {1,1,2,3,5};Lad os erklære en pointer fibPtr til at pege på dette array.
int* fibPtr; fibPtr = fibSeq;Når vi udskriver indholdet af fibPtr, bliver output det første element i fibSeq-arrayet. Dette skyldes, at navnet på arrayet uden firkantede parenteser evalueres til en markør til det første element i arrayet. Således i ovenstående eksempel peger navnet “fibSeq” på det første element i arrayet “fibSeq”.
Nedenfor er en billedlig gengivelse af det samme:
Som vist i ovenstående billedrepræsentation peger fibPtr på det første element i arrayet. Således ved hjælp af markørens aritmetik kan vi udskrive alle elementerne i arrayet ved blot at bruge fibPtr.
For eksempel, udtryk * (fibPtr + 1) vil pege på det andet element i arrayet og så videre.
qa testled interview spørgsmål og svar
Lad os sætte dette i et program og kontrollere output af '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); } }Produktion:
fibSeq peger på: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
I ovenstående eksempel erklærer vi en markørvariabel fibPtr og får den til at pege på arrayet ved at tildele arrayets navn til fibPtr. Når vi gør dette, får vi fibPtr til at pege på det første element i arrayet. Derefter udskriver vi alle værdierne i en matrix ved hjælp af fibPtr.
Videregive arrays til at fungere
Når vi har at gøre med funktioner, sender vi arrays til funktionen på en lignende måde, som vi sender variabler til funktion. Men vi videregiver ikke arrayvariablen af typen ().
I stedet sender vi markøren til arrayet, dvs. navnet på arrayet, der peger på det første element i arrayet. Derefter er den formelle parameter, der accepterer denne markør, faktisk en matrixvariabel. Når vi passerer markøren, kan vi direkte ændre arrayet inde i funktionen.
Overvej følgende program, der beregner firkanten af hvert element af de første fem elementer i Fibonacci-sekvensen for at demonstrere, at en matrix går videre til at 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 firkanten af hvert element i en Fibonacci-sekvens. Denne firkant beregnes inde i en funktion. Derfor overfører vi arraynavnet til funktionen “fibSeqSquare”, mens vi kalder funktionen fra main. Inde i funktionen beregner vi firkanterne for hvert element.
Da vi har passeret henvisningen til arrayet ved hjælp af en markør, uanset hvilke ændringer vi foretager til arrayet inde i funktionen, vil det reflektere arrayet. Derfor når vi udskriver arrayet i hovedfunktionen, får vi firkanterne for hvert element som output.
I ovenstående eksempel har vi set, at arrayargumentet (formel parameter) for funktionen fibSeqSquare ikke angiver arrayets størrelse, men kun firkantede parenteser (()) for at indikere, at det er en array. Dette er en måde at specificere arrayargumenterne på.
En anden måde at specificere arrayargumentet i den formelle parameterliste er ved at specificere arrayets størrelse inden for firkantede parenteser. Begge argumenter fungerer ens. Dette er simpelthen de to måder, hvorpå vi specificerer arrayargumenterne.
Følgende eksempel viser et Array-argument specificeret med størrelse.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<Ovenstående eksempel har en funktion til at vise Fibonacci-sekvensen. Funktionen har en parameter som en matrix, hvor vi også har specificeret arrayets størrelse.
Vi kan også overføre multidimensionelle arrays til funktioner på samme måde som vist ovenfor.
bedste test sagsstyringsværktøj til jira
Returnering af arrays fra funktioner
Når det kommer til at returnere et array fra funktion, tillader C ++ os ikke at returnere et helt array fra funktionen. Vi kan dog lave en funktion til at returnere en markør til arrayet. Men der er en fangst i det.
Overvej følgende kode:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Selvom ovenstående program simpelthen returnerer markøren til det første element i en matrix fra funktionen, fungerer den ikke som forventet. Vi kan ikke garantere, at programmet giver os den korrekte output. Det giver måske ikke det korrekte output.
bedste gratis registry cleaner windows 10
Dette skyldes, at vi returnerer den lokale variabel fra funktion, og vi er ikke sikre på, om den vil være inden for rækkevidde, når den returneres eller ej.
I en nøddeskal favoriserer C ++ således ikke returnering af arrays fra funktioner.
Hvis vi overhovedet har brug for at returnere arrays fra funktionen, skal vi bruge en af følgende metoder:
# 1) Returnering af dynamisk tildelte arrays
Vi kan returnere matrixmarkøren fra det dynamisk tildelte array. Vi bruger operatøren 'ny' til dynamisk at tildele arrayet. Da det er et dynamisk array, vil det være i omfang, medmindre vi 'sletter' arrayet. Derfor kører programmet fint, når vi returnerer arrayet.
Dette er vist i det følgende eksempel.
#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< Produktion:
1 2 3
# 2) Returnering af statiske arrays
Da statiske variabler / arrays har omfang i hele programmet, kan vi også returnere statiske arrays fra funktioner. Vi kan tage et eksempel for at demonstrere dette. Dette er det samme som det foregående eksempel med den eneste forskel, at vi i dette eksempel har brugt et statisk array i stedet for det dynamisk tildelte array.
#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< Produktion:
1 2 3
Bemærk : Vi kan også bruge en struktur til at pakke arrayet inde i det og derefter returnere strukturen. På denne måde returnerer vi naturligvis en matrix fra en funktion. Men dette er ikke en meget gennemførlig metode til at returnere arrays.
Konklusion
Således i denne vejledning har vi diskuteret arrays med hensyn til funktioner i detaljer. Vi håber, at denne vejledning ville have bidraget til at fjerne al tvivl og misforståelse om C ++ - arrays og funktioner.
=> Tjek den perfekte C ++ træningsvejledning her.
Anbefalet læsning