Tworzenie przestrzeni nazw C ++ w nagłówku i źródle (CPP)

Czy jest jakaś różnica między zawijaniem zawartości pliku nagłówka i pliku cpp w przestrzeni nazw lub zawijaniem samej zawartości nagłówka, a następnie użyciem przestrzeni nazw w pliku CPP?

Przez różnicę rozumiem każdy spadek wydajności lub nieco inną semantykę, która może powodować problemy lub cokolwiek, o czym muszę wiedzieć.

Przykład:

// header
namespace X
{
  class Foo
  {
  public:
    void TheFunc();
  };
}

// cpp
namespace X
{
  void Foo::TheFunc()
  {
    return;
  }
}

VS

// header
namespace X
{
  class Foo
  {
  public:
    void TheFunc();
  };
}

// cpp
using namespace X;
{
  void Foo::TheFunc()
  {
    return;
  }
} 

Jeśli nie ma różnicy, jaka jest preferowana forma i dlaczego?

Przestrzeń nazw to tylko sposób na modyfikowanie sygnatur funkcji, aby nie powodowały konfliktów. Niektórzy wolą pierwszy sposób, a inni wolą drugą wersję. Obie wersje nie mają żadnego wpływu na wydajność w czasie kompilacji. Zauważ, że przestrzenie nazw są po prostu jednostką czasu kompilacji.

Jedynym problemem, który pojawia się przy używaniu przestrzeni nazw, jest sytuacja, gdy mamy takie same zagnieżdżone nazwy przestrzeni nazw (tj X::X::Foo. ) . Takie postępowanie powoduje większe zamieszanie przy użyciu słów kluczowych lub bez nich.

Różnica w „namespace X” do „using namespace X” polega na tym, że w pierwszym przypadku wszelkie nowe deklaracje będą znajdować się pod przestrzenią nazw, podczas gdy w drugim nie.

W twoim przykładzie nie ma nowej deklaracji - więc nie ma różnicy, stąd nie ma preferowanego sposobu.

Nie ma żadnych kar za wydajność, ponieważ wynik mógłby być taki sam, ale umieszczenie twojego Foow przestrzeni nazw niejawnie wprowadza niejednoznaczność w przypadku, gdy masz Foos w różnych przestrzeniach nazw. Rzeczywiście, możesz dostać swój kod fubar. Zalecam unikanie używania usingw tym celu.

I masz bezpański {po using namespace;-)

Jeśli skompiluje się również druga, nie powinno być żadnych różnic. Przestrzenie nazw są przetwarzane w czasie kompilacji i nie powinny wpływać na działania w czasie wykonywania.

Ale jeśli chodzi o kwestie projektowe, druga jest okropna. Nawet jeśli się kompiluje (nie jestem pewien), nie ma to żadnego sensu.

Foo :: TheFunc () nie znajduje się w poprawnej przestrzeni nazw w przypadku VS. Użyj „void X :: Foo :: TheFunc () {}”, aby zaimplementować funkcję w prawidłowej przestrzeni nazw (X).

W przypadku, gdy zawijasz tylko zawartość .h, musisz pisać używając przestrzeni nazw ... w pliku cpp, w przeciwnym razie za każdym razem pracujesz na prawidłowej przestrzeni nazw. Zwykle pakujesz zarówno pliki .cpp, jak i .h, w przeciwnym razie istnieje ryzyko użycia obiektów z innej przestrzeni nazw, co może powodować wiele problemów.

Myślę, że właściwym rozwiązaniem jest użycie przestrzeni nazw do określania zakresu.

namespace catagory
{
    enum status
    {
      none,
      active,
      paused
    }
};

void func()
{
    catagory::status status;
    status = category::active;
}

Jeśli próbujesz używać zmiennych z jednej do drugiej, polecam ich eksternalizację, a następnie zainicjowanie ich w pliku źródłowym w następujący sposób:

// [.hh]
namespace example
{
   extern int a, b, c;
}
// [.cc]
// Include your header, then init the vars:
namespace example
{
   int a, b, c;
}
// Then in the function below, you can init them as what you want: 
void reference
{
    example::a = 0;
}