Как правильно использовать пространства имен в C ++?

Пространства имен по сути являются пакетами. Их можно использовать так:

namespace MyNamespace
{
  class MyClass
  {
  };
}

Затем в коде:

MyNamespace::MyClass* pClass = new MyNamespace::MyClass();

Или, если вы хотите всегда использовать определенное пространство имен, вы можете сделать это:

using namespace MyNamespace;

MyClass* pClass = new MyClass();

Изменить: после того, что bernhardrusch сказал, что я вообще не использую синтаксис «using namespace x», я обычно явно указываю пространство имен при создании экземпляров моих объектов (т.е. в первом показанном мною примере).

И как вы просили ниже, вы можете использовать как сколько угодно пространств имен.

Чтобы не говорить всего, Марк Ингрэм уже сказал небольшой совет по использованию пространств имен:

Избегайте директивы «using namespace» в файлах заголовков - это открывает пространство имен для всех частей программы, которые импортируют этот файл заголовка. В файлах реализации (* .cpp) это обычно не представляет большой проблемы - хотя я предпочитаю использовать директиву «using namespace» на уровне функций.

Я думаю, что пространства имен в основном используются, чтобы избежать конфликтов имен - не обязательно для организации структуры кода. Я бы организовал программы на C ++ в основном с заголовочными файлами / файловой структурой.

Иногда пространства имен используются в более крупных проектах C ++, чтобы скрыть детали реализации.

Дополнительное примечание к директиве using: некоторые люди предпочитают использовать "using" только для отдельных элементов:

using std::cout;  
using std::endl;

Винсент Роберт прав в своем комментарии Как правильно использовать пространства имен в C ++?.

Использование пространства имен

Пространства имен используются как минимум для того, чтобы избежать конфликта имен. В Java это обеспечивается идиомой org.domain (поскольку предполагается, что никто не будет использовать ничего, кроме своего собственного доменного имени).

В C ++ вы можете дать пространство имен всему коду в вашем модуле. Например, для модуля MyModule.dll вы можете присвоить его коду пространство имен MyModule. Я видел в другом месте, что кто-то использовал MyCompany :: MyProject :: MyModule. Думаю, это перебор, но в целом мне это кажется правильным.

Использование using

Использование следует использовать с большой осторожностью, поскольку оно эффективно импортирует один (или все) символы из пространства имен в ваше текущее пространство имен.

Это зло делать это в файле заголовка, потому что ваш заголовок будет загрязнять каждый источник, включая его (он напоминает мне макросы ...), и даже в исходном файле плохой стиль вне области действия функции, потому что он будет импортировать в глобальной области символы из пространства имен.

Самый безопасный способ использования - импортировать выбранные символы:

void doSomething()
{
   using std::string ; // string is now "imported", at least,
                       // until the end of the function
   string a("Hello World!") ;
   std::cout << a << std::endl ;
}

void doSomethingElse()
{
   using namespace std ; // everything from std is now "imported", at least,
                       // until the end of the function
   string a("Hello World!") ;
   cout << a << endl ;
}

Вы увидите много примеров использования пространства имен std; в учебнике или примерах кодов. Причина в том, чтобы уменьшить количество символов, чтобы облегчить чтение, а не потому, что это хорошая идея.

используя пространство имен std; не одобряет Скотт Мейерс (точно не помню, какую книгу, но при необходимости могу найти).

Состав пространства имен

Пространства имен - это больше, чем просто пакеты. Другой пример можно найти в "Языке программирования C ++" Бьярна Страуструпа.

В специальном выпуске, в разделе 8.2.8 Состав пространства имен, он описывает, как можно объединить два пространства имен AAA и BBB в другое, называемое CCC. Таким образом, CCC становится псевдонимом для AAA и BBB:

namespace AAA
{
   void doSomething() ;
}

namespace BBB
{
   void doSomethingElse() ;
}

namespace CCC
{
   using namespace AAA ;
   using namespace BBB ;
}

void doSomethingAgain()
{
   CCC::doSomething() ;
   CCC::doSomethingElse() ;
}

Вы даже можете импортировать выбранные символы из разных пространств имен, чтобы создать свой собственный интерфейс пространства имен. Мне еще предстоит найти этому практическое применение, но в теории это круто.

Я не видел упоминания об этом в других ответах, поэтому вот мои 2 канадских цента:

В теме «Использование пространства имен» полезным утверждением является псевдоним пространства имен, позволяющий «переименовать» пространство имен, обычно, чтобы дать ему более короткое имя. Например, вместо:

Some::Impossibly::Annoyingly::Long:Name::For::Namespace::Finally::TheClassName foo;
Some::Impossibly::Annoyingly::Long:Name::For::Namespace::Finally::AnotherClassName bar;

ты можешь написать:

namespace Shorter = Some::Impossibly::Annoyingly::Long:Name::For::Namespace::Finally;
Shorter::TheClassName foo;
Shorter::AnotherClassName bar;

Не слушайте всех, кто говорит вам, что пространства имен - это просто пространства имен.

Они важны, потому что, по мнению компилятора, они применяют принцип интерфейса. В основном это можно пояснить на примере:

namespace ns {

class A
{
};

void print(A a)
{
}

}

Если вы хотите напечатать объект A, код будет следующим:

ns::A a;
print(a);

Обратите внимание, что мы явно не упоминали пространство имен при вызове функции. Это принцип интерфейса: C ++ рассматривает функцию, принимающую тип в качестве аргумента, как часть интерфейса для этого типа, поэтому нет необходимости указывать пространство имен, потому что параметр уже подразумевает пространство имен.

Почему этот принцип так важен? Представьте, что автор класса A не предоставил функцию print () для этого класса. Вам придется предоставить его самостоятельно. Поскольку вы хороший программист, вы определите эту функцию в своем собственном пространстве имен или, возможно, в глобальном пространстве имен.

namespace ns {

class A
{
};

}

void print(A a)
{
}

И ваш код может начать вызывать функцию print (a) где угодно. Теперь представьте, что годы спустя автор решает предоставить функцию print () лучше, чем ваша, потому что он знает внутреннее устройство своего класса и может создать лучшую версию, чем ваша.

Затем авторы C ++ решили, что его версия функции print () должна использоваться вместо той, которая предоставлена ​​в другом пространстве имен, для соблюдения принципа интерфейса. И что это «обновление» функции print () должно быть максимально простым, а это означает, что вам не придется менять каждый вызов функции print (). Вот почему «интерфейсные функции» (функция в том же пространстве имен, что и класс) можно вызывать без указания пространства имен в C ++.

Вот почему вы должны рассматривать пространство имен C ++ как «интерфейс», когда вы его используете, и помнить о принципе интерфейса.

Если вы хотите лучше объяснить это поведение, вы можете обратиться к книге Исключительный C ++ от Херба Саттера

В более крупных проектах C ++, которые я видел, почти не использовалось более одного пространства имен (например, библиотека boost).

На самом деле boost использует множество пространств имен, обычно каждая часть boost имеет собственное пространство имен для внутренней работы, а затем может помещать только общедоступный интерфейс в boost пространства имен верхнего уровня.

Лично я считаю, что чем больше становится кодовая база, тем важнее становятся пространства имен даже в рамках одного приложения (или библиотеки). На работе мы помещаем каждый модуль нашего приложения в свое собственное пространство имен.

Другое использование (без каламбура) пространств имен, которые я часто использую, - это анонимное пространство имен:

namespace {
  const int CONSTANT = 42;
}

Это в основном то же самое, что:

static const int CONSTANT = 42;

Однако использование анонимного пространства имен (вместо статического) является рекомендуемым способом для отображения кода и данных только в пределах текущего модуля компиляции в C ++.

Также обратите внимание, что вы можете добавить в пространство имен. Это станет яснее на примере, я имею в виду, что вы можете иметь:

namespace MyNamespace
{
    double square(double x) { return x * x; }
}

в файле square.h и

namespace MyNamespace
{
    double cube(double x) { return x * x * x; }
}

в файле cube.h. Это определяет единое пространство имен MyNamespace (то есть вы можете определить единое пространство имен для нескольких файлов).

В Java:

package somepackage;
class SomeClass {}

In C++:

namespace somenamespace {
    class SomeClass {}
}

И используя их, Java:

import somepackage;

И C ++:

using namespace somenamespace;

Кроме того, полные имена: somepackge.SomeClass для Java и somenamespace :: SomeClass для C ++. Используя эти соглашения, вы можете организовать, как вы привыкли в Java, включая создание совпадающих имен папок для пространств имен. Однако требований к папкам и пакетам и файлам-> классам нет, поэтому вы можете называть свои папки и классы независимо от пакетов и пространств имен.

@ мариус

Да, вы можете использовать несколько пространств имен одновременно, например:

using namespace boost;   
using namespace std;  

shared_ptr<int> p(new int(1));   // shared_ptr belongs to boost   
cout << "cout belongs to std::" << endl;   // cout and endl are in std

[Фев. 2014 - (Неужели это было так долго?): Этот конкретный пример теперь неоднозначен, как указывает Джои ниже. Boost и std :: now имеют shared_ptr.]

Вы также можете содержать "using namespace ..." внутри функции, например:

void test(const std::string& s) {
    using namespace std;
    cout << s;
}

Вообще говоря, я создаю пространство имен для основной части кода, если считаю, что могут возникнуть конфликты имени функции или типа с другими библиотеками. Это также помогает использовать фирменный код, например, boost ::.

Я предпочитаю использовать пространство имен верхнего уровня для приложения и подпространства имен для компонентов.

Способ использования классов из других пространств имен на удивление очень похож на способ использования в java. Вы можете использовать «use NAMESPACE», аналогичный оператору «import PACKAGE», например использовать std. Или вы указываете пакет как префикс класса, разделенный "::", например std :: строка. Это похоже на «java.lang.String» в Java.

Обратите внимание, что пространство имен в C ++ на самом деле является просто пространством имен. Они не обеспечивают инкапсуляции, которую делают пакеты в Java, поэтому вы, вероятно, не будете их так часто использовать.

Я использовал пространства имен C ++ так же, как и в C #, Perl и т. Д. Это просто семантическое разделение символов между материалами стандартной библиотеки, сторонними материалами и моим собственным кодом. Я бы поместил свое собственное приложение в одно пространство имен, а затем повторно используемый компонент библиотеки в другое пространство имен для разделения.

Еще одно различие между java и C ++ заключается в том, что в C ++ иерархия пространств имен не требует обработки макета файловой системы. Поэтому я стараюсь помещать всю повторно используемую библиотеку в одно пространство имен, а подсистемы внутри библиотеки - в подкаталоги:

#include "lib/module1.h"
#include "lib/module2.h"

lib::class1 *v = new lib::class1();

Я бы поместил подсистемы во вложенные пространства имен только в том случае, если бы существовала возможность конфликта имен.

std :: cout

Префикс std :: указывает, что имена cout и endl определены внутри пространства имен с именем std. Пространства имен позволяют нам избежать непреднамеренных конфликтов между именами, которые мы определяем, и использованием тех же имен внутри библиотеки. Все имена, определенные стандартной библиотекой, находятся в пространстве имен std. При написании std :: cout используется оператор области видимости (оператор ::), чтобы сказать, что мы хотим использовать имя cout, которое определено в пространстве имен std. покажет более простой способ доступа к именам из библиотеки.