[C++] Mi spiegate queste poche righe di codice?

[zaxis]

In questi giorni, mentre studio il C++, mi aggiro per la rete in cerca di tutorials e definizioni. Andando sulla wikipedia, (http://it.wikipedia.org/wiki/C_plus_plus ) , ho trovato questo (considerato un semplice esempio )

#include <string>
 
class Message {
  std::string subject_;
  std::string from_;
   
public:
  Message (const std::string& subject,
           const std::string& from)
         : subject_(subject),
           from_   (from)
           {}
   
  std::string subject() const { return subject_; }
  std::string from()    const { return from_;    }
};

Ci sono alcune sintassi che non ho ancora visto da nessuna parte...cioe':

(1) Message (const std::string& subject, const std::string& from) e' il costruttore, prende due argomenti, e non fa niente (le parentesi graffe sono vuote), ma cosa sono quei due punti nella linea : subject_(subject), ??

(2) subject_ e from_ sono due stringhe, giusto? Che significa allora subject_(subject) ??

(3) std::string subject() const { return subject_; } mi pare essere una funzione che restituisce un tipo std::string e non prende argomenti. Ma perchè const si trova tra gli argomenti (parentesi tonde) e gli elementi della funzione (parentesi graffe), come se non appartenesse ne agli argomenti ne' alla funzione? Non era piu' corretto
qualcosa come

std::string subject() { return const subject_; }

??

Lo so, sono ignorante...abbiate pazienza sto facendo del mio meglio...

[lumen]

1)I due punti dopo la dichiarazione del costruttore indicano che verranno inizializzate alcune proprietà della classe.

2)subject_(subject) significa che il membro subject_ sarà inizializzato con il valore di subject, cioè del parametro passato al costruttore. Stesso discorso per from_ (from)

3) Infatti const messo lì non significa che fa parte degli argomenti, ma semplicemente che il metodo non varia in alcun modo lo stato dell'istanza (in altre parole, significa che non cambia il valore di alcuna proprietà, in questo caso from_ e subject_)

Spero di essere stato chiaro...

[internet]

Originariamente inviato da zaxis
In questi giorni, mentre studio il C++, mi aggiro per la rete in cerca di tutorials e definizioni. Andando sulla wikipedia, (http://it.wikipedia.org/wiki/C_plus_plus ) , ho trovato questo (considerato un semplice esempio )

#include <string>
 
class Message {
  std::string subject_;
  std::string from_;
   
public:
  Message (const std::string& subject,
           const std::string& from)
         : subject_(subject),
           from_   (from)
           {}
   
  std::string subject() const { return subject_; }
  std::string from()    const { return from_;    }
};

Ci sono alcune sintassi che non ho ancora visto da nessuna parte...cioe':

(1) Message (const std::string& subject, const std::string& from) e' il costruttore, prende due argomenti, e non fa niente (le parentesi graffe sono vuote), ma cosa sono quei due punti nella linea : subject_(subject), ??

Si chiama constructor initializer list
http://www.blueturnip.com/projects/e...zer-lists.html

(2) subject_ e from_ sono due stringhe, giusto? Che significa allora subject_(subject) ??

costruisce subject_ usando la stringa subject

(3) std::string subject() const { return subject_; } mi pare essere una funzione che restituisce un tipo std::string e non prende argomenti. Ma perchè const si trova tra gli argomenti (parentesi tonde) e gli elementi della funzione (parentesi graffe), come se non appartenesse ne agli argomenti ne' alla funzione?

è un modificatore che si applica al metodo, si usa quando un metodo è costante, cioè non modifica lo stato (i suoi attributi) di un oggetto su cui è applicato.

[zaxis]

Originariamente inviato da lumen

2)subject_(subject) significa che il membro subject_ sarà inizializzato con il valore di subject, cioè del parametro passato al costruttore. Stesso discorso per from_ (from)

Grazie a tutti. Pero' ci sono ancora alcune cose che mi sfuggono. Io credevo che normalmente, per inizializzare delle variabili, dovevo dichiararle dentro la funzione del costruttore. Cioè qualcosa tipo:

class pippo {
  string pippo1;
  string pippo2;
   
public:
  pippo (string parametro1, string parametro2)
 }

pippo::pippo(string parametro1, string parametro2) {
  pippo1 = parametro1
  pippo2 = parametro2
 }

E' sbagliato?

[lumen]

Punti e virgola mancanti dopo le assegnazioni, è corretto.

La notazione originale è un altro modo di scrivere la stessa cosa...

[zaxis]

Originariamente inviato da lumen
Punti e virgola mancanti dopo le assegnazioni, è corretto.

La notazione originale è un altro modo di scrivere la stessa cosa...

Grazie!
Quindi lo posso considerare come un'alternativa alla versione estesa (secondo me piu' leggibile).
Anche perche' credevo fosse una buona regola dividere le funzioni vere e proprie dai prototipi, invece il codice

Message (const std::string& subject,
           const std::string& from)
         : subject_(subject),
           from_   (from)
           {}

sembra mettere insieme sia il propotipo che "l'azione" di assegnamento, e mi pare confusionaria. Ci sono dei motivi particolari per preferirla all'altra?

[lumen]

E' preferibile usare la sintassi che hai trovato nell'esempio quando un metodo deve fare solo (e sottolineo solo) assegnazioni.
In questa maniera il metodo della classe (che in questo caso è il costruttore) viene implicitamente definito come funzione "inline", migliorando l'efficienza dell'eseguibile generato.

Sarebbe buona norma dividere l'interfaccia dall'implementazione, separandole anche fisicamente usando files con estensione .h e .cpp.
Scegliere fra leggibilità ed efficienza è responsabilità del programmatore, che deve valutare quale sia la soluzione migliore volta per volta.

[infinitejustice]

La modalità che hai trovato nell'esempio, in realtà, è obbligatoria in alcuni casi specifici, come ad esempio quando devi inizializzare reference o costanti (vanno forzatamente inizializate prima del corpo della funzione).

Poi molti la usano anche quando nn è necessaria (come nell'esempio, appunto).

Un po come se uno scrivesse return f(), g(), h();
E' corretto ma ...poteva risparmiarselo.

[zaxis]

Originariamente inviato da infinitejustice
La modalità che hai trovato nell'esempio, in realtà, è obbligatoria in alcuni casi specifici, come ad esempio quando devi inizializzare reference o costanti (vanno forzatamente inizializate prima del corpo della funzione).

E se per inizializzare le costanti prima del corpo della funzione le dichiaro dentro la classe? Esempio:

class pippo {
  int pippo1;
  int pippo2;
  pippo1 = 1;
  pippo2 = 2;
   
public:
  pippo (string parametro1, string parametro2)
 }

pippo::pippo(string parametro1, string parametro2) {
  etc..
 }

Ho scritto un idiozia?

[oregon]

Non e' una scrittura lecita.