Newsgroup: it.comp.lang.c++
Titolo: Punto in cui dichiarare le variabili

Al seguente link, viene spiegato dove  e' opportuno inserire le
dichiarazioni delle variabili:
 
http://www.learncpp.com/cpp-tutorial/21-basic-addressing-and-variable-declaration/
 
 
 
...e vengono fatti due esempi:
 
Nel primo esempio, tutte le variabili sono dichiarate in TESTA:
 
 
=================================================
 
int main()
{
    // all variable up top
    int x;
    int y;
 
    // then code
    using namespace std;
    cout << "Enter a number: ";
    cin >> x;
 
    cout << "Enter another number: ";
    cin >> y;
 
    cout << "The sum is: " << x + y << endl;
    return 0;
}
 
========================================
 
 
Nel secondo esempio, le variabili sono dichiarate quando NECESSARIO:
 
 
====================================================
 
int main()
{
    // then code
    using namespace std;
 
    cout << "Enter a number: ";
    int x; // we need x starting here.
    cin >> x;
 
    cout << "Enter another number: ";
    int y; // we don't need y until now
    cin >> y;
 
    cout << "The sum is: " << x + y << endl;
    return 0;
}
 
=========================================
 
Viene consigliato il secondo metodo: *dichiarare le varabili nel punto
in cui vengono utilzzate*...anche voi utilizzate questo metodo?
 
Inoltre ho notato che, nell'istruzione :
 
cout << "The sum is: " << x + y << endl;
 
 
che restituisce la somma di x e y, si sarebbe potuto, in alternativa,
memorizzare prima il risultato in una nuova varabile intera z, es. z=x
+y e poi eseguire il comando:
 
cout << "The sum is: " << z << endl;
 
Quando e' piu' opportuno utilizzare il caso alternativo, con
l'utilizzo di una nuova varabile z?
 
Ciao e grazie mille!
 
 
 
 
 


 
 
-- 
1) Resistere, resistere, resistere.
2) Se tutti pagano le tasse, le tasse le pagano tutti
Soviet_Mario - (aka Gatto_Vizzato)
 

 domanda mi è parsa banale solo in apparenza.
 
[cut]
 
...esponi concetti che per me sono troppo avanzati..cmq ti
ringrazio...certamente rileggero'  questo thread ed altri suggerimenti
dati in questo ng quando saro' piu' padrone della materia.
 
Relativamente al discorso sul dove e' piu' opportuno dichiarare le
variabili (tutte in testa o solo dove si utilizzano), cosa
suggerisci?...sei d'accordo con l'indicazione data nel tutorial di
dichiarare le variabili solo quando vengono utilizzate (come nel
secondo caso dell'esempio)?
 
Ciao e grazie milleeeee!
 
 
 
 

 Ciao e grazie milleeeee!


 inizializzazione.
 
[cut]
 
Puoi fare qualche semplice (se possibile) esempio a riguardo?
 
 
Ciao e grazie milleeeee!


 
class A {
	A(int x) {  ... }
};
 
 
la classe A  non ha un costruttore A()
quindi la seguente dichiarazione:
 
 
A a;
non è valida
 
 


ottimo esempio.
A volte, laddove questo è eccessivamente limitativo, può 
bastare rendere PRIVATE o PROTECTED i costruttori che non 
devono essere usati esternamente per istanziare, ma a solo 
consumo interno. Nel privato, spesso una classe ha necessità 
di maggiore spazio di manovra.
ciao
CCCP


 in cui vengono utilzzate*...anche voi utilizzate questo metodo?
 
Si. Dichiara *ed inizializza* le variabili *immediatamente prima* del loro uso 
possibilmente in una sola istruzione.
 


 
 
Per esempio usando l' ereditarietà o  classi/funzioni friend,o chiamati 
da altri costruttori pubblici, altrimenti non hanno nessuna utilità i 
costruttori protected o private.
Comunque, un esempio di come ho proposto,nei programmi reali non succede 
sempre,anzi quasi mai.
Una classe ha quasi sempre un costruttore A() perfettamente compatibile 
con la logica della classe stessa
Ne nostro caso:
 
class A {
	explicit A(int x=0) {  .. }
};
 
potrebbe essere un costruttore logico per la classe.
explicit serve per evitare costrutti del genere:
 
A a=5;
 
Ma ad esempio in una classe di questo genere:
 
class positive_number {
	positive_number(long x=<init_value>) {... }
};
 
a che valore si inizializza <init_value> ?
0, ovviamente, non è valido per il dominio del problema
Qualcuno potrebbe dire 1 in quanto è il primo simbolo valido nel dominio 
di positive_number, ma sono titubante su questo
 
 


Quindi, ritornando all'esempio del tutorial, potrei inizializzare le
variabili intere x e y a zero *prima* dell'imput dell'utente?
 
====================================================
 
int main()
 {
     // then code
     using namespace std;
 
    cout << "Enter a number: ";
     int x=0; // we need x starting here.
     cin >> x;
 
    cout << "Enter another number: ";
     int y=0; // we don't need y until now
     cin >> y;
 
    cout << "The sum is: " << x + y << endl;
     return 0;
 
}
 
=========================================
 
Ciao e grazie milleeeee!
 
 
 

 possibilmente in una sola istruzione.
 
Questa io non la consiglio. Per come sono fatti i compilatori e per come la gente
legge il codice, direi di mettere sempre il tutto all'inizio del blocco
(ovviamente aprendo e chiudendo i blocchi in maniera decente).
 
Ciao!


 
 


 Ciao!



 
Ora che sai,a che valore posso impostare init_value ?
 


 
Ognuno ha naturalmente i propri pensieri, ma pensate a questo:
 
{ // inizio blocco
	T x;   // T è una classe, non un tipo semplice e viene chiamato
		// il costruttore T()
	....   // un po di operazioni fino ad avere il valore
		// per 	reinizializzare x e lo chiamo y
	T  y(...);
 
	x = y; // qui viene chiamato operator =
	...  // altre cose
}
 
 
1) puo succedere un errore logico: x viene usato prima di x=y
 
2) ottimizzazione: riuscirà il compilatore ad eliminare l' istruzione T 
x e sostituire x=y con T x(y) ?
 
 
 
 
 
 


Cosa vuoi dire con "per come sono fatti i compilatori"? Le variabili 
dichiarate all'inizio di un blocco erano frutto delle prime versioni dello 
standard C, dove non era possibile fare altrimenti, ma oggi questa limitazione 
è stata superata anche dal C. Per quanto riguarda il C++, non ho mai letto 
alcun autore che abbia esplicitamente suggerito o preferisca, per qualche 
valido motivo,  dichiarare le variabili all'inizio di un blocco; ho anzi 
spesso letto di diversi vantaggi nel dichiarare una variabile immediatamente 
prima del suo uso: alcuni vantaggi sono prettamente soggettivi, come la 
leggibilità del codice, altri meno, come la possibilità per l'ottimizzatore di 
generare codice più efficiente (per motivi che ora tralascio).
 

 variabili intere x e y a zero *prima* dell'imput dell'utente?
 
Esatto (considera che l'input può fallire).
 


Ho spiegato questo (l' ottimizzazione) in un altro thread di questo post
 


ogni valore ammissibile per il tipo long.
Se poi c'è qualche throw nel costruttore, o qualche assert, 
potresti rendere incompilabile con alcuni valori (es. 
negativi). Ma non è una costrizione intrinseca, sono 
precauzioni da codificare a manina



non dissento certamente. PEr dichiarazioni di variabili, 
avevo in mente soltanto quelle i cui costruttori sono 
triviali (o mancanti) e privi di effetti collaterali.
Già se devono fare qualche new, avranno sicuramente una 
logica di scope tutta loro peculiare che non contempla certo 
l'accatastarli insieme.



A parte i  vari controlli interni, l' oggetto deve essere inizializzato 
ad un valore valido al dominio del problema, quindi ad un valore
  0 < x <= LONG_MAX e  quindi ogni valore ammissibile per long non va bene
 
 
 


Il punto 2) per una variabile semplice non comporta particolari problemi.
Il punto 1) comunque non è risolto