[C] alcune pignolerie di sintassi...

[}gu|do[z]{®©]

Ciau,
mi sto preparando per un esame di programmazione che non mi hanno riconosciuto in un cambio di facoltà... non avevo mia fatto C... l'esame è a breve e sto facendo un po' di esercizi.. bene o male lli faccio tutti bene.. ma noto nelle soluzioni proposte dal prof alcune cose che onon mi sono del tutto chiare...

1) funzione(const char* stringa)
lui usa smpre const.. che cambia? io non lo uso mai

2) lui dichiara spesso variabili in qualsiasi punto del codice... io ero abituato a dichiararle sempre all'inizio delle funzioni... cambia qualcosa oltre alla legibilità? beh.. se lo fa lui posso farlo anche io cmq

3) ero abituato (dal testo che ho usato) a esplicitare sempre un casting per il puntatore restituito da malloc, lui non lo fa.. esempio:

io:
char* stringa = (char*) malloc(sizeof(char)*10);
lui:
char* stringa = malloc(sizeof(char)*10);

capisco che effettivamente è un po' ridondante... ma sul mio testo lo fa sempre e comunqu e avevo preso quest'abitudine... quando va esplicitato e quando no?


Per ora basta così

[anx721]

1) funzione(const char* stringa)
lui usa smpre const.. che cambia? io non lo uso mai

mettendo const dici al compilatore che la variabile passata non è modificabile, quindi ad esempio se nella funzione cerchi di fare qlcosa del tipo stringa[0] = '2' ti dà errore. Ad esempio se vuoi fare una funzione per calcolare la lunghezza di una stringa e vuoi garantirti che la funzione non modificherà l'argomento lo puoi dichiare const.

lui dichiara spesso variabili in qualsiasi punto del codice... io ero abituato a dichiararle sempre all'inizio delle funzioni... cambia qualcosa oltre alla legibilità?

direi di no.

3) ero abituato (dal testo che ho usato) a esplicitare sempre un casting per il puntatore restituito da malloc, lui non lo fa.. esempio:

io:
char* stringa = (char*) malloc(sizeof(char)*10);
lui:
char* stringa = malloc(sizeof(char)*10);

capisco che effettivamente è un po' ridondante... ma sul mio testo lo fa sempre e comunqu e avevo preso quest'abitudine... quando va esplicitato e quando no?

Il C effetua atuomaticamente i cast fra le variabili, a differenza del C++; in C++ sarebbe corretto solo il tuo codice, ma non quello del prof, a meno di non dire al compilatore di non preoccuparsi delle icncpompatibilità di tipo (passandogli l'opzione -fpermissive nel caso del g++). Il C++ è da questo punto di vista un linguaggio più 'sicuro', difatti spesso anche chi programma in C utilizza il g++ per compilare, perchè effettuando più controlli a tempo di compilazione rileva subito degli errori, che nonsarebbero rilevati dal C. Personalmente ritengo buona regola di programmazione esplicitare tutti i cast, cosi se stai commettendo qualche erorre te ne accorgi.

[}gu|do[z]{®©]

Originariamente inviato da anx721
mettendo const dici al compilatore che la variabile passata non è modificabile, quindi ad esempio se nella funzione cerchi di fare qlcosa del tipo stringa[0] = '2' ti dà errore. Ad esempio se vuoi fare una funzione per calcolare la lunghezza di una stringa e vuoi garantirti che la funzione non modificherà l'argomento lo puoi dichiare const.

ok.. + o meno c'ero... ma mi rimane il dubbio sul fatto che il compilatore dia errori... non l'ho provato [ok, lo faccio ] ma mi è parso di vedere nel codice del prof modifiche a stringhe passate con const.. e non capivo quindi se const fa sì che le modifiche vengano annullate quando il controllo torna al chiamante, o se proprio da waring o errori il compilatore...

Cmq è solo una buona abitudine (come quella del casting esplicito) giusto? quindi see ce lo metto o non ce lo metto non mi cambia il compito vero? [il compito è su carta.. non c'è il compilatore che mi aiuta sigh]

dankeshe

[anx721]

Il gcc non dà errori, tanto per cambiare, da solo il warning, mentre il g++ dà errori, anche se a sto punto non vedo perchè dichiarare il parametro const se poi si vuole modificarlo. Comunque le modifiche sono effettive, non valgono solo nella funzione, ma anche dopo.

I cast non modificano il codice, quindi puoi metterli tranquillamente.

[}gu|do[z]{®©]

Originariamente inviato da anx721
Il gcc non dà errori, tanto per cambiare, da solo il warning, mentre il g++ dà errori, anche se a sto punto non vedo perchè dichiarare il parametro const se poi si vuole modificarlo. Comunque le modifiche sono effettive, non valgono solo nella funzione, ma anche dopo.

denghiù

vabbè allora vuol dire solo che se il prototipo che ci da il prof ha const... mi deve scattare il campanellino d'allarme e non devo fare modifiche...

è solo che mi è parso di vedere in qualche esercizio sulle liste che prendeva una lista come const... e poi per scorrerla faceva:

while(lista != NULL)
{
bla bla
lista = lista->next;
}

o mi sbaglio io a ricordare o si sarà distratto lui in quella soluzione [che mo' in mezzo a 200 non trovo ]

in un caso del genere dovrei fare una copia della lista e scorrerla con la copia, giusto?

Tnx

[Ikitt]

Originariamente inviato da }gu|do[z]{®©
e poi per scorrerla faceva:

while(lista != NULL)
{
 bla bla
 lista = lista->next;
}

Beh questo modifica il puntatore locale, (passaggio per valore sempre, in C), non altera la struttura dati originaria.
E` quindi coerente con l'uso un parametro const...

[}gu|do[z]{®©]

Originariamente inviato da Ikitt
Beh questo modifica il puntatore locale, (passaggio per valore sempre, in C), non altera la struttura dati originaria.
E` quindi coerente con l'uso un parametro const...

sì appunto.. ma il puntatore è passato come const no?

typedef struct elemento
{
bla bla bla
} list;


funzione(const list* lista)

lista è un puntatore alla struct.. nel momento in cui faccio

lista = lista->next;

modifico il puntatore.. ma il puntatore era const...

no?

[anx721]

Allora, la questione non è proprio come l'hai capita tu. Come già ti dissi in un altro post, quando passi un argomento ad una funzione, questo viene sempre passato per valore, cosicchè anche se lo modifichi all'interno della funzione, all'uscita resta col valore originario. Per modificare una variabile devi invece passare il puntatore alla variabile e non la variabile stessa.

Questo significa che ogni qualvolta passi ad una funzione un puntatore, all'interno della funzione puoi modificare la variabile puntata da quel puntatore.

Però non sempre si passa un puntatore ad una funzione per poter modificare la variabile, spesso si passa un puntatore perche ad esempio si passa una stringa (char *) o una lista come nell'esempio che facevi tu. In queso caso si puo volere che la funzione non modifichi la variabile, nonostante sia stato passato il relativo puntatore. Mettere 'const' significa appunto che non vuoi che all'interno della funzione venga modificata la variabile puntata dal puntatore passato, non che non deve essere modificato il puntatore stesso, perche questo, come ho gia detto, è sempre passato per valore e anche se venisse modificato nel corpo della funzione, all'uscita mantiene il suo valore originario.

[}gu|do[z]{®©]

Originariamente inviato da anx721
Mettere 'const' significa appunto che non vuoi che all'interno della funzione venga modificata la variabile puntata dal puntatore passato, non che non deve essere modificato il puntatore stesso, perche questo, come ho gia detto, è sempre passato per valore e anche se venisse modificato nel corpo della funzione, all'uscita mantiene il suo valore originario.

in qusto caso non mi interessava la modifica al chiamante.. ma capire meglio sta cosa del const

Tutta la questone dei puntatori e del passaggio per valore ce l'ho abbastanza chiara.. nel post che dici tu mi incasinavo con un doppio puntatore se ricordo bene...
e in effetti faccio un po' di confusione con il passaggio di puntatori come parametri di una funzione..... :\

vabbè ma in sostanza in questo caso viene passato alla funzione il valore del puntatore alla lista, giusto? quindi se modifico il puntatore all'interno della funzione non modifico quello nel chiamante.. ok.. fin qui ci sono..

ma const in questo caso.. mi impedisce di modificare il puntatore locale alla funzione, o il dato puntato?
Mi pare di capire quest'ultimo... quindi non posso cambiare niente all'interno della struct puntata?
giusto?

in sostanza "const tipo* " mi impedisce di modificare il puntato, e non il puntatore?

tnx e pardon se sono duro.. ho dovuto fare da autodidatta in 2-3 mesi perchè in segreteria a qualcuno è girato di non riconoscermi programmazione

[anx721]

Si, cio che non deve essere cambiato è il dato puntato e il motivo e quello che ti ho spiegato: passando un puntatore dai la passibilità alla funzione di cambiare la variabile puntata, se non vuoi che ciò avvenga metti il const.

struct ab{
	int el;
	struct ab *next;
};

void prova(const struct ab *io){
	io = NULL;  //cambio il puntatore: ok
}

non dà warning (o errore nel g++), mentre

void prova(const struct ab *io){
	io->el = 110;  //cambio la struttura puntata! Non va bene
}

ti dà il warning (o l'errore in g++)


P:S O:T:stai ad informatica alla spienza?