Объявление и определение типов

 

Внутри пространства имен можно объявлять и определять типы и функции. Тут не обойтись без обсуждения стратегических подходов программирования в C++. Правильность структуры программы определяется тем, насколько четко отделен интерфейс программы от ее процедурной части. Этому принципу необходимо следовать не только при работе с классами, но и при создании пространств имен. Ниже показан пример плохо структурированного пространства имен:

namespace Window {

//... другие объявления и определения переменных.

void move(int x, int у); // объявления

void resize(int x, int у);

//... другие объявления и определения переменных.

void move(int x, int у)

{

if(x < MAX_SCREEN_X && x > 0)

if(у < MAX_SCREEN_Y && у > 0)

platform.move(x, у); // специальная программа

}

void resize(int x, int у)

{

if(x < MAX_SIZE__X && x > 0)

if(у < MAX_SIZE_Y && у > 0)

platform.resize(x, у); // специальная программа

}

//... продолжение определений

}

 

Наглядно видно, как быстро пространство имен становится хаотичным и беспорядочным! Причем в этом примере объявление пространства имен составляло всего около 20 строк, а во что превратилась бы программа, будь объявление более длинным?

 

Объявление функций за пределами пространства имен

 

Функции пространства имен следует объявлять за пределами тела пространства. Это позволит явно отделить объявления функций от определения их выполнения, не захламляя тело пространства имен. Кроме того, вынос объявлений функции даст возможность разместить пространство имен и его внедренные объявления в файле заголовка, а определения выполнения поместить в исполняемый файл программы. Например:

// файл header.h

namespace Window {

void move(int x, int у);

// другие объявления

}

 

// file impl.cpp

void Window::move(int x, int у)

{

// код перемещения окна

}

 

Добавление новых членов

 

Добавление новых членов в пространство имен осуществляет только в теле пространства. Невозможно создавать новые члены пространства имен вне тела пространства, указывая его имя, как это делалось с объектами классов. Компилятор ответит на это сообщением об ошибке. Пример такой ошибки показан ниже.

namespace Window {

// ряд объявлений

}

// код программы

int Window::newIntegerInNamespace; // ошибка

 

Последняя строка неправильна, и компилятор сообщит об этом. Чтобы исправить ошибку, перенесите объявление переменной-члена newIntegerInNamespace в тело пространства имен.

Все заключенные в пространстве имени члены являются открытыми. Поэтому неправильным будет и следующий код:

namespace Window {

private:

void move(int x, int у);

}

 

Вложения пространства имен

 

Одно пространство имен можно вложить в другое пространство имен. К подобному вложению прибегают в том случае, когда определение выполнения одного пространства имен должно содержать объявление нового пространства. Чтобы обратиться к члену внутреннего пространства имен, необходимо явно указать имена обоих пространств. Так, в следующем примере одно именованное пространство объявляется внутри другого именованного пространства:

namespace Window {

namespace Pane {

void size(int x, int у);

}

}

 

Для доступа к функции size() за пределами пространства имен Window нужно дополнить имя вызываемой функции именами пространств имен, внутри которых она была объявлена, например:

int main()

{

Window::Pane::size(10, 20);

return 0;

}

 

 

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

 

Теперь рассмотрим пример использования пространства имен и связанного с ним оператора видимости. Сначала внутри пространства имен Windowoбъявляютcя все типы и функции, после чего за его пределами следуют определения функций-членов. Чтобы определить функцию, объявленную в пространстве имен, следует перед именем функции установить имя пространства имен и оператор видимости, как это делается в листинге 17.1.

Листинг 17.1. Использование пространства имен

1: #include <iostream>

2:

3: namespace Window

4: {

5: const int MAX_X = 30

6: const int MAX_Y = 40

7: class Рапе

8: {

9: public:

10: Pane();

11: ~Pane();

12: void size(int x, int у)

13: void move(int x, int у)

14: void show();

15: private:

16: static int cnt;

17: int x;

18: int у;

19: };

20: }

21:

22: int Window::Pane::cnt = 0;

23: Window::Pane::Pane(): x(0), y(0) { }

24: Windo::Pane::~Pane() { }

25:

26: void Window;:Pane::size(int x, int y)

27: {

28: if(x < Window::MAX_X && x > 0)

29: Pane;:x = x:

30: if(y < Window;;MAX_Y && y > 0)

31: Pane::y = y;

32: }

33: void Window;:Pane::move(int x, int y)

34: {

35: if(x < Window::MAX_X && x > 0)

36: Pane::x = x;

37: if(y< Window::MAX_Y && y > 0)

38: Pane::y = y;

39: }

40: void Window::Pane::show()

41: {

42: std::cout << "x " << Pane::x;

43: std::cout << " y " << Pane::y << std::endl;

44: }

45:

46: int main()

47: {

48: Window::Pane pane;

49:

50: pane.move(20, 20);

51: pane.show();

52:

53: return 0;

54: }

 

Результат:

x 20 y 20

 

Анализ: Обратите внимание, что класс Pane вложен в пространство имен Window. Поэтому при обращении к объектам класса Pane их имена дополняются идентификатором Window::.

Статическая переменная-член cnt, объявленная в строке 16 внутри класса Pane, определяется как обычно. Но при определении функции-члена Pane::size() и обращениях к переменным-членам MAX_X и MAX_Y в строках 26-32 используется явное указание пространства имен. Дело в том, что статическая переменная-член определяется внутри класса Pane, а определения других функций-членов (это же справедливо для функции Pane::move()) происходят как за пределами класса, так и вне тела пространства имен. Без явного указания пространства имен компилятор покажет сообщение об ошибке.

Обратите внимание также на то, что внутри определений функций-членов обращение к объявленным переменным-членам класса происходит с явным указанием имени класса: Pane::x и Pane::y. Зачем это делается? Дело в том, что у вас возникли бы проблемы, если функция Pane::move() определялась бы следующим образом:

 

void Window::Pane::move(int x, int у)

{

if(x < Window::MAX_X && x > 0)

x = x;

if(у < Window::MAX_Y && у > 0)

У = У;

Platform::move(x, у);

}

 

Ну что, догадались, в чем проблема? Опасность состоит в том, что компилятор в этом выражении никаких ошибок не заметит.

Источник проблемы заключается в аргументах функции. Аргументы x и у скроют закрытые переменные-члены x и у, объявленные в классе Pane, поэтому вместо присвоения значений аргументов переменным-членам произойдет присвоение этих значений самим себе. Чтобы исправить эту ошибку, необходимо явно указать переменные-члены класса:

Pane::x = x;

Pane::y = у;

 

Ключевое слово using

 

Ключевое слово using может использоваться и как оператор, и в качестве спецификатора при объявлении членов пространства имен, но синтаксис использования using при этом меняется.