Come inizializzare un campo const nel costruttore?

Immaginate di avere una classe C++ Foo e una classe Bar che deve essere creata con un costruttore in cui viene passato un puntatore Foo e questo puntatore è destinato a rimanere immutabile nel ciclo di vita dell'istanza Bar. Qual è il modo corretto di farlo?Come inizializzare un campo const nel costruttore?

In realtà, ho pensato che avrei potuto scrivere come il codice qui sotto, ma non viene compilato correttamente ..

class Foo; 

class Bar { 
public: 
    Foo * const foo; 
    Bar(Foo* foo) { 
     this->foo = foo; 
    } 
}; 

class Foo { 
public: 
    int a; 
};

Ogni suggerimento è benvenuto.

fonte

2009-09-14 puccio

Hai bisogno di fare in una lista di inizializzazione:

Bar(Foo* _foo) : foo(_foo) { 
}

(Si noti che ho rinominato la variabile in entrata per evitare confusione.)

fonte

2009-09-14 20:24:13

+1, anche se recentemente ho imparato qui che le variabili iniziando con underscore ora * ufficialmente * riservato ;-) –

Solo se sono seguiti da una lettera maiuscola. – GManNickG

o si trovano nello spazio dei nomi! O sono seguiti da un altro trattino basso. Quindi sì, è tecnicamente legale in questo caso, ma direi che è più facile fingere di essere riservati e non usarli affatto. :) – jalf

utilizzare un riferimento:

Foo& foo; 
Bar(Foo& f) : foo(f) { }

È può quindi fare riferimento a foo facilmente in Bar:

foo.doSomething();

fonte

2009-09-14 20:24:35 AraK

Io voto come "negativo" perché se fosse l'unica risposta, avrei potuto erroneamente pensare che usare un riferimento fosse l'unico modo per ottenerlo, mentre invece, come mostra l'altra risposta, il trucco è l'elenco di inizializzazione. – puccio

IMHO, i riferimenti sono molto più eleganti in questo caso perché il puntatore non deve essere cambiato affatto dopo essere inizializzato :) – AraK

Ma la domanda era come inizializzare il puntatore. –

prova: Bar(Foo* xfoo) : foo(xfoo) {}

fonte

2009-09-14 20:25:22

inizializzazione membri const e altri casi particolari (a tali classi genitore) può essere realizzato nella lista di inizializzazione

class Foo { 
private: 
    const int data; 
public: 
    Foo(int x) : data(x) {} 
};

Oppure, allo stesso modo, per l'inizializzazione genitore

class Foo { 
private: 
    int data; 
public: 
    Foo(int x) : data(x) {} 
}; 

class Bar : Foo { 
public: 
    Bar(int x) : Foo(x) {} 
};

fonte

2009-09-14 20:25:36 ezpz

È necessario inizializzare foo nell'elenco di inizializzazione.

class Bar { 
    Foo* const foo; 
    public: 
    Bar(Foo* f) : foo(f) {...} 
};

fonte

2009-09-14 20:25:39 KeithB

Credo che lo si debba fare in un inizializzatore. Per esempio:

Bar(Foo* foo) : foo(foo) { 
}

Come nota a margine, se non si sarà mai cambiare quello che punti a foo, passarlo in come riferimento:

Foo& foo; 

Bar(Foo& foo) : foo(foo) { 
}

fonte

2009-09-14 20:26:00 SingleShot

+1: usa i riferimenti dove vuoi, i puntatori di cui hai bisogno. –

Come inizializzare un campo const nel costruttore?

risposta

Problemi correlati