Probabilmente un duplicato, ma non facile da cercare ...

Data un'intestazione come:

namespace ns1
{
 class MyClass
 {
  void method();
 };
}

Ho visto method()definito in diversi modi nel file .cpp:

Versione 1:

namespace ns1
{
 void MyClass::method()
 {
  ...
 }
}

Versione 2:

using namespace ns1;

void MyClass::method()
{
 ...
}

Versione 3:

void ns1::MyClass::method()
{
 ...
}

C'è un modo "giusto" per farlo? Qualcuno di questi "sbagliati" in quanto non significano tutti la stessa cosa?

La versione 2 non è chiara e non è facile da capire perché non sai a quale spazio dei nomi MyClassappartiene ed è semplicemente illogica (la funzione di classe non è nello stesso spazio dei nomi?)

La versione 1 è corretta perché mostra che nello spazio dei nomi stai definendo la funzione.

La versione 3 è corretta anche perché hai utilizzato l' ::operatore di risoluzione dell'ambito per fare riferimento a MyClass::method ()nello spazio dei nomi ns1. Preferisco la versione 3.

Vedere Spazi dei nomi (C ++) . Questo è il modo migliore per farlo.

5 anni dopo e ho pensato di menzionarlo, che sembra carino e non è malvagio

using ns1::MyClass;

void MyClass::method()
{
  // ...
}

Sto usando la versione 4 (sotto) perché combina la maggior parte dei vantaggi della versione 1 (lacune della definizione risettiva) e della versione 3 (sii massimamente esplicita). Lo svantaggio principale è che le persone non ci sono abituate ma siccome lo considero tecnicamente superiore alle alternative non mi dispiace.

Versione 4: utilizza la qualifica completa utilizzando gli alias dello spazio dei nomi:

#include "my-header.hpp"
namespace OI = outer::inner;
void OI::Obj::method() {
    ...
}

Nel mio mondo utilizzo frequentemente alias dello spazio dei nomi poiché tutto è esplicitamente qualificato, a meno che non sia possibile (ad es. Nomi di variabili) o non sia un punto di personalizzazione noto (ad es. Swap () in un modello di funzione).

La versione 3 rende l'associazione tra la classe e lo spazio dei nomi molto esplicita a scapito di una maggiore digitazione. La versione 1 lo evita ma acquisisce l'associazione con un blocco. La versione 2 tende a nasconderlo, quindi eviterei quello.

Googles C ++ Style Guide detta la tua versione 1, senza indentazione però.

Scelgo Num.3 (ovvero la versione dettagliata). È più digitando, ma l'intento è esatto per te e per il compilatore. Il problema che hai pubblicato così com'è è in realtà più semplice del mondo reale. Nel mondo reale, ci sono altri ambiti per le definizioni, non solo i membri della classe. Le tue definizioni non sono molto complicate solo con le classi, perché il loro ambito non viene mai riaperto (a differenza degli spazi dei nomi, dell'ambito globale, ecc.).

Num.1 questo può fallire con ambiti diversi dalle classi - tutto ciò che può essere riaperto. Quindi, puoi dichiarare una nuova funzione in uno spazio dei nomi usando questo approccio, oppure i tuoi inline potrebbero finire per essere sostituiti tramite ODR. Ti servirà per alcune definizioni (in particolare, le specializzazioni dei modelli).

Num.2 Questo è molto fragile, in particolare in codebase di grandi dimensioni: poiché le intestazioni e le dipendenze cambiano, il programma non verrà compilato.

Num.3 Questo è l'ideale, ma molto da scrivere - qual è il tuo intento di definire qualcosa . Questo fa esattamente questo e il compilatore interviene per assicurarsi di non aver commesso un errore, una definizione non è fuori sincronia con la sua dichiarazione, ecc.

Si scopre che non è solo "questione di codice". Num. 2 porta a un errore di collegamento durante la definizione e l'inizializzazione di una variabile dichiarata extern nel file di intestazione. Dai un'occhiata all'esempio nella mia domanda. Definizione di costante all'interno dello spazio dei nomi nel file cpp

Tutti i modi sono giusti e ognuno ha i suoi vantaggi e svantaggi.

Nella versione 1, hai il vantaggio di non dover scrivere lo spazio dei nomi davanti a ciascuna funzione. Lo svantaggio è che otterrai un'identificazione noiosa, specialmente se hai più di un livello di spazi dei nomi.

Nella versione 2, rendi il tuo codice più pulito, ma se hai più di uno spazio dei nomi implementato nel CPP, uno può accedere direttamente alle funzioni e alle variabili dell'altro, rendendo il tuo spazio dei nomi inutile (per quel file cpp).

Nella versione 3, dovrai digitare di più e le linee delle funzioni potrebbero essere più grandi dello schermo, il che è negativo per gli effetti di design.

C'è anche un altro modo in cui alcune persone lo usano. È simile alla prima versione, ma senza problemi di identificazione.

È così:

#define OPEN_NS1 namespace ns1 { 
#define CLOSE_NS1 }

OPEN_NS1

void MyClass::method()
{
...
}

CLOSE_NS1

Sta a te scegliere quale è meglio per ogni situazione =]