[C/++] chiarimenti sulla copia di stringhe const

[Duchamp]

Salve a tutti.
Ho realizzato una banalissima classe che ha come variabile privata un const char *txt, in altre parole una stringa.
Per gestire il valore di questa variabile mi sono inventato due metodi:

void addTxt( const char *txt ) {
   _txt = txt;
}
void printTxt() {
  printf( "%s\n", _txt );
}

(notare l'underscore per la variabile privata). Tutto liscio quando chiamo la funzione come

addTxt( "abcdef" );

e stampo il valore di _txt.
Ora la parte poco chiara: non capisco come mai riesca a passare alla funzione anche un array di caratteri, il classico char str[xxx], senza che il compilatore si lamenti. L'assegnazione avviene senza problemi, se debuggo e stampo il "contenuto" di _txt all'interno di addTxt leggo la stringa voluta: ottengo invece spazzatura se chiamo printTxt.
Sarei curioso di capire le dinamiche che avvengono nella scatolina nera, naturalmente ringraziando in anticipo per la vostra disponibilità.

[DanieleC88]

Originariamente inviato da Duchamp

Ora la parte poco chiara: non capisco come mai riesca a passare alla funzione anche un array di caratteri, il classico char str[xxx], senza che il compilatore si lamenti.

Questo è normale. Quando tu scrivi:

char buffer[100] = "....";

[...]

funzione(buffer);

quello viene tradotto implicitamente come:

funzione(&buffer[0]);

quindi come un puntatore al primo carattere della stringa.

Originariamente inviato da Duchamp

L'assegnazione avviene senza problemi, se debuggo e stampo il "contenuto" di _txt all'interno di addTxt leggo la stringa voluta: ottengo invece spazzatura se chiamo printTxt.

Su questo non posso darti una risposta certa senza vedere il resto del codice, ma cerco di interpretare: quando tu dichiari un'array di char, ciò che effettivamente fai è di allocare un buffer di dimensione fissa sullo stack, nel record di attivazione della funzione in cui è dichiarato. Quindi, quando vai a fare quell'addTxt() leggi correttamente il puntatore che in quel momento è valido, ma magari poi esci dalla funzione che fa addTxt() e ne chiami un'altra che fa printTxt(): in quel caso l'area allocata dalla prima funzione sullo stack è persa (è stata cancellata o sostituita dalla seconda chiamata a funzione), e quindi il puntatore che printTxt() conosce punterà a qualcosa che non è più esistente, e perciò la spazzatura.

ciao

[Duchamp]

Carissimo DanieleC88, prima di tutto ti ringrazio perchè la seconda parte della tua risposta è stata illuminante: in poche parole dovrei dimenticare l'allocazione statica del buffer char[...] e considerare quella dinamica, per risolvere il problema!
L'ho sparata grossa?
Per quanto riguarda il primo esempio che hai riportato,
vorrei capire meglio quanto segue: quale sarebbe il prototipo della funzione

funzione(&buffer[0])

?

[DanieleC88]

Originariamente inviato da Duchamp

Carissimo DanieleC88, prima di tutto ti ringrazio perchè la seconda parte della tua risposta è stata illuminante: in poche parole dovrei dimenticare l'allocazione statica del buffer char[...] e considerare quella dinamica, per risolvere il problema!
L'ho sparata grossa?

No, in teoria così funzionerebbe. Ma tieni conto che io ti ho risposto senza vedere il codice effettivo, quindi andavo solo secondo logica.

E comunque in realtà l'allocazione statica va benissimo, ma solo nei casi in cui non utilizzerai mai le variabili dopo che sono uscite dal loro contesto di visibilità.

Ti faccio un esempio in codice:

#include <stdio.h>

int *salvato;

void salva_puntatore(int *riferimento)
{
    salvato = riferimento;
}

void usa_puntatore()
{
    (*salvato) = 10;
}

int main()
{
    int x = 0;

    salva_puntatore(&x);
    usa_puntatore();
    printf("x = %d;\n", x);

    return 0;
}

In questo caso va benissimo, perché la variabile intera che è definita nel main() viene persa solo quando si esce con il return 0, e quindi il puntatore che viene salvato è poi letto ed utilizzato correttamente, proprio perché punta ad un'area di memoria ancora "viva".

Se invece avessi fatto una cosa del tipo:

#include <stdio.h>

int *salvato;

void salva_puntatore()
{
    int x = 0;

    salvato = &x;
}

void usa_puntatore()
{
    (*salvato) = 10;
    printf("salvato = %d;\n", (*salvato));
}

int main()
{
    salva_puntatore();
    usa_puntatore();

    return 0;
}

questa non sarebbe andata bene, perché la variabile intera viene definita in salva_puntatore(), e viene quindi allocata staticamente quando invochi tale funzione. Salvando il puntatore all'area di memoria che occupa in quel momento, quando salva_puntatore() termina, avrai un riferimento ad un'area di memoria che non esiste più. Perciò usa_puntatore() quasi certamente darà luogo ad un crash.

Nota che questa è una regola generale, e vale anche per l'allocazione dinamica: le aree di memoria che allochi sono valide solo nell'intervallo di tempo tra una malloc() e una free().

Originariamente inviato da Duchamp

Per quanto riguarda il primo esempio che hai riportato,
vorrei capire meglio quanto segue: quale sarebbe il prototipo della funzione

funzione(&buffer[0])

?

Potrebbe essere:

[tipo] funzione([const] char *s);

o anche:

[tipo] funzione([const] char s[]);

che per il compilatore hanno lo stesso significato (la seconda viene implicitamente tradotta nella prima).

Nota: con [tipo] voglio denotare un generico tipo di ritorno della funzione, mentre con [const] voglio indicare che può essere o non essere const, a seconda della tua scelta.

ciao

[Duchamp]

Chiarissimo, non ho davvero nulla da aggiungere. Per il "const" sono obbligato ad usarlo, poichè dichiarare char *c in c++ è considerato deprecated.
Questa discussione me la salvo! Grazie e alla prossima

[tomminno]

Ma visto che si parla di stringhe e C++ perchè non usare la classe string?
Questa discussione sta riguardando le stringhe C.

[DanieleC88]

Originariamente inviato da Duchamp

Chiarissimo, non ho davvero nulla da aggiungere. Per il "const" sono obbligato ad usarlo, poichè dichiarare char *c in c++ è considerato deprecated.

Questo perché in C++ c'è la classe std::string che è molto più comoda (e sicura) da utilizzare, come puoi leggere anche nella giustissima osservazione di tomminno.