using arrays with functions c
Tot ce trebuie să știți despre matricele cu funcții în C ++:
În acest tutorial, vom discuta despre modul în care tablourile pot fi utilizate cu funcții în C ++. În general, tablourile pot fi transmise funcțiilor ca argumente în același mod în care trecem variabilele la funcții.
Dar evaluarea parametrilor formali este ușor diferită atunci când vine vorba de matrice. Înainte de a explora de fapt trecerea matricelor la funcții, trebuie să discutăm pe scurt conceptul de pointer către o matrice.
=> Consultați aici tutorialele de instruire în profunzime C ++.
Ce veți învăța:
- Pointer To An Array
- Trecerea matricilor la funcționare
- Returnarea matricilor din funcții
- Concluzie
- Lectură recomandată
Pointer To An Array
Luați în considerare următoarea matrice care conține primele cinci numere ale secvenței Fibonacci.
int fibSeq(5) = {1,1,2,3,5};Să declarăm un pointer fibPtr pentru a indica această matrice.
int* fibPtr; fibPtr = fibSeq;Când imprimăm conținutul fibPtr, ieșirea va fi primul element al matricei fibSeq. Acest lucru se datorează faptului că numele matricei fără paranteze pătrate se evaluează într-un pointer către primul element al matricei. Astfel, în exemplul de mai sus, numele „fibSeq” indică primul element al matricei „fibSeq”.
Mai jos este o reprezentare picturală a aceluiași:
Așa cum se arată în reprezentarea picturală de mai sus, fibPtr indică primul element al matricei. Astfel, folosind aritmetica indicatorului, putem imprima toate elementele matricei folosind doar fibPtr.
De exemplu, expresia * (fibPtr + 1) va indica al doilea element al matricei și așa mai departe.
cum se deschid fișiere .swf pe Windows
Să punem acest lucru într-un program și să verificăm rezultatele „fibSeq” și „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); } }Ieșire:
fibSeq indică: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
În exemplul de mai sus, declarăm o variabilă pointer fibPtr și apoi o facem să indice matricea atribuind numele matricei fibPtr. Când facem acest lucru, facem ca fibPtr să indice primul element al matricei. Apoi imprimăm toate valorile unui tablou folosind fibPtr.
Trecerea matricilor la funcționare
Când avem de-a face cu funcții, trecem matricele la funcție într-un mod similar în timp ce trecem variabile la funcție. Dar nu trecem variabila matrice de tip ().
În schimb, trecem indicatorul către matrice, adică numele matricei care indică primul element al matricei. Atunci parametrul formal care acceptă acest pointer este de fapt o variabilă matrice. Pe măsură ce trecem indicatorul, putem modifica direct matricea din interiorul funcției.
Luați în considerare următorul program care calculează pătratul fiecărui element din primele cinci elemente din secvența Fibonacci pentru a demonstra trecerea unui tablou pentru a funcționa.
#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<În exemplul de mai sus, calculăm pătratul fiecărui element într-o succesiune Fibonacci. Acest pătrat este calculat în interiorul unei funcții. Prin urmare, trecem numele matricei la funcția „fibSeqSquare” în timp ce apelăm funcția din main. În interiorul funcției, calculăm pătratele fiecărui element.
Pe măsură ce am trecut referința la matrice prin intermediul unui pointer, indiferent de modificările pe care le facem matricii din interiorul funcției, vor reflecta matricea. Prin urmare, atunci când imprimăm matricea în funcția principală, obținem pătratele fiecărui element ca ieșire.
În exemplul de mai sus, am văzut că argumentul matricei (parametrul formal) al funcției fibSeqSquare nu specifică dimensiunea matricei, ci doar parantezele pătrate (()) pentru a indica faptul că este o matrice. Aceasta este o modalitate de a specifica argumentele matrice.
Un alt mod de a specifica argumentul matricei în lista formală de parametri este prin specificarea dimensiunii matricei din parantezele pătrate. Ambele argumente funcționează în mod similar. Acestea sunt pur și simplu cele două moduri în care specificăm argumentele matrice.
Următorul exemplu arată un argument Array specificat cu dimensiune.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<Exemplul de mai sus are o funcție pentru a afișa secvența Fibonacci. Funcția are un parametru ca matrice în care am specificat și dimensiunea matricei.
De asemenea, putem transmite matrici multidimensionale către funcții în același mod așa cum se arată mai sus.
care sunt toate site-urile de e-mail
Returnarea matricilor din funcții
Când vine vorba de returnarea unui tablou din funcție, C ++ nu ne permite să returnăm un întreg tablou din funcție. Cu toate acestea, putem face o funcție pentru a returna un indicator la matrice. Dar există o captură în ea.
Luați în considerare următoarea bucată de cod:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Deși programul de mai sus returnează pur și simplu indicatorul către primul element al unui tablou din funcție, acesta nu funcționează așa cum era de așteptat. Nu putem garanta că programul ne va oferi rezultatul corect. Poate da sau nu rezultatul corect.
Acest lucru se datorează faptului că returnăm variabila locală din funcție și nu suntem siguri dacă va fi în sfera de aplicare până când va fi returnată sau nu.
Astfel, pe scurt, C ++ nu favorizează returnarea matricilor din funcții.
Dacă trebuie să returnăm matricele din funcție, trebuie să folosim oricare dintre următoarele metode:
# 1) Returnarea matricelor alocate dinamic
Putem returna indicatorul matricei din matricea alocată dinamic. Folosim operatorul „nou” pentru a aloca dinamic matricea. Întrucât este un tablou dinamic, acesta va fi în domeniul de aplicare, cu excepția cazului în care „ștergem” tabloul. Prin urmare, programul va rula bine când vom returna matricea.
Acest lucru este prezentat în următorul exemplu.
#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< Ieșire:
1 2 3
# 2) Returnarea matricelor statice
Deoarece variabilele / matricile statice au domeniu de aplicare pe tot parcursul programului, putem de asemenea returna matricile statice din funcții. Putem lua un exemplu pentru a demonstra acest lucru. Acesta este același cu exemplul anterior, cu singura diferență că în acest exemplu am folosit o matrice statică în locul matricei alocate dinamic.
#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< Ieșire:
cel mai bun convertor video YouTube în mp3
1 2 3
Notă : Putem folosi, de asemenea, o structură pentru a înfășura matricea în interiorul acesteia și apoi a returna acea structură. În acest fel, vom returna în mod natural o matrice dintr-o funcție. Dar aceasta nu este o metodă foarte fezabilă de returnare a matricelor.
Concluzie
Astfel, în acest tutorial, am discutat în detaliu matricile cu privire la funcții. Sperăm că acest tutorial ar fi ajutat la eliminarea tuturor îndoielilor și a concepțiilor greșite despre matricile și funcțiile C ++.
=> Consultați aici ghidul perfect de formare C ++.
Lectură recomandată