[C++]Assegnare un campo di una classe con "una_stringa"

[anx721]

Ho un dubbio sull'assegnazione di un campo di una classe con un oggetto di tipo char * non allocato con malloc ma come un letterale "xxxxxx", ad esempio:

class A{
       const char * value;

       A(const char * v){
           value = v;
       }
}


Quindi in una funzione posso fare:

A * create(){
        a = new A("ciao");
        return a;
}

Nel costruttore di A inizializzo il campo value con un puntatore a char che è stato inizializzato direttamente nella chiamata del costruttore con la 'stringa' "ciao". Quello che mi chiedo è quale sia il tempo di vita della zona di memoria allocata per "ciao", se cioè "ciao" viene trattato come un array di caratteri allocato staticamente che quindi, essendo una variabile locale viene deallocato all'uscita della funzione create(), oppure continua ad esistere dopo la funzione. Nel primo caso si assegna al campo value l'indirizzo di una zona di memoria non piu valida; ad ogni modo il compilatore non mi segnala problemi, quindi dovrebbe essere giusto, ma voglio essere sicuro.

Ciao e grazie.

[Ziosilvio]

Originariamente inviato da anx721
Ho un dubbio sull'assegnazione di un campo di una classe con un oggetto di tipo char * non allocato con malloc ma come un letterale "xxxxxx", ad esempio:

class A{
       const char * value;

       A(const char * v){
           value = v;
       }
}


Quindi in una funzione posso fare:

A * create(){
        a = new A("ciao");
        return a;
}

Nel costruttore di A inizializzo il campo value con un puntatore a char che è stato inizializzato direttamente nella chiamata del costruttore con la 'stringa' "ciao". Quello che mi chiedo è quale sia il tempo di vita della zona di memoria allocata per "ciao", se cioè "ciao" viene trattato come un array di caratteri allocato staticamente che quindi, essendo una variabile locale viene deallocato all'uscita della funzione create(), oppure continua ad esistere dopo la funzione.

Nel tuo codice, "ciao" e' una costante stringa, quindi viene allocata staticamente e rimane in vita finche' il programma non termina.
Inoltre, nella classe A, il campo value e' semplicemente un puntatore a char: quando invochi new A("ciao"), value si limita a puntare all'inizio di "ciao", e quando l'oggetto a viene deallocato, la stessa sorte tocca a value ma non a "ciao".

il compilatore non mi segnala problemi, quindi dovrebbe essere giusto

Il compilatore ti puo' dire se un programma e' sintatticamente corretto; non puo' dirti se e' giusto.

[anx721]

Originariamente inviato da Ziosilvio
Nel tuo codice, "ciao" e' una costante stringa, quindi viene allocata staticamente e rimane in vita finche' il programma non termina.

Ok..era questo che mi interessava

Originariamente inviato da Ziosilvio
Inoltre, nella classe A, il campo value e' semplicemente un puntatore a char: quando invochi new A("ciao"), value si limita a puntare all'inizio di "ciao", e quando l'oggetto a viene deallocato, la stessa sorte tocca a value ma non a "ciao".

Si, questo lo so, se pero la variabile puntata da quel puntatore fosse stata deallocata automaticamente all'uscita dala funzione il campo della classe avrebbe continuato a puntare ad una zona di memoria deallocata. Se ad esempio il costruttore prendeva un puntatore ad int e creo all'interno della funzione una variabile locale int e chiamo il costruttore di A passando l'indirizzo di quella varbiabile sarebbe stato errore giusto?

Originariamente inviato da Ziosilvio
Il compilatore ti puo' dire se un programma e' sintatticamente corretto; non puo' dirti se e' giusto.

Certo, pero certe cose le segnala, ad esempio se in una funzione ritorno l'indirizzo di una variabile locala dà un warning.

Ciao.

[Ziosilvio]

Originariamente inviato da anx721
Si, questo lo so, se pero la variabile puntata da quel puntatore fosse stata deallocata automaticamente all'uscita dala funzione il campo della classe avrebbe continuato a puntare ad una zona di memoria deallocata.

Scusami, ma questa frase cambia significato a seconda se metti una virgola dopo "fosse stata deallocata automaticamente" oppure dopo "all'uscita della funzione".
Puoi ripostarla mettendo la virgola dove va davvero?

Se ad esempio il costruttore prendeva un puntatore ad int e creo all'interno della funzione una variabile locale int e chiamo il costruttore di A passando l'indirizzo di quella varbiabile sarebbe stato errore giusto?

Detta cosi': a priori no, per esempio questa va benissimo:

class A {
    int n;
public:
    A(int *p) {
        n=*p;
    }
};
A* create() {
    int n=10;
    return new A(&n);
}

perche' l'esecuzione del costruttore di A termina prima della funzione.
Se invece fosse stato:

class A {
    int *p;
public:
    A(int *q) {
        p=q;
    }
};
A* create() {
    int n=10;
    return new A(&n);
}

allora sarebbe stato sbagliato, perche' (come hai detto) ci sarebbe stato un campo dell'oggetto restituito da create, contenente l'indirizzo di una variabile deallocata.

[anx721]

Il senso della frase era:


"Se pero la variabile puntata da quel puntatore fosse stata deallocata automaticamente (cioè deallocata all'uscita dalla funzione), all'uscita dalla funzione il campo della classe avrebbe continuato a puntare ad una zona di memoria deallocata."


L'esempio che facevo con il puntatore ad int era il secondo, cioè è un errore passare come argomento del costruttore di una classe che ha un campo 'puntatore a T' un puntatore ad un oggetto T, se tale oggetto T è stato creato staticamente, cioè non con new o con malloc, perche tale oggetto ha un tempo di vita che dura la durata della funzione; il mio problema iniziale era appunto sapere se la costante 'stringa' "ciao" durava oltre la funzione.

Se ad esempio ho questo scenario:

class A {
    int *array;

public:
    A(int *arr) {
        array = arr;
    }
};

A* create() {
    int arr[1]={10};
    return new A(arr);
}

Dovrebbe essere un errore perchè l'array arr all'interno della funzione create è allocato staticamente, e all'uscita della funzione è deallocato e quelle posizioni di memoria sono considerate libere, giusto?

Se la risposta alla domanda precedente è 'si', mi chiedevo se per caso scrivendo:

char * c = "ciao";

il compilatore non trasformasse quest'istruzione in :

char[] = "ciao";

o

char[] = {'c', 'i', 'a', 'o', '\0'};

che dovrebbe appunto avere una vita limitata alla durata della funzione.

Ciao.

[Ziosilvio]

Originariamente inviato da anx721
Se ad esempio ho questo scenario:

class A {
    int *array;

public:
    A(int *arr) {
        array = arr;
    }
};

A* create() {
    int arr[1]={10};
    return new A(arr);
}

Dovrebbe essere un errore perchè l'array arr all'interno della funzione create è allocato staticamente, e all'uscita della funzione è deallocato e quelle posizioni di memoria sono considerate libere, giusto?

Giusto, ma leggi fino in fondo.

Se la risposta alla domanda precedente è 'si', mi chiedevo se per caso scrivendo:

char * c = "ciao";

il compilatore non trasformasse quest'istruzione in :

char[] = "ciao";

o

char[] = {'c', 'i', 'a', 'o', '\0'};

che dovrebbe appunto avere una vita limitata alla durata della funzione.

Dunque... immagino che c sia una variabile locale della funzione...
... a naso direi che si puo' fare, perche' comunque "ciao" e' una costante stringa e dovrebbe vivere quanto il programma... ma chiedo conferma.
Quello che quasi sicuramente non succede, e' la trasformazione di un puntatore in un array: di solito succede il contrario.
In effetti gli array non sono puntatori e non hanno lo stesso comportamento.

[anx721]

Ok, se qualcuno vuole darci ulteriore conferma è benvenuto...

Intanto ho fatto una prova per verificare l'indirizzo assegnato ad una costante stringa, sembra che se si creano due costanti stringa uguali in due punti diversi del programma, esse faranno riferimento alla stessa zona di memoria che conterrà una sola volta la costante stringa; quindi se inizializzo uno dopo l'altro due oggetti passandogli una costante stringa con lo stesso valore, il campo char * dei due oggetti punterà alla stessa locazione di memoria. Questo non è un problema proprio perche tanto si tratta di una costante, e qualora venisse modificata (con un'istruzione value[0] = ...) interviene un segmentation fault; ovviamente i due campi dei due ogetti possono essere riassegnati per puntarte altrove.

#include <cstdio>
#include <iostream>

class A{
	char *value;
public:
	A( char *c){
		value = c;
		printf("\n indirizzo: %d    valore: %s", value, value);
	}
};

char *createCIAO(){
	return "ciao";
}

char *createBYE(){
	return "bye";
}

A * create(int x){
	if (x == 1)
		return new A("uno");
	else
		return new A("non uno");
}

int main(){
	A a1(createCIAO());
	A a2(createBYE());
	std::cout << "\n\n";
	
	A a3("ciao");
	A a4("bye");
	std::cout << "\n\n";
	
	A *a5 = new A(createCIAO());
	A *a6 = new A(createBYE());
	std::cout << "\n\n";
	
	create(1);
	create(0);
	create(1);
	
	return 0;
}

E questo è l'output:

 indirizzo: 4199088    valore: ciao
 indirizzo: 4199104    valore: bye


 indirizzo: 4199088    valore: ciao
 indirizzo: 4199104    valore: bye


 indirizzo: 4199088    valore: ciao
 indirizzo: 4199104    valore: bye


 indirizzo: 4199118    valore: uno
 indirizzo: 4199122    valore: non uno
 indirizzo: 4199118    valore: uno