[c++] vettori e passaggio parametro a funzione

[MItaly]

Correggo solo le affermazioni errate:

passo alla funzione l'indirizzo del 4°elemento del vettore e lo metto in int m;

Non passi l'indirizzo, passi una copia del valore contenuto nel 5° elemento del vettore.

//poi prendo l'indirizzo della cella di memoria contenente vet, ci sottraggo 1 (cella) e passo questo indirizzo a n[].
//è un po' come se gli avessi passato vet[-1]

No, è equivalente ad aver passato &vet[-1].

Nota comunque che, per quanto concerne lo standard, anche se poi in scambia ri-aggiungi 4 e quindi ottieni un puntatore ad una posizione valida nel vettore, anche solo costruire un puntatore che punta al di fuori di qualunque variabile (o array) non è consentito (unica eccezione: si può avere un puntatore che punta all'elemento successivo all'ultimo elemento di un array, anche se non è consentito dereferenziarlo; questo è comodo perché consente di esprimere più facilmente i range di elementi come intervalli semichiusi [inizio, fine) ).

//vet[4]: passo il valore contenuto nella posizione vet[4], quindi un intero, nel mio caso =4

Corretto, ma ovviamente non lo puoi fare, dato che il tipo che scambia si aspetta è un puntatore (o meglio, un compilatore C te lo consentirebbe dato che la politica per i cast impliciti da interi a puntatore è estremamente lassista )

[BoG]

Non vorrei correre troppo ma penso di aver capito.
Grazie mille a tutti!

[MItaly]

[Patrick Jane]

//ora, chiamo di nuovo la funzione scambia passando un intero e  l'indirizzo di memoria &vet[4]. Domanda: se passo come parametro  vet[4] passo il valore contenuto in vet[4] oppure l'indirizzo
//della cella di memoria vet[4]? e se avessi passato vet+4? oppure &vet+4? oppure &vet[4]? 
//Provo a dare la mia idea:
// vet+4: passo l'indirizzo del primo elemento + 4, quindi passo l'indirizzo del 5° elemento del vettore
//vet[4]: passo il valore contenuto nella posizione vet[4], quindi un intero, nel mio caso =4
//&vet+4: credo valga lo stesso discrorso di vet+4
//&vet[4]: passo l'indirizzo di memoria del 5° elemento dell'array

Se fai vet[4] passi il valore della posizione 4 dell'array; quindi l'ultimo numero dell'array, nel tuo caso.

Il tuo: (*(n+m))--; nella realtà... non fa proprio un bel nulla! L'unico a cambiare le cose è n-- alla fine della funzione. Quindi dopo la prima chiamata avrai in pratica n che vale 4 byte meno di prima. Quindi: 0x28fef0. Ma vet non è cambiato, è sempre quello di prima!

Nell'altra chiamata passi invece 0x28ff08 (indirizzo dell'ultimo elemento), a cui poi sottrai -1; quindi 0x28ff04 alla fine della funzione.
Ma anche in questo caso, vet non viene alterato!

PS: sono stato anticipato

[BoG]

Antipatico? no!
Purtroppo facendo girare il programma mi altera i vettori.
Se tu mi dici che non dovrebbe, allora io non ho capito un ca-a-a-a-a-a

[Patrick Jane]

Ho alterato leggermente il tuo codice:

using namespace std;
#include <iostream>
void cambia(int m, int n[7]){
    cout << "Indirizzo n ad inizio chiamata cambia(): "<<n<<endl;
    //for(int i=0;i<7;i++) cout << "n["<<i<<"]: " << n[i] <<endl; 
        (*(n+m))--;
        m++;
        cout << "Indirizzo n dopo (*(n+m))--: " << n<<endl;
        n--;
    cout << "Indirizzo n termine funzione: "<<n<<endl;
}


int main(){
    int vet[] ={4,2,3,2,4};
    cout << "Indirizzo originale vet: " << vet << endl;
    cambia(vet[4], vet-1);
    cout << "Indirizzo vet dopo cambia(vet[4], vet-1): "<<vet<<endl<<endl;
    cambia(0,&vet[4]);
    cout << "Indirizzo vet dopo cambia(0, &vet[4]): "<<vet<<endl;
    int i=0;
    
    for(i=0; i<5; i++)
        cout << vet[i];
    return 0;
    
}

Io ottengo:

Indirizzo originale vet: 0x28fef8
Indirizzo n ad inizio chiamata cambia(): 0x28fef4
Indirizzo n dopo (*(n+m))--: 0x28fef4
Indirizzo n termine funzione: 0x28fef0
Indirizzo vet dopo cambia(vet[4], vet-1): 0x28fef8

Indirizzo n ad inizio chiamata cambia(): 0x28ff08
Indirizzo n dopo (*(n+m))--: 0x28ff08
Indirizzo n termine funzione: 0x28ff04
Indirizzo vet dopo cambia(0, &vet[4]): 0x28fef8
42313

Quindi fai caso a:

Indirizzo n ad inizio chiamata cambia(): 0x28fef4
Indirizzo n dopo (*(n+m))--: 0x28fef4

è sempre il solito di inizio funzione, prima dell'esecuzione di quell'istruzione. Cambia solo dopo con l'ultima sottrazione: Indirizzo n termine funzione: 0x28fef0
Ma quando ritorna al chiamante, vet ha sempre l'indirizzo originale, questo voglio dire! Questo vale per entrambe le chiamate, come si nota.

[BoG]

Quindi fai caso a:

Indirizzo n ad inizio chiamata cambia(): 0x28fef4
Indirizzo n dopo (*(n+m))--: 0x28fef4

è sempre il solito di inizio funzione, prima dell'esecuzione di quell'istruzione. Cambia solo dopo con l'ultima sottrazione: Indirizzo n termine funzione: 0x28fef0
Ma quando ritorna al chiamante, vet ha sempre l'indirizzo originale, questo voglio dire! Questo vale per entrambe le chiamate, come si nota.

Tutto chiaro. Grazie mille!

[Patrick Jane]

Di nulla!