Пространства имен
Пространство имен определяет некоторую декларативную область. Пространства имен мы кратко рассмотрели в главе 2. Они позволяют локализовать имена идентификаторов, чтобы избежать конфликтных ситуаций с ними. В С++-среде программирования используется огромное количество имен переменных, функций и имен классов. До введения пространств имен все эти имена конкурировали за память в глобальном пространстве имен, что и было причиной возникновения многих конфликтов. Например, если бы в вашей программе была определена функция toupper(), она могла бы (в зависимости от списка параметров) переопределить стандартную библиотечную функцию toupper(), поскольку оба имени должны были бы храниться в глобальном пространстве имен. Конфликты с именами возникали также при использовании одной программой нескольких библиотек сторонних производителей. В этом случае имя, определенное в одной библиотеке, конфликтовало с таким же именем из другой библиотеки. Подобная ситуация особенно неприятна при использовании одноименных классов. Например, если в вашей программе определен класс VideoMode, и в библиотеке, используемой вашей программой, определен класс с таким же именем, конфликта не избежать.
Для решения описанной проблемы было создано ключевое слово namespace. Поскольку оно локализует видимость объявленных в нем имен, это значит, что пространство имен позволяет использовать одно и то же имя в различных контекстах, не вызывая при этом конфликта имен. Возможно, больше всего от нововведения "повезло" С++-библиотеке стандартных функций. До появления ключевого слова namespace вся С++-библиотека была определена в глобальном пространстве имен (которое было, конечно же, единственным). С наступлением namespace-"эры" С++-библиотека определяется в собственном пространстве имен, именуемом std, которое значительно понизило вероятность возникновения конфликтов имен. В своей программе программист волен создавать собственные пространства имен, чтобы локализовать видимость тех имен, которые, по его мнению, могут стать причиной конфликта. Это особенно важно, если вы занимаетесь созданием библиотек классов или функций.
Понятие пространства имен
Ключевое слово namespace позволяет разделить глобальное пространство имен путем создания некоторой декларативной области. По сути, пространство имен определяет область видимости. Общий формат задания пространства имен таков.
namespace name {
// объявления
}
Все, что определено в границах инструкции namespace, находится в области видимости этого пространства имен.
В следующей программе приведен пример использования namespace-инструкции. Она локализует имена, используемые для реализации простого класса счета в обратном направлении. В созданном здесь пространстве имен определяется класс counter, который реализует счетчик, и переменные upperbound и lowerbound, содержащие значения верхней и нижней границ, применяемых для всех счетчиков.
namespace CounterNameSpace {
int upperbound;
int lowerbound;
class counter {
int count;
public:
counter(int n) {
if(n <= upperbound) count = n;
else count = upperbound;
}
void reset(int n) {
if(n <= upperbound) count = n;
}
int run() {
if(count > lowerbound) return count--;
else return lowerbound;
}
};
}
Здесь переменные upperbound и lowerbound, а также класс counter являются частью области видимости, определенной пространством имен CounterNameSpace. В любом пространстве имен к идентификаторам, которые в нем объявлены, можно обращаться напрямую, т.е. без указания этого пространства имен. Например, в функции run(), которая находится в пространстве имен CounterNameSpace, можно напрямую обращаться к переменной lowerbound:
if(count > lowerbound) return count--;
Но поскольку инструкция namespace определяет область видимости, то при обращении к объектам, объявленным в пространстве имен, извне этого пространства необходимо использовать оператор разрешения области видимости. Например, чтобы присвоить значение 10 переменной upperbound из кода, который является внешним по отношению к пространству имен CounterNameSpace, нужно использовать такую инструкцию.
CounterNameSpace::upperbound = 10;
Чтобы объявить объект типа counter вне пространства имен CounterNameSpace, используйте инструкцию, подобную следующей.
CounterNameSpace::counter ob;
В общем случае, чтобы получить доступ к некоторому члену пространства имен извне этого пространства, необходимо предварить имя этого члена именем пространства и разделить эти имена оператором разрешения области видимости.
Рассмотрим программу, в которой демонстрируется использование пространства имен CounterNameSpace.
// Демонстрация использования пространства имен.
#include <iostream>
using namespace std;
namespace CounterNameSpace {
int upperbound;
int lowerbound;
class counter {
int count;
public:
counter (int n) {
if(n <= upperbound) count = n;
else count = upp
do {
i = ob1.run();
cout << i << " ";
}while(i > CounterNameSpace :: lowerbound);
cout << endl;
CounterNameSpace::counter ob2(20);
do {
i = ob2.run();
cout << i << " ";
}while(i > CounterNameSpace::lowerbound);
cout << endl;
ob2.reset(100);
CounterNameSpace::lowerbound = 90;
do {
i = ob2.run();
cout << i << " ";
}while(i > CounterNameSpace::lowerbound);
return 0;
}
Обратите внимание на то, что при объявлении объекта класса counter и обращении к переменным upperbound и lowerbound используется имя пространства имен CounterNameSpace. Но после объявления объекта типа counter уже нет необходимости в полной квалификации его самого или его членов. Поскольку пространство имен однозначно определено, функцию run() объекта ob1 можно вызывать напрямую, т.е. без указания (в качестве префикса) пространства имен (ob1.run()).
Программа может содержать несколько объявлений пространств имен с одинаковыми именами. Это означает, что пространство имен можно разбить на несколько файлов или на несколько частей в рамках одного файла. Вот пример.
namespace NS {
int i;
}
// . . .
namespace NS {
int j;
}
Здесь пространство имен NS разделено на две части. Однако содержимое каждой части относится к одному и тому же пространству имен NS.
Любое пространство имен должно быть объявлено вне всех остальных областей видимости. Это означает, что нельзя объявлять пространства имен, которые локализованы, например, в рамках функции. При этом одно пространство имен может быть вложено в другое.
Инструкция using
Инструкция using делает заданное пространство имен "видимым", т.е. действующим. Если программа включает множество ссылок на члены некоторого пространства имен, то нетрудно представить, что необходимость указывать имя этого пространства имен при каждом к ним обращении, очень скоро утомит вас. Эту проблему позволяет решить инструкция using, которая применяется в двух форматах.
using namespace имя;
using name::член;
В первой форме элемент имя задает название пространства имен, к которому вы хотите получить доступ. Все члены, определенные внутри заданного пространства имен, попадают в "поле видимости", т.е. становятся частью текущего пространства имен и их можно затем использовать без квалификации (уточнения пространства имен). Во второй форме делается "видимым" только указанный член пространства имен. Например, предполагая, что пространство имен CounterNameSpace определено (как показано выше), следующие инструкции using и присваивания будут вполне законными.
using CounterNameSpace::lowerbound; /* Видимым стал только член
lowerbound */
lowerbound = 10; /* Все в порядке, поскольку член lowerbound
находится в области видимости. */
using namespace CounterNameSpace; // Все члены видимы.
upperbound = 100; // Все в порядке, поскольку все члены видимы
Использование инструкции using демонстрируется в следующей программе (которая представляет собой новый вариант счетчика из предыдущего раздела).
// Использование инструкции using.
#include <iostream>
using namespace std;
namespace CounterNameSpace {
int upperbound;
int lowerbound;
class counter {
int count;
public:
counter (int n) {
if(n <= upperbound) count = n;
else count = upperbound;
}
void reset(int n) {
if(n <= upperbound) count = n;
}
int run() {
if(count > lowerbound) return count--;
else return lowerbound;
}
};
}
int main()
{
/* Используется только член upperbound из пространства имен
CounterNameSpace. */
using CounterNameSpace::upperbound;
/* Теперь для установки значения переменной upperbound не
нужно указывать пространство имен. */
upperbound = 100;
/* Но при обращении к переменной lowerbound и другим объектам
по-прежнему необходимо указывать пространство имен. */
CounterNameSpace::lowerbound = 0;
CounterNameSpace::counter ob1(10);
int i;
do {
i = ob1.run();
cout << i << " ";
}while(i > CounterNameSpace::lowerbound);
cout. << endl;
/* Теперь используем все пространство имен CounterNameSpace.
*/
using namespace CounterNameSpace;
counter ob2(20);
do {
i = ob2.run();
cout << i << " ";
}while(i > lowerbound);
cout << endl;
ob2.reset(100);
lowerbound = 90;
do {
i = ob2.run();
cout << i << " ";
}while(i > lowerbound);
return 0;
}
Эта программа иллюстрирует еще один важный момент. Использование одного пространства имен не переопределяет другое. Если некоторое пространство имен становится "видимым", это значит, что оно просто добавляет свои имена к именам других, уже действующих пространств. Поэтому к концу этой программы к глобальному пространству имен добавились и std, и CounterNameSpace.
Неименованные пространства имен
Неименованное пространство имен ограничивает идентификаторы рамками файла, в котором они объявлены. Существует неименованное пространство имен специального типа, которое позволяет создавать идентификаторы, уникальные для данного файла. Общий формат его объявления выглядит так.
namespace {
// объявления
}
Неименованные пространства имен позволяют устанавливать уникальные идентификаторы, которые известны только в области видимости одного файла. Другими словами, члены файла, который содержит неименованное пространство имен, можно использовать напрямую, без уточняющего префикса. Но вне файла эти идентификаторы неизвестны
Как упоминалось выше в этой книге, использование модификатора типа static также позволяет ограничить область видимости глобального пространства имен файлом, в котором он объявлен. Например, рассмотрим следующие два файла, которые являются частью одной и той же программы.
Поскольку переменная k определена в файле One, ее и можно использовать в файле One. В файле Two переменная k определена как внешняя (extern-переменная), а это значит, что ее имя и тип известны, но сама переменная k в действительности не определена. Когда эти два файла будут скомпонованы, попытка использовать переменную k в файле Two приведет к возникновению ошибки, поскольку в нем нет определения для переменной k. Тот факт, что k объявлена static-переменной в файле One, означает, что ее область видимости ограничивается этим файлом, и поэтому она недоступна для файла Two.
Несмотря на то что использование глобальных static-объявлений все еще разрешено в C++, для локализации идентификатора в рамках одного файла лучше использовать неименованное пространство имен. Рассмотрим пример.
Здесь переменная k также ограничена рамками файла One. Для новых программ рекомендуется использовать вместо модификатора static неименованное пространство имен.
Обычно для большинства коротких программ и программ среднего размера нет необходимости в создании пространств имен. Но, формируя библиотеки многократно используемых функций или классов, имеет смысл заключить свой код (если хотите обеспечить его максимальную переносимость) в собственное пространство имен.
Пространство имен std
Пространство имен std используется библиотекой C++. Стандарт C++ определяет всю свою библиотеку в собственном пространстве имен, именуемом std. Именно по этой причине большинство программ в этой книге включает следующую инструкцию:
using namespace std;
При выполнении этой инструкции пространство имен std становится текущим, что открывает прямой доступ к именам функций и классов, определенных в этой библиотеке, т.е. при обращении к ним отпадает необходимость в использовании префикса std::
Конечно, при желании можно явным образом квалифицировать каждое библиотечное имя префиксом std::. Например, следующая программа не привносит библиотеку в глобальное пространство имен.
// Использование явно заданной квалификации std::.
#include <iostream>
int main()
{
double val;
std::cout << "Введите число: ";
std::cin >> val;
std::cout << "Вы ввели число ";
std::cout << val;
return 0;
}
Здесь имена cout и cin явно дополнены именами своих пространств имен. Итак, чтобы записать данные в стандартный выходной поток, следует использовать не просто имя потока cout, а имя с префиксом std::cout, а чтобы считать данные из стандартного входного потока, нужно применить "префиксное" имя std::cin.
Если ваша программа использует стандартную библиотеку только в ограниченных пределах, то, возможно, ее и не стоит вносить в глобальное пространство имен. Но если ваша программа содержит сотни ссылок на библиотечные имена, то гораздо проще сделать пространство имен std текущим, чем полностью квалифицировать каждое имя в отдельности.
Если вы используете только несколько имен из стандартной библиотеки, то, вероятно, имеет смысл использовать инструкцию using для каждого из них в отдельности. Преимущество этого подхода состоит в том, что эти имена можно по-прежнему использовать без префикса std::, не внося при этом всю библиотеку стандартных функций в глобальное пространство имен. Рассмотрим пример.
/* Внесение в глобальное пространство имен лишь нескольких имен.
*/
#include <iostream>
// Получаем доступ к именам потоков cout и cin.
using std::cout;
using std::cin;
int main()
{
double val;
cout << "Введите число: ";
cin >> val;
cout << "Вы ввели число ";
cout << val;
return 0;
}
Здесь имена потоков cin и cout можно использовать напрямую, но остальная часть пространства имен std не внесена в область видимости.
Как упоминалось выше, исходная библиотека C++ была определена в глобальном
пространстве имен. Если вам придется модернизировать старые С++-программы, то вы
должны либо включить в них инструкцию using namespace std, либо дополнить каждое
обращение к члену библиотеки префиксом std::. Это особенно важно, если вам придется
заменять старые заголовочные *.h-файлы современными заголовками. Помните, что старые
заголовочные *.h-файлы помещают свое содержимое в глобальное пространство имен, а
современные заголовки — в пространство имен std.