Newsgroup: it.comp.lang.c++
Titolo: const-correctness senza reference

Salve,
avrei il seguente quesito, riguardante la const-correctness C++, per cui
mi appello agli esperti del NG:
Se ho una funzione, tipo:
float pitagora( float x, float y )
{
  return sqrt(x*x + y*y);
}
i parametri in input x e y non vengono modificati dalla funzione. Poiche'
si tratta di passaggio *per valore*, non c'e' bisogno di specificare il
modificatore "const" nella signature, cioe', non c'e' bisogno di scrivere:
float pitagora( const float x, const float y ) ...
giusto??
Oppure quest'ultimo prototipo ha qualche sfumatura in piu' rispetto al
precedente, e mi sfugge?
Credo di aver chiaro l'uso del const quando vi sono puntatori o reference,
es.
// non modifico v
float lunghezza( const Vector & v );
Pero' quando si usano tipi "primitivi" come il float, come nell'esempio
precedente, l'uso di const *non* e' necessario, vero?
Grazie a chi vorra' chiarirmi a riguardo,
Dan

 giusto??
Giusto.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic

 precedente, l'uso di const *non* e' necessario, vero?
Torna cosi` anche a me. In effetti se fai una copia, modificherai
comunque la copia.
-- 
Adesso quando i medici di turno rifiuteranno di esserti d'aiuto / perchè
venne un polacco ad insegnargli che è più cristiano imporsi col rifiuto
pretenderanno che tu torni indietro/e ti costringeranno a partorire per
poi chiamarlo figlio della colpa / e tu una Maddalena da pentire

 giusto??
Giustissimo. Addiruttura per il C++ le due signature sono assolutamente
equivalenti.
Ciao,
Nicola


Dichiarando i parametri const sei sicuro di non modificarli per errore.
--
Leo

 Dichiarando i parametri const sei sicuro di non modificarli per errore.
...veramente la mia domanda era un po' diversa :)
Comunque colgo l'occasione per ringraziare gli altri che hanno risposto
chiaramente, confermando quanto avevo in mente.
Ciao
Dan


Hai scritto:
 >i parametri in input x e y non vengono modificati dalla funzione. >Poiche'
 > si tratta di passaggio *per valore*, non c'e' bisogno di specificare >il
 > modificatore "const" nella signature, cioe', non c'e' bisogno di 
 >scrivere:
ecc
Il fatto che i parametri non siano reference non esclude l'uso
di const. Usando f(const x, const y) assicuri a compile-time che x,y
non possono cambiare (neanche per un errore del programmatore).
Ciao
Leo

 non possono cambiare (neanche per un errore del programmatore).
E come potrebbero? Vengono comunque *copiati* e poi si lavora sulla
copia. Con o senza const. Oppure io non ho capito quello che volevi
dire.


hola,
intendevo all'interno della funzione.
Leo


 intendevo all'interno della funzione.
Ah, OK :)
sorry

 inserire linee di commento
Su questo sono perfettamente in disaccordo. Ma fa lo stesso. :))


 
uhm, sono sorpreso .... forse mi sono spiegato male.
Intendevo dire che se un linguaggio mi permette di costruire 
direttive (discrezionali) tramite le quali regolamentare la mia 
stessa codifica senza poter facilmente barare, tenderà più a 
favorire l'ordine nella codifica stessa e a evitare sviste ed 
effetti collaterali.
In effetti questo non è mutualmente esclusivo ad una corretta 
documentazione del codice, ma complementare.
Con la documentazione (commenti) si raggiunge un ordine di 
livello più astratto, superiore diciamo, peraltro facilmente 
aggirabile (ciò che può essere error prone), mentre con le 
strutture semantiche intrinseche del linguaggio si ha un 
controllo più a basso livello ma molto saldo.
Es : se voglio essere sicuro che un dato metodo possa essere 
richiamato solo su oggeggi const, lo dichiaro const meglio che 
denominare la funzione MetodoCostante (), questo volevo dire.
Ovviamente .... eh eh he puoi ancora essere in perfetto 
disaccordo. Dipende anche dall'ordine mentale spontaneo di 
ciascuno. Io ho memoria molto corta e scordo subito le funzioni 
scritte la settimana precedente.
ciao
Soviet-Mario

 scritte la settimana precedente.
Io invece sono abituato con linguaggi estremamente dinamici e di alto
livello, e per abitudine preferisco rifarmi a convenzioni che nel caso,
a mio rischio e pericolo (sto violando il contratto, ergo sono "fatti
miei") posso infrangere, rispetto a costrutti del linguaggio che in
genere posso comunque evadere, ma facendo molto piu` casino.


 voglio :))
Questo e' come dire che siccome guidi con prudenza e' sbagliato che i
costruttori ti obblighino a comprare macchine con le cinture di
sicurezza.
La disciplina e' imprescindibile, ma se il compilatore ti da una mano,
perche' rifiutarla? Senza contare che, piu' sei esplicito nelle tue
intenzioni piu' chiaro sara' agli altri il tuo codice.
Senza contare che nessuno ti obbliga a dichiarare i parametri, o
qualsiasi altra variabile, const.
Ciao,
Nicola

 qualsiasi altra variabile, const.
Il mio era un discorso piu` vasto, non e` sulle "piccole" cose, come per
esempio i const (cose che peraltro ho anche in altri linguaggi che uso
-- o meglio, ho costrutti che si comportano in modo simile -- e che
quando non ho un poco mi mancano, e mi trovo a scrivere le estensioni
che si comportano cosi` in C++, per l'appunto.)
-- 
Adesso quando i medici di turno rifiuteranno di esserti d'aiuto / perchč
venne un polacco ad insegnargli che č piů cristiano imporsi col rifiuto


Salve a tutti,
mi trovo abbastanza daccordo con Soviet_Mario.
Io personalmente se un parametro è di input metto il 
qualificatore const davanti per 2 motivi : 
1-Chi legge il prototipo della funzione capisce al volo che 
è un parametro di input.
2-Se è un parametro di input perchè mai dovrebbe essere 
modificato ? 
E' Comnunque una questione filosofica come detto in precedenza.
Ciao a tutti.
__
Niente e nessuno al mondo 
potrà fermarmi dal ragionare.
--  
Postato da Virgilio Newsgroup 
http://newsgroup.virgilio.it
Completo come il newsreader, ma senza il newsreader

 modificato ?
In ogni caso se il parametro formale non e' definito come puntatore o
reference il parametro attuale non viene modificato, quindi a livello
di prototipo non fa differenza.
Puo' essere preferibile modificare direttamente un parametro che non
copiarlo su una variabile locale.
Ciao,
Nicola


Il volatile è equiparato al const.
Standard, 13.1/3:
Parameter declarations that differ only in the presence or absence of
const and/or volatile are equivalent. [...]
ciao,
gianluca