[Esercizio C] Spiegare dov'è l'errore nel seguente codice

[-Ivan-]

Mi sono trovato a fare questo esercizio ma non ho capito bene dov'è l'errore e come correggerlo.
Alla prima chiamata ad f() crasha nel momento in cui accede a *str2.
Penso lo scopo sia quello di memorizzare str2 in str1.
str1 non causa problemi, è str2 a causare il crash.

Mi sapete dare un indizio del motivo per cui succede?

Sono molto insicuro sulla gestione di str2 perchè è un array.
So che essendo str1 un puntatore posso eseguire tutte le operazioni di aritmetica con i puntatori del tipo *(string1+1) per accedere al secondo elemento nell'array e così via, invece con la dichiarazione string2[] non sono certo che questo si possa fare.


void f(char *str1, char *str2)
{
//while( *str1++ != 'a' ) would work, str2 is the problem

while( *str++ = *str2++ );
}

int _tmain(int argc, _TCHAR* argv[])
{
char *string1="test";
char string2[256];
f(string1, string2);


cout << string1 << string2 << endl << endl;

return 0;
}

[airon]

Ciao allora ti metto in bold le cose che vedo di errori di sintassi poi passimoa alla logica.


void f(char *str1, char *str2)
{
//while( *str1++ != 'a' ) would work, str2 is the problem

while( *str1++ = *str2++ ) ; //str non esiste la var è str1
}

int _tmain(int argc, _TCHAR* argv[])
{
char *string1="test";
char string2[256];
f(string1, string2);


cout << string1 << string2 << endl << endl;

return 0;
}



Secondo me il problema è copiare str1 in str2 e non il contrario e io farei così:



void f(char *str1, char *str2)
{
//while( *str1++ != 'a' ) would work, str2 is the problem

while( *str1 != '\0')
{
*str2++ = *str1++ ;
}
}

int main()
{
char* string1="test";
char string2[256];
f(string1, string2);


printf("%s", string2);

return 0;
}


Se così non fosse il tuo problema è cmq sull'accesso a spazi di memoria non allocati dal programma, se non fai nessun controllo sul fine stringa o vai a posizioni sbagliate (string 2 ha 256 posizioni e le vuoi mettere su sttring1).

[-Ivan-]

...


Purtroppo devo mantenere la stessa struttura, non posso cambiare la funzione se non per correggere il problema che causa il crash.

Non ho ancora capito dove sia il problema, per ora la mia idea è questa:

str1 dentro la funzione memorizza l'indirizzo della prima lettera della stringa in memoria, questa potrebbe essere diciamo all'indirizzo 5000.
str1++ mi manda all'indirizzo seguente, diciamo 5002 e dunque facendo *str1++ ottengo la seconda lettera e così via.

str2 dentro la funzione memorizza l'indirizzo della prima lettera in string2, supponiamo all'indirizzo 2000.
Facendo str2++ dovrei (credo) andare all'indirizzo 2002 (mi sto sempre inventando i numeri) ed accedere al secondo elemento dell'array.
Questo però sembra non essere vero.

[airon]

Eh ma scusa il while ha dentro:

*str++ = *str2++ (a parte che deve essere str1)


Tu stai associando a str1 quello che trovi in str2.

str1 ha 4 caratteri
str2 ne ha 256

Come puoi mettere dentro str1 256 caratteri? E' un puntatore ad una stringa che in memoria, in fase di compilazione ha 4 spazi non 256. Se inverti i due puntatori ovvimaente ti va ma copi str1 in 2 come da logica dovrebbe essere :D

[-Ivan-]

Eh ma scusa il while ha dentro:

*str++ = *str2++ (a parte che deve essere str1)


Tu stai associando a str1 quello che trovi in str2.

str1 ha 4 caratteri
str2 ne ha 256

Come puoi mettere dentro str1 256 caratteri? E' un puntatore ad una stringa che in memoria, in fase di compilazione ha 4 spazi non 256. Se inverti i due puntatori ovvimaente ti va ma copi str1 in 2 come da logica dovrebbe essere :D

Sì questo è vero infatti questa potrebbe essere la soluzione dell'esercizio, però perchè il programma originale come da esercizio crasha subito al primo accesso a str2 e non alla quinta copiatura?
Temo di dover spiegare anche questo.

[bancodeipugni]

beh è ovvio, nel ciclo devi controllare il finestringa

[bancodeipugni]

anche

è vero è vero è vero....

dovrebbe dare errore cosi'

ma perché non dichiara direttamente le string ??

[airon]

Scusate ma io ricordo che è solo in C che la definizione del puntatore è implicitamente const (anche se si omette è solo read only quindi non si può cambiare direttamente il valore).

E' così anche in C++ o faccio confusione?

[-Ivan-]

Quindi non c'è nessun modo possibile per far funzionare la funzione lasciando la dichiarazione di string2 così come è nel main?

[-Ivan-]

non vedo perche' ti preoccupi di str2. il problema e' in str1...

Se le dichiaro così nel main:

char string1[]="test";
char string2[256];

il ciclo while è infinito e crasha per questo motivo.
Ho bisogno di mettere un paio di punti fermi:

1)
char *string1="test";
char string2[256];

f(string1, string2);

passa alla funzione f l'indirizzo contenuto in string1 (indirizzo del char 't' di 'test') e l'indirizzo del primo char di string2.

2)
*str1++ nella funzione f sta eseguendo prima il ++ spostandosi al carattere successivo nella stringa e poi il dereference per prendere il valore contenuto a quell'indirizzo.

Allo stesso modo
*str2++ si sta spostando all'indirizzo successivo dell'array prendendone il contenuto con *.

Sono corrette queste due affermazioni o c'è qualcosa che non so o che so in modo sbagliato?

[Oceans11]

c'e' una grossa differenza tra
char *string1 = "test"
e
char string1[] = "test"


la difficoltà del c sta tutta qua e nel decadimento degli array a puntatori.

[airon]

Rieccomi,

allora ho fatto un po' di confusione :D

char *p = "stringa";

che io sappia è un'istruzione valida (almeno in C)

p è un puntatore (e quindi contiene l'indirizzo di memoria della stringa "stringa"). Non posso variarne il contenuto.

se io stampo *p mi stampa "stringa".

Non posso però cambiare i caratteri di "stringa". Ed è questo l'errore del programma. Posso volendo cambiare l'indirizzo a cui punta p facendo:

p = "nuova stringa".

Se stampo di nuovo *p esce "nuova stringa", se stampo p stampo l'indirizzo in memoria di "nuova stringa".

Giusto no? :D

[vendettaaaaa]

c'e' una grossa differenza tra

char *string1 = "test"

e

char string1[] = "test"


inoltre

*str++ il post incremento si chiama appunto post incremento perche' viene eseguito dopo la valutazione dell'espressione... quindi la tua considerazione 2) e' sbagliata
Dato che ho sempre usato C++ e non C, e da un pezzo non smanetto con ste cose me le sto dimenticando, la differenza sta nel fatto che
char string1[] = "test";
equivale a
char* const string1 = "test\0";
?
Son sicuro che l'array è un puntatore const, ma non ricordo se assegnare una literal ad un puntatore char non aggiunge il terminatore implicitamente.

[bancodeipugni]

il fatto è che una volta che hai dichiarato char*="qualcosa"
non puoi più variarlo, sovrascriverlo, allungare il vettore

puoi solo spostare il cursore * avanti e indietro dentro la stringa

non puoi pertanto fare riassegnazioni a quell'array

la dichiarazione char[] teoricamente uguale formalmente è diversa

vale anche per records strutturati

[Oceans11]

:D io la trovo affascinante sta faccenda di puntatori ed array

[-Ivan-]

alla fine comunque tutto si risolve semplicemente invertendo str1 e str2 in quel while... :asd:

Ok credo di esserci. Grazie delle risposte.
Non sapevo che la dichiarazione char *p = "test" poi non permettesse più di modificare il contenuto di p.

Purtroppo ho un'altra domanda :D ...
Invertendo str1 e str2 e risolvendo dunque l'esercizio, perchè il ciclo while si ferma quando incontra il \0 di fine stringa?

[Oceans11]

Ok credo di esserci. Grazie delle risposte.
Non sapevo che la dichiarazione char *p = "test" poi non permettesse più di modificare il contenuto di p.

Purtroppo ho un'altra domanda :D ...
Invertendo str1 e str2 e risolvendo dunque l'esercizio, perchè il ciclo while si ferma quando incontra il \0 di fine stringa?

perchè il null character ('\0') viene interpretato come 0 nella determinazione della condizione del ciclo while, il resto è precedenza di operatori, viene prima valutata la parte destra dell'assegnazione, poi viene effettuata quest'ultima.

[van9]

rispondo a tutti...

la differenza è che

char *p = "ciao"

definisce nello stack un puntatore p a char,e lo inizializza con la stringa "ciao". ma da dove proviene questa stringa?


"Praticamente" sempre vero - è interessante però sapere che esistono implementazioni che non hanno stack e heap separati: robe arcaiche come i Burroughs systems, diverse piattaforme per l'hard realtime, piattaforme per il parallelismo... Generalmente si chiamano "cactus stack". Se la cosa vi incuriosisce, l'architettura dietro Cilk++ di Intel (che è vero non è ne' C ne' C++ e quindi esula dalla discussione, ma può tornarvi più utile che magari guardarvi strani compilatori per macchine hard realtime che non vedrete mai all'opera...) fa più o meno così.

In effetti, sorprende sempre molti scoprire che lo standard non la contiene nemmeno la parola "stack".


tu non stai assegnando esplicitamente l'indirizzo di memoria, quello che accade è che il compilatore mette un buffer "ciao\0" nella sezione .rodata e p punterà a questo buffer.


Spesso ma non sempre, anche perché ad essere precisi lo standard dice solo che avrà static storage lifetime e che accedendovi in modifica si avrà undefined behavior (e pure qualcos'altro che adesso non ricordo). Ci sono un sacco di sistemi e formati che un'area read-only non ce l'hanno, ed è per supportare una certa massa di codice preesistente che

"Some compilers have a switch controlling whether string literals are writable or not (for compiling old code), and some may have options to cause string literals to be formally treated as arrays of const char (for better error catching)."

http://c-faq.com/decl/strlitinit.html


Interessanti questioni architetturali a parte, per cavarsela sempre e comunque ricordiamo che basta agire seguendo:

https://www.securecoding.cert.org/confluence/display/seccode/STR30-C.+Do+not+attempt+to+modify+string+literals


char p[] = "ciao"

definisce nello stack un array di 5 char, puntati da p. Puoi farci quello che vuoi finchè rimani nello scope di visibilità della funzione che l'ha definito.

in C ti viene insegnato che la notazione a puntatore è sempre equivalente a quella a parentesi quadre... non sempre vero.

Non è vero, solo quando libri e istruttori sono very sloppy! Quella dell'equivalenza è una vecchia storia che ha sempre causato grossi danni, quando invece basterebbe ricordare solo che il nome dell'array *decade* a puntatore salvo le tre note eccezioni (di cui una è proprio quella sugli string literals).


Il tutto senza voler essere pedante ma solo per ricordare quanto la programmazione di sistema sia vasta, affascinante e ... possa causare parecchi incubi!