using arrays with functions c
Tot el que heu de saber sobre matrius amb funcions en C ++:
En aquest tutorial, analitzarem com es poden utilitzar matrius amb funcions en C ++. Generalment, les matrius es poden passar a les funcions com a arguments de la mateixa manera que passem les variables a les funcions.
Però l'avaluació dels paràmetres formals és lleugerament diferent pel que fa a matrius. Abans d'explorar el pas de matrius a funcions, hem de discutir breument el concepte d'un punter a una matriu.
=> Consulteu aquí els tutorials de formació en profunditat de C ++.
Què aprendreu:
- Punter a una matriu
- Passar matrius a la funció
- Retorn de matrius de funcions
- Conclusió
- Lectura recomanada
Punter a una matriu
Penseu en la següent matriu que conté els primers cinc números de la seqüència de Fibonacci.
int fibSeq(5) = {1,1,2,3,5};Declarem un punter fibPtr per apuntar aquesta matriu.
int* fibPtr; fibPtr = fibSeq;Quan imprimim el contingut de fibPtr, la sortida serà el primer element de la matriu fibSeq. Això es deu al fet que el nom de la matriu sense claudàtors s’avalua com a punter al primer element de la matriu. Així, a l'exemple anterior, el nom 'fibSeq' apunta al primer element de la matriu 'fibSeq'.
A continuació es mostra una representació pictòrica de la mateixa:
Com es mostra a la representació pictòrica anterior, fibPtr apunta al primer element de la matriu. Així, utilitzant l'aritmètica del punter, podem imprimir tots els elements de la matriu només amb fibPtr.
Per exemple, L'expressió * (fibPtr + 1) assenyalarà el segon element de la matriu, etc.
sas programació de preguntes i respostes d’entrevistes
Posem això en un programa i comprovem la sortida de '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); } }Sortida:
fibSeq apunta a: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
A l'exemple anterior, declarem una variable punter fibPtr i, a continuació, fem que assenyali la matriu assignant el nom de la matriu a fibPtr. Quan ho fem, fem que el punt fibPtr sigui el primer element de la matriu. A continuació, imprimim tots els valors d'una matriu mitjançant fibPtr.
Passar matrius a la funció
Quan es tracta de funcions, passem matrius a la funció de manera similar a mesura que passem variables a la funció. Però no passem la variable array del tipus ().
En canvi, passem el punter a la matriu, és a dir, al nom de la matriu que apunta al primer element de la matriu. Aleshores, el paràmetre formal que accepta aquest punter és en realitat una variable de matriu. Quan passem el punter, podem modificar directament la matriu dins de la funció.
Penseu en el programa següent que calcula el quadrat de cada element dels cinc primers elements de la seqüència de Fibonacci per demostrar el pas d'una matriu a la funció.
#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<A l'exemple anterior, calculem el quadrat de cada element en una seqüència de Fibonacci. Aquest quadrat es calcula dins d’una funció. Per tant, passem el nom de la matriu a la funció 'fibSeqSquare' mentre cridem la funció des de main. Dins de la funció, calculem els quadrats de cada element.
A mesura que hem passat la referència a la matriu pel punter, qualsevol modificació que fem a la matriu dins de la funció reflectirà la matriu. Per tant, quan imprimim la matriu a la funció principal, obtenim els quadrats de cada element com a sortida.
A l’exemple anterior, hem vist que l’argument de la matriu (paràmetre formal) de la funció fibSeqSquare no especifica la mida de la matriu, sinó només els claudàtors (()) per indicar que és una matriu. Aquesta és una manera d’especificar els arguments de la matriu.
Una altra manera d’especificar l’argument de la matriu a la llista de paràmetres formals és especificant la mida de la matriu dins dels claudàtors. Tots dos arguments funcionen de manera similar. Aquestes són simplement les dues maneres en què especifiquem els arguments de matriu.
L'exemple següent mostra un argument Array especificat amb mida.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<L'exemple anterior té una funció per mostrar la seqüència de Fibonacci. La funció té un paràmetre com a matriu en què també hem especificat la mida de la matriu.
També podem passar matrius multidimensionals a funcions de la mateixa manera que es mostra anteriorment.
la millor manera d'obrir un fitxer XML
Retorn de matrius de funcions
Quan es tracta de retornar una matriu de la funció, C ++ no ens permet retornar tota una matriu de la funció. No obstant això, podem fer una funció per tornar un punter a la matriu. Però hi ha un problema.
Preguntes sobre l'entrevista del servidor sql per a usuaris experimentats
Penseu en el següent fragment de codi:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Tot i que el programa anterior simplement retorna el punter al primer element d'una matriu de la funció, no funciona com s'esperava. No podem garantir que el programa ens doni la sortida correcta. Pot donar o no la sortida correcta.
Això es deu al fet que retornem la variable local des de la funció i no estem segurs de si estarà en el seu abast en el moment en què es retorni o no.
Per tant, en poques paraules, C ++ no afavoreix el retorn de matrius de funcions.
Si hem de tornar matrius des de la funció, hem d’utilitzar algun dels mètodes següents:
# 1) Retorn de matrius assignats dinàmicament
Podem retornar el punter de la matriu des de la matriu assignada dinàmicament. Utilitzem l’operador ‘new’ per assignar dinàmicament la matriu. Com que és una matriu dinàmica, tindrà l'abast a menys que 'suprimim' la matriu. Per tant, el programa funcionarà bé quan retornem la matriu.
Això es mostra a l'exemple següent.
#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< Sortida:
1 2 3
# 2) Matrius estàtics que retornen
Com que les variables / matrius estàtiques tenen abast al llarg del programa, també podem retornar matrius estàtics de les funcions. Podem prendre un exemple per demostrar-ho. Això és el mateix que l'exemple anterior, amb l'única diferència que en aquest exemple hem utilitzat una matriu estàtica en lloc de la matriu assignada dinàmicament.
#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< Sortida:
1 2 3
Nota : També podem utilitzar una estructura per embolicar la matriu al seu interior i després tornar-la. D'aquesta manera, retornarem naturalment una matriu d'una funció. Però aquest no és un mètode molt factible per retornar matrius.
Conclusió
Així, en aquest tutorial, hem debatut matrius respecte a les funcions en detall. Esperem que aquest tutorial hagi ajudat a esborrar tots els dubtes i idees errònies sobre matrius i funcions de C ++.
=> Consulteu aquí la guia d’entrenament perfecta de C ++.
Lectura recomanada