Menu

Utilizzo di array con funzioni in C ++

using arrays with functions c

Prova Il Nostro Strumento Per Eliminare I Problemi

Tutto quello che devi sapere sugli array con funzioni in C ++:

In questo tutorial, discuteremo di come gli array possono essere usati con le funzioni in C ++. Generalmente, gli array possono essere passati alle funzioni come argomenti nello stesso modo in cui passiamo le variabili alle funzioni.

Ma la valutazione dei parametri formali è leggermente diversa quando si tratta di array. Prima di esplorare effettivamente il passaggio di array a funzioni, dobbiamo discutere brevemente il concetto di puntatore a un array.

=> Controlla qui i tutorial di formazione approfonditi su C ++.

ARRAY CON FUNZIONE

Cosa imparerai:

Puntatore a una matrice

Considera il seguente array contenente i primi cinque numeri della sequenza di Fibonacci.

int fibSeq(5) = {1,1,2,3,5};

Dichiariamo un puntatore fibPtr per puntare a questo array.

int* fibPtr; fibPtr = fibSeq;

Quando stampiamo il contenuto di fibPtr, l'output sarà il primo elemento dell'array fibSeq. Questo perché il nome della matrice senza parentesi quadre restituisce un puntatore al primo elemento della matrice. Pertanto, nell'esempio precedente, il nome 'fibSeq' punta al primo elemento della matrice 'fibSeq'.

Di seguito una rappresentazione pittorica dello stesso:

Puntatore a un array
Come mostrato nella rappresentazione pittorica sopra, fibPtr punta al primo elemento della matrice. Quindi, usando l'aritmetica del puntatore, possiamo stampare tutti gli elementi dell'array semplicemente usando fibPtr.

Per esempio, espressione * (fibPtr + 1) punterà al secondo elemento dell'array e così via.

come giocare a mkv su pc

Inseriamolo in un programma e controlliamo l'output di 'fibSeq' e '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); } }

Produzione:

fibSeq punta a: 1

fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): ​​5

Nell'esempio sopra, dichiariamo una variabile di puntatore fibPtr e quindi facciamo in modo che punti l'array assegnando il nome dell'array a fibPtr. Quando lo facciamo, facciamo in modo che fibPtr punti al primo elemento dell'array. Quindi stampiamo tutti i valori di un array usando fibPtr.

Passaggio di array alla funzione

Quando abbiamo a che fare con le funzioni, passiamo gli array alla funzione in modo simile a come passiamo le variabili alla funzione. Ma non passiamo la variabile array di tipo ().

Invece, passiamo il puntatore all'array, cioè il nome dell'array che punta al primo elemento dell'array. Quindi il parametro formale che accetta questo puntatore è in realtà una variabile di matrice. Quando passiamo il puntatore, possiamo modificare direttamente l'array all'interno della funzione.

Considera il seguente programma che calcola il quadrato di ogni elemento dei primi cinque elementi nella sequenza di Fibonacci per dimostrare il passaggio di un array alla funzione.

#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<

Nell'esempio sopra, calcoliamo il quadrato di ogni elemento in una sequenza di Fibonacci. Questo quadrato è calcolato all'interno di una funzione. Quindi passiamo il nome dell'array alla funzione 'fibSeqSquare' durante la chiamata della funzione da main. All'interno della funzione calcoliamo i quadrati di ogni elemento.

Poiché abbiamo passato il riferimento all'array tramite un puntatore, qualunque modifica apportiamo all'array all'interno della funzione, rifletterà l'array. Quindi quando stampiamo l'array nella funzione main, otteniamo i quadrati di ogni elemento come output.

Nell'esempio precedente, abbiamo visto che l'argomento dell'array (parametro formale) della funzione fibSeqSquare non specifica la dimensione dell'array ma solo le parentesi quadre (()) per indicare che si tratta di un array. Questo è un modo per specificare gli argomenti dell'array.

Un altro modo per specificare l'argomento dell'array nell'elenco dei parametri formali è specificare la dimensione dell'array all'interno delle parentesi quadre. Entrambi gli argomenti funzionano in modo simile. Questi sono semplicemente i due modi in cui specifichiamo gli argomenti dell'array.

L'esempio seguente mostra un argomento Array specificato con size.

#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<

L'esempio sopra ha una funzione per visualizzare la sequenza di Fibonacci. La funzione ha un parametro come un array in cui abbiamo anche specificato la dimensione dell'array.

Possiamo anche passare array multidimensionali alle funzioni nello stesso modo mostrato sopra.

implementazione del bubble sort c ++

Restituzione di array da funzioni

Quando si tratta di restituire un array dalla funzione, C ++ non ci consente di restituire un intero array dalla funzione. Tuttavia, possiamo creare una funzione per restituire un puntatore all'array. Ma c'è un problema.

Considera la seguente parte di codice:

int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout<

Sebbene il programma precedente restituisca semplicemente il puntatore al primo elemento di un array dalla funzione, non funziona come previsto. Non possiamo garantire che il programma ci fornirà l'output corretto. Può fornire o meno l'output corretto.

Questo perché stiamo restituendo la variabile locale dalla funzione e non siamo sicuri se sarà nell'ambito quando verrà restituita o meno.

Quindi, in poche parole, C ++ non favorisce la restituzione di array dalle funzioni.

Se è assolutamente necessario restituire array dalla funzione, è necessario utilizzare uno dei seguenti metodi:

# 1) Restituzione di array allocati dinamicamente

Possiamo restituire il puntatore all'array dall'array allocato dinamicamente. Usiamo l'operatore 'new' per allocare dinamicamente l'array. Poiché si tratta di un array dinamico, sarà nell'ambito a meno che non 'eliminiamo' l'array. Quindi, il programma funzionerà correttamente quando restituiremo l'array.

Ciò è mostrato nel seguente esempio.

#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<

Produzione:

1 2 3

# 2) Restituzione di array statici

Poiché le variabili / array statici hanno ambito in tutto il programma, possiamo anche restituire array statici dalle funzioni. Possiamo fare un esempio per dimostrarlo. È lo stesso dell'esempio precedente con l'unica differenza che in questo esempio abbiamo utilizzato un array statico invece dell'array allocato dinamicamente.

#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<

Produzione:

1 2 3

Nota : Possiamo anche usare una struttura per avvolgere l'array al suo interno e quindi restituire quella struttura. In questo modo, restituiremo naturalmente un array da una funzione. Ma questo non è un metodo molto fattibile per restituire gli array.

Conclusione

Pertanto, in questo tutorial, abbiamo discusso in dettaglio gli array rispetto alle funzioni. Speriamo che questo tutorial abbia contribuito a chiarire tutti i dubbi e le idee sbagliate sugli array e le funzioni C ++.

come riprodurre file mkv su pc

=> Dai un'occhiata alla guida di formazione C ++ perfetta qui.

Lettura consigliata

^