[c++] * e ** ???

[vermaccio]

int x=20; //crea variabile intera x che vale 20

int *puntx=& x; // l'indirizzo di memoria dove era la variabile x è diventato il valore della variabile puntx

*puntx=10; //la variabile x viene modificata e non vale più 20 ma 10.

è corretto?







inoltre spesso nei listati vedo **. a che servono nei puntatori?

[andbin]

Originariamente inviato da vermaccio

int x=20; //crea variabile intera x che vale 20

int *puntx=& x; // l'indirizzo di memoria dove era la variabile x è diventato il valore della variabile puntx

*puntx=10; //la variabile x viene modificata e non vale più 20 ma 10.

è corretto?

Sì, è esatto.

Originariamente inviato da vermaccio

inoltre spesso nei listati vedo **. a che servono nei puntatori?

È un ulteriore livello di indirezione.
Esempio:

int x = 20;

int *px = &x;
int **ppx = &px;

**ppx = 10;

[vermaccio]

int x = 20; //assegna alla variabile x il valore 20

int *px = &x; //assegna alla variabile di tipo puntatore px l'indirizzo della cella di memoria in cui è la variabile x


int **ppx = &px; //che assegna?

e

int *punt = &px; //ha senso?

[andbin]

Originariamente inviato da vermaccio

int x = 20; //assegna alla variabile x il valore 20

int *px = &x; //assegna alla variabile di tipo puntatore px l'indirizzo della cella di memoria in cui è la variabile x

Ok

Originariamente inviato da vermaccio

int **ppx = &px; //che assegna?

ppx è "un puntatore ad un puntatore ad un int".

In pratica si assegna alla variabile ppx l'indirizzo del puntatore px.
px è una variabile come le altre, quindi anch'essa ha un suo indirizzo.

Originariamente inviato da vermaccio

int *punt = &px; //ha senso?

No, &px è l'espressione che indica un "puntatore a puntatore a int" mentre punt è solo un "puntatore a int". Il compilatore si arrabbia in questi casi. Ti segnalerebbe che la assegnazione è incompatibile.

[vermaccio]

questo, se ho ben capito, perchè px è una variabile puntatore e non una variabile nel senso stretto.

infatti è diverso dire
int x;
e
int *px;

quindi , per "estrarre" l'indirizzo, quando ho una "int" userò "*".
mentre se ho una "int*" userò "**".

int x --> *px=&x
int* px --> int **ppx = &px

esatto?

ma... se punto alla ppx... che metto TRE *?

int ***pppx = &ppx

????

[andbin]

Originariamente inviato da vermaccio

questo, se ho ben capito, perchè px è una variabile puntatore e non una variabile nel senso stretto.

infatti è diverso dire
int x;
e
int *px;

Sono entrambe delle variabili (nel senso generale del termine "variabile") ma x è una variabile che contiene un valore intero mentre px è una variabile "puntatore" che contiene un indirizzo.

Originariamente inviato da vermaccio

quindi , per "estrarre" l'indirizzo, quando ho una "int" userò "*".
mentre se ho una "int*" userò "**".

int x --> *px=&x
int* px --> int **ppx = &px

esatto?

Questa non l'ho capita, spiegati meglio. Per ottenere un indirizzo si usa il &, per dereferenziare un indirizzo si usa il *.

Originariamente inviato da vermaccio

ma... se punto alla ppx... che metto TRE *?

int ***pppx = &ppx

Sì, è così. Tieni presente che è molto raro usare 3 livelli di indirezione.

[vermaccio]

mi spiego meglio:

int x=20; //e ipotizziamo che l'indirizzo di memoria dove è stoccata la x sia 7500


int *px=&x; //cioè px vale 7500 ma la variabile px è stoccata, ad esempio, in indirizzo di memoria 8500

int **ppx = &px; //cioè ppx vale 8500 ma la variabile ppx è stoccata, ad esempio, in indirizzo di memoria 9500

*px=10; //la variabile x viene modificata e non vale più 20 ma 10.

x=x+5: //la variabile x ora vale 15.

tutto esatto?

[andbin]

Originariamente inviato da vermaccio

int x=20; //e ipotizziamo che l'indirizzo di memoria dove è stoccata la x sia 7500

int *px=&x; //cioè px vale 7500 ma la variabile px è stoccata, ad esempio, in indirizzo di memoria 8500

int **ppx = &px; //cioè ppx vale 8500 ma la variabile ppx è stoccata, ad esempio, in indirizzo di memoria 9500

*px=10; //la variabile x viene modificata e non vale più 20 ma 10.

x=x+5: //la variabile x ora vale 15.

tutto esatto?

Sì, esatto.

[andbin]

Prova questo "esercizio" sui puntatori ...

void funz (int **pa, int **pb)
{
    int *pt;

    pt = *pa;
    *pa = *pb;
    *pb = pt;
}

int main (void)
{
    int a = 10;
    int b = 20;
    int *p1 = &a;
    int *p2 = &b;

    /* Qui p1 punta ad 'a', p2 punta a 'b' */

    funz (&p1, &p2);

    *p1 = 55;
    *p2 = 99;

    /* Cosa contengono a e b ?? */
    /* Cosa fa la funz() ?? */

    return 0;
}

[wingman87]

Scusa andbin ma quando ad esempio tu hai fatto:
int *p1 = &a;
è uguale a scrivere:
int *p1;
p1=&a;
giusto?

[andbin]

Originariamente inviato da wingman87

Scusa andbin ma quando ad esempio tu hai fatto:
int *p1 = &a;
è uguale a scrivere:
int *p1;
p1=&a;
giusto?

Giusto. L'unica cosa è che nel secondo caso, se p1 è una variabile locale, non essendo subito inizializzata, contiene sicuramente "spazzatura".

[vermaccio]

void funz (int **pa, int **pb)
{
    int *pt;

    pt = *pa;
    *pa = *pb;
    *pb = pt;
}

int main (void)
{
    int a = 10;
    int b = 20;
    int *p1 = &a;
    int *p2 = &b;

    /* Qui p1 punta ad 'a', p2 punta a 'b' */

    funz (&p1, &p2);

    *p1 = 55;
    *p2 = 99;

    /* Cosa contengono a e b ?? */
    /* Cosa fa la funz() ?? */

    return 0;
}

all'inizio a=10 e b=20
poi b=55 e a=99 perchè i puntatori sono stati invertiti prima della riassegnazione.

esercizio illuminante!
grazie

sei sempre un mito!
(e mi sta simpatico anche il gatto)

[vermaccio]

int x=20; //crea variabile intera x che vale 20

int *puntx=& x; // l'indirizzo di memoria dove era la variabile x è diventato il valore della variabile puntx


1)
ma se io per motivi di programmazione conoscessi solo
*puntx come stampo il valore "20" a cui punta il puntatore *puntx?

2)se ho una funzione:
void funzione (....., double* &variabile,...)
(notare la "&")
In questa funzione ho un ciclo for che riempie l'array "variabile"

for(int i=0; .....){
variabile[i]=qualcosa
}

Se io richiamo la funzione dal main tramite
double *puntx
funzione(..., puntx,...)

io ottengo la variabile puntx che è un array(?) di puntatori ai valori "qualcosa".

se voglio stampare a video i "qualcosa" come faccio se sono double?

printf("puntx: %g\n", puntx);

???????

[andbin]

Originariamente inviato da vermaccio

int x=20; //crea variabile intera x che vale 20

int *puntx=& x; // l'indirizzo di memoria dove era la variabile x è diventato il valore della variabile puntx

Ok

Originariamente inviato da vermaccio

1)
ma se io per motivi di programmazione conoscessi solo
*puntx come stampo il valore "20" a cui punta il puntatore *puntx?

In generale, quando hai un puntatore (e ammesso che il puntatore sia "valido"), per ottenere il valore puntato si usa *punt.

Originariamente inviato da vermaccio

2)se ho creato double *posizioneX

e in una funzione ho:
void funzione (....., double* &variabile,...)
(notare la "&")
In questa funzione ho un ciclo for che riempie l'array "variabile"

for(int i=0; .....){
variabile[i]=qualcosa
}

Se io richiamo la funzione dal main tramite
double *puntx
funzione(..., puntx,...)

io ottengo la variabile puntx che è un array(?) di puntatori ai valori "qualcosa".

No, alt.
Ti faccio un esempio più chiaro:

void funz (double *ptr)   /* ottengo un puntatore */
{
    int i;

    for (i = 0; i < 10; i++)
        ptr[i] = i+1;     /* ptr[i] equivale a *(ptr+i)  cioè accede all'elemento di indice 'i' !!! */
}

int main (void)
{
    int i;
    double arr[10];   /* definisco un array di 10 double */

    funz (arr);   /* passo a funz l'indirizzo del primo elemento!! */

    for (i = 0; i < 10; i++)
        printf ("%f ", arr[i]);    /* stampa elemento */

    return 0;
}

Originariamente inviato da vermaccio

printf("puntx: %g\n", puntx);

Guarda la documentazione della printf. Ci sono molti specificatori di formato. Per i double si può usare 'e', 'f' o 'g' (ci sono delle differenze, naturalmente).

[vermaccio]

eccoil mio dilemma

void funz (double* &ptr)

{
int i;

for (i = 0; i < 10; i++)
ptr[i] = 100+i; //100, 101, .. ,110
}


int main (void)
{
int i;
double* nuovo;

funz (nuovo);

//ora che contiene nuovo? come stampo il contenuto?

return 0;
}

[vermaccio]

Originariamente inviato da andbin

Ok


Ti faccio un esempio più chiaro:

void funz (double *ptr)   /* ottengo un puntatore */
{
    int i;

    for (i = 0; i < 10; i++)
        ptr[i] = i+1;     /* ptr[i] equivale a *(ptr+i)  cioè accede all'elemento di indice 'i' !!! */
}

int main (void)
{
    int i;
    double arr[10];   /* definisco un array di 10 double */

    funz (arr);   /* passo a funz l'indirizzo del primo elemento!! */

    for (i = 0; i < 10; i++)
        printf ("%f ", arr[i]);    /* stampa elemento */

    return 0;
}

ptr[i] = i+1;



ptr[i], variando i da 0 a 10 varrà 1,2,...11

la funzione passa all'esterno "double *ptr" ovvero il puntatore al primo elemento che vale 1.


quando fuori della funzione stampo "printf ("%f ", arr[i]);" verrà stampato 1,2...,11.

esatto?


(questi puntatori mi stanno facendo impazzireeeeeeee)

[andbin]

Originariamente inviato da vermaccio

void funz (double* &ptr)

Per iniziare, si dichiara il parametro come double *ptr (senza alcun &, nota bene!!!!)

Originariamente inviato da vermaccio

{
int i;

for (i = 0; i < 10; i++)
ptr[i] = 100+i; //100, 101, .. ,110
}

Ok

Originariamente inviato da vermaccio

int main (void)
{
int i;
double* nuovo;

funz (nuovo);

//ora che contiene nuovo? come stampo il contenuto?

return 0;
}

Qui no, è sbagliato.
con double *nuovo hai dichiarato un puntatore ma senza dargli un valore. Non è inizializzato, in pratica. Molto probabilmente contiene schifezze, quindi non sai a cosa punta.
Se anche puntasse a qualcosa di valido ... l'unica cosa certa è che funz cercherebbe di scrivere su 10 double a partire dall'indirizzo passato.

[andbin]

Originariamente inviato da vermaccio

ptr[i], variando i da 0 a 10 varrà 1,2,...11

No, "i" va da 0 a 9 (il test è per < 10!!!).

Originariamente inviato da vermaccio

quando fuori della funzione stampo "printf ("%f ", arr[i]);" verrà stampato 1,2...,11.

esatto?

I valori stampati (usando "%f") saranno:
1.000000 2.000000 3.000000 4.000000 5.000000 6.000000 7.000000 8.000000 9.000000 10.000000

[vermaccio]

bel casino.
allora.
facciamo chiarezza.
tutto è iniziato perchè ho una funzione fatta così.

void funz (double* &ptr)

{
int i;

for (i = 0; i < 10; i++)
ptr[i] = 100+i; //100, 101, .. ,110
}

per attivarla ho pensato bene di fare nel main
double* nuovo;
funz (nuovo);

però non riuscivo poi a stampare il contenuto di nuovo che in teoria doveva contenere puntatori ai valori creati nella funzione.

però se ho ban capito così non va bene.

allora che devo dare in pasto alla funzione?

la devo richiamare come dal main infilandogli dentro che double? creato come?

[andbin]

Originariamente inviato da vermaccio

allora che devo dare in pasto alla funzione?

la devo richiamare come dal main infilandogli dentro che double? creato come?

Prendiamo il tuo ultimo esempio:

void funz (double* ptr)
{
    int i;

    for (i = 0; i < 10; i++)
        ptr[i] = 100+i; //100, 101, .. ,109
}

Tu sai che la funzione va a scrivere su 10 double messi in sequenza (quindi un array di 10 double!!!).
Alla funzione dovrai passare un puntatore tale per cui punti ad una zona di memoria valida in cui ci sia spazio per 10 double.
Il modo più semplice è passare l'indirizzo di un array di double!!!

double arr[10];

funz (arr);

Puoi allocare della memoria:

double *punt;
punt = (double*) malloc (10*sizeof (double));

funz (punt);

Quello che deve essere chiaro è che la funzione si aspetta un puntatore valido ad un blocco di 10 double.