Dovrebbe essere in un namespace?

Question

Devo inserire il codice da .cpp in uno spazio dei nomi dal corrispondente .h o è sufficiente scrivere solo usando la dichiarazione?

//file .h 
namespace a 
{ 
/*interface*/ 
class my 
{ 
}; 
} 

//file .cpp 

using a::my; // Can I just write in this file this declaration and 
      // after that start to write implementation, or 
      // should I write: 

namespace a //everything in a namespace now 
{ 
//Implementation goes here 
} 

Grazie.

Answer 1

Ritengo più appropriato circondare tutto il codice che si intende essere nello spazio dei nomi all'interno di un blocco namespace a { ... }, poiché quello è semanticamente cosa stai facendo: stai definendo gli elementi all'interno dello spazio dei nomi a. Ma se si definiscono solo i membri, allora entrambe le cose funzioneranno.

Quando il compilatore trova void my::foo(), si cercherà di determinare ciò che è my, e troverà il using a::my, risolvere my da questo e capire che si sta definendo il metodo a::my::foo.

D'altra parte questo approccio avrà esito negativo se si utilizza funzioni libere:

// header 
namespace a { 
    class my { // ... 
    }; 
    std::ostream & operator<<(std::ostream& o, my const & m); 
} 
// cpp 
using a::my; 
using std; 
ostream & operator<<(ostream & o, my const & m) { 
    //.... 
} 

Il compilatore sarà lieto di tradurre il codice di cui sopra in un programma, ma quello che sta effettivamente facendo sta dichiarando std::ostream& a::operator<<(std::ostream&, a::my const &) nell'intestazione file - senza implementazione - e definendo std::ostream& ::operator<<(std::ostream &, a::my const &) nel file cpp, che è una funzione diversa. Utilizzando Koening ricerca, ogni volta che il compilatore vede cout << obj con obj di tipo a::my, il compilatore guardare negli spazi dei nomi di cinta di cout e my (std, e a) e troverà che c'è un a::operator<< dichiarata ma mai definito in namespace a. Compilerà ma non collegherà il tuo codice.

Answer 2

Se ho capito bene la domanda, si può avere solo con un :: mia e poi basta attuare i metodi, come

using a::my; 

void my::doSomething() {} 

Answer 3

È può farlo. Ma, dovrebbe voi?

È una pratica insolita e probabilmente porterà a una proliferazione di using a::Type; per ogni tipo dallo spazio dei nomi 'a' utilizzato nel file .cc. Se è una buona cosa decidere per voi, ma voterei contro di esso :)