[C] allocazione di memoria

[white05]

Salve,
vorrei dei chiarimenti sull'allocazione di memoria del C perché sinceramente ho un pò di confusione.
Nel mio studio sui manuali ed a lezione ho imparato due tipi di allocazione una statica ed una dinamica.
Partiamo con quella statica, provando con il Visual C di microsoft come compilatore succede questo
un codice del tipo

void main(){

char string[5];

scanf("%s",string);

printf("%s",string);
}

dovrebbe se ho capito bene accettare una stringa composta da 4 caratteri e porre alla fine il terminatore giusto? Ora perché accade che mi accetta e ristampa a schermo regolarmente stringhe fino a 7 caratteri?? :mbe: dall'ottavo carattere mi da errore...

per quanto riguarda l'allocazione dinamica un codice di questo tipo
void main(){

char *stringa;

stringa = (char*)(malloc(sizeof(char)));

scanf("%s",stringa);

printf("%s",stringa);

}

dovrebbe, se ho ben capito, accettare solo stringhe di un carattere essendo sizeof(char) uguale ad un byte.
Ebbene allora perché se scrivo parole lunghissime (ho provato con supercalifragilistichespiralidoso :D ) me le accetta e me le ristampa a schermo regolarmente??

A questo punto credo di aver capito ben poco...:doh:

Quindi vi chiedo umilmente spiegazioni perché in qualunque manuale leggo la storia è sempre la stessa...:muro:

[Steel Jans]

Il tuo esempio funziona benissimo.

Con il C puoi rappresentare le stringhe in due modi

o con la classica dichiarazione
char frase[dimensione]

o tramite puntatori
char *frase

nel secondo caso hai si dichiarato una variabile puntatore di tipo char, ma anche una stringa! Per questo il tuo esempio "sembra" che non funzioni bene.

Se hai studiato il C saprai bene che vettori e puntatori sono in strettissima correlazione.

[cionci]

C non fa il controllo sulla dimensione di destinazione. Benvenuto nel meraviglioso mondo del buffer overflow :O
Entrambi i programmi da te presentati non terminano la lettura a 4 caratteri.
Per ovviare al problema in C si usa un'altra istruzione per leggere le stringhe che ha un controllo sulla quantità di caratteri letti:

char str[5];

fgets(str, 4, stdin);

Attenzione: i cartteri eccedenti rimangono nel buffer di input.

[white05]

Il tuo esempio funziona benissimo.

Con il C puoi rappresentare le stringhe in due modi

o con la classica dichiarazione
char frase[dimensione]

o tramite puntatori
char *frase

nel secondo caso hai si dichiarato una variabile puntatore di tipo char, ma anche una stringa! Per questo il tuo esempio "sembra" che non funzioni bene.

Se hai studiato il C saprai bene che vettori e puntatori sono in strettissima correlazione.

Si ma infatti il mio problema non è che il programma non funziona ma che funziona!!! Pensavo non dovesse funzionare...


C non fa il controllo sulla dimensione di destinazione. Benvenuto nel meraviglioso mondo del buffer overflow

e allora perché tutti i manuali dicono che se dichiari un array di 5 elementi non ne puoi inserire più di 5?? Oppure perché in malloc e calloc è necessario specificare la dimensione esatta da allocare se qualsiasi cosa inserisco comunque la accetta?? Tanto vale allocare un numero a caso no? :mbe:
non capisco...

[AnonimoVeneziano]

Si ma infatti il mio problema non è che il programma non funziona ma che funziona!!! Pensavo non dovesse funzionare...




e allora perché tutti i manuali dicono che se dichiari un array di 5 elementi non ne puoi inserire più di 5?? Oppure perché in malloc e calloc è necessario specificare la dimensione esatta da allocare se qualsiasi cosa inserisco comunque la accetta?? Tanto vale allocare un numero a caso no? :mbe:
non capisco...

Probabilmente i manuali dicono che non devi farlo, ma puoi. Il programma scrive nell'array e poi, una volta finito lo spazio di quello, va avanti scrivendo sopra ad altra roba, con molta probabilità altre aree di memoria del tuo programma (ad esempio le istruzioni del codice eseguibile o altre variabili). Quando sborda completamente dalla memoria del programma tecnicamente il programma dovrebbe crashare perchè il sistema operativo entra in protezione .

In DOS , dove non c'era la protezione, se sbordavi sul Kernel erano dolori ...

Ciao

[white05]

quindi mi sembra di capire a questo punto che il mio codice, soprattutto quello dinamico, funziona ma non è idealmente corretto uscire dai limiti allocati giusto?

[Steel Jans]

diciamo di si! Concordo con quello che dice AnonimoVeneziano. Se dichiari un vettore di 50 elementi sai che all'atto dell'esecuzione del programma verrà stanziato in memoria lo spazio per contenerlo tutto. Sta a te scrivere codice che non cerchi di leggere/scrivere oltre la 50esima posizione del vettore (pena risultati imprevedibili).
Lo stesso vale anche per variabili allocate dinamicamente. La differenza tra la variabili statiche e quelle dinamiche è il fatto che queste puoi allocarle quando ti servono e deallocarle nel momento che non sono più di nessuna utilità. questo si traduce nel fatto che hai una migliore gestione delle risorse di memoria.
Forse lavorando con dati primitivi non ti accorgi del loro beneficio, ma se ti troverai a lavorare con grosse strutture di dati magari accodate in una lista non potrai farne a meno.

Riguardo ai vettori ti do un suggerimento: quando lavori con vettori impara a definire le loro dimensioni tramite costanti
es

#define num_elementi 50;
.
.
int vettore[num_elementi];

nei cicli o quant'altro utilizzerai per accedere al vettore utilizza sempre la tua costante num_elementi per verificare se ti trovi nell'intervallo degli indici ammessi in modo tale che se vorrai cambiare dimensione al vettore ti basterà modificare solo il valore di questa costante lasciando inalterato il resto del codice.

[cionci]

quindi mi sembra di capire a questo punto che il mio codice, soprattutto quello dinamico, funziona ma non è idealmente corretto uscire dai limiti allocati giusto?
Sono corretti entrambi ed entrambi soffrono dello stesso problema. Cioè un buffer overflow in caso si inseriscano troppi caratteri nel buffer. Ti ho scritto sopra come evitare il buffer overflow con l'input da tastiera.

[white05]

ok grazie mille a tutti adesso ho le idee molto più chiare :D
peccato che nei manuali non siano cosi efficienti nelle spiegazioni...o almeno non i quelli da cui ho studiato io...

[white05]

approfitto della vostra gentilezza per chiedervi un'altra cosa sempre riguardo questo argomento. Avete presente la funzione di sostituzione di una parola con un'altra? Dovrei implementarla. Ora il problema non è tanto l'algoritmo ma l'input della parola da sostituire e della nuova parola da inserire.
Per allocare lo spazio giusto per entrambe le parole dovrei sapere quanto sono lunghe e quindi fare la classica domanda 'quanto è lunga la parola?' ed acquisire il numero per poi inizializzare con calloc o malloc e quindi poi acquisire la stringhe che corrispondo alle due parole.
Ma se volessi evitare questa domanda che trovo molto poco professionale (del resto se lo facciamo in word mica ci chiede prima la lunghezza)...come fare?? grazie :help:

[cionci]

La soluzione più semplice è creare un buffer staticamente di dimensione, ad esempio, 256 caratteri ed andare a leggere un massimo di 255 caratteri con la fgets.
A questo punto copi la stringa in input in una nuova stringa che allochi dinamicamente in base alla lunghezza della stringa presa in ingresso e ce la copi.
Fai la stessa cosa per la seconda e le passi alla tua funzione.

C'è anche un'altra alternativa più complessa che consiste nel leggere carattere per carattere con getchar e ridimensionare con realloc ogni volta (in teoria si potrebbe fare a blocchi) la stringa letta aggiungendo una poszione in coda.