Опорный конспект

Для пространства имен можно создать псевдоним. Пусть есть пространство имен, определенное следующим образом:

namespace very_very_long_name_of_namespace{…}

Для такого длинного имени лучше использовать псевдоним: namespace vvln = very_very_long_name_of_namespace;

Этот же прием можно использовать для упрощения операций с вложенными пространствами имен:

namespace First

{

namespace Second

{

namespace Third

{

int test;

}

}

}

namespace FST = First::Second::Third; int s = FST::test;

Рис. 21.7 Создание псевдонима для пространства имен

Неименованные пространства имен

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

namespace

{

int source; char * stroka;

}

Рис. 21.8 Создание неименованного пространства имен

После этого к переменным source и stroka можно обращться так, как если бы они были активизированы директивой using. Имена, объявленные в неименованном пространстве имен, подобны глобальным переменным. Но отсутсвие имени у пространства имен делает невозможным его использование с помощью директивы или объявления using. Поэтому недопустимо использование имен из неименованного пространства имен в любом файле, кроме того, что содержит объявление пространства имен.

Такое применение пространств имен служит альтернативой использованию глобальных статических переменных. Стандарт С++ говорит, что использование ключевого слова static в пространствах имен и в глобальном диапазоне доступа является устаревшим.

173

Тема 22

ШАБЛОНЫ

22.1. Шаблоны функций

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

Обобщенные функции – это функции, которые перегружают сами себя.

Все описания шаблонов функций начинаются с ключевого слова template, за которым следует список формальных параметров шаблона, заключенный в угловые скобки, каждому формальному параметру должно предшествовать ключевое слово class:

template<class T, class B>

Формальные параметры в описании шаблона используются (наряду с другими параметрами) для определения типов параметров функции, типа возвращаемого функцией значения и типов переменных, объявляемых внутри функции. Ключевое слово class фактически означает «Любой встроенный или определенный пользователем тип данных». Вместо слова class допустимо использование слова typename [2]

#include <iostream> using namespace std; template<class T>

void printArray(T *array, const int count){ for (int i = 0; i< count; i++)

cout << array[i] << '\t'; cout << endl;

}

int main(){

const int aCount = 5, bCount = 7, cCount = 6; int a[aCount] = {1,2,3,4,5};

float b[bCount] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7}; char c[cCount] = "HELLO";

cout << "Array of integer: \n"; printArray(a, aCount);

cout << "Array of float: \n"; printArray(b, bCount);

cout << "Array of char: \n"; printArray(c, cCount); return 0;

}

174

Рис. 22.1. Использование шаблонов функций

Рис. 22.2. Результат работы программы

В данной программе Т называется параметром типа. Когда компилятор обнаруживает в тексте программы вызов функции printArray, он заменяет Т во всей области определения шаблона на тип первого параметра функции printArray и С++ создает специализацию функции (или конкретизацию) вывода массива указанного типа данных Специализацию также называют порожденной функцией. А процесс порождения функции определют как ее реализацию. После этого вновь созданная функция компилируется.

Например, так, как показано на рис. 22.3, если массив целого типа.

void printArray(int *array, const int count)

{

for (int i = 0; i< count; i++) cout << array[i] << '\t';

cout << endl;

}

Рис. 22.3. Создание конкретной функции для типа int

Каждый формальный параметр из описания шаблона функции должен появиться в списке параметров функции по крайней мере один раз. Имя формального параметра может использоваться в списке параметров заголовка шаблона только один раз. Одно и то же имя формального параметра шаблона функции может использоваться несколькими шаблонами.

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

Если порождаемая функция вызывается с определяемым пользователем типом в качестве параметра и если этот шаблон использует операции (например, ==, +, <= и др.) с объектами этого типа, то эти операции должны быть перегружены.

Шаблонную функцию можно перегрузить вручную. Такая функция называется

явная специализация.

Например, для типа массива элементов типа char* можно явно переопределить шаблон функции printArray:

175

ку родового шаблона класса на специфический тип данных при создании объекта класса.

Шаблоны классов не могут вкладываться друг в друга.

Шаблоны фактически являются макросами, поэтому они должны полностью определяться в заголовочных файлах [2]. Если компилятор поддерживает ключевое слово export, то можно расположить определения шаблонных методов в отдельном файле.

//заголовочный файл myvector.h

#ifndef _MYVECTOR_H_ #define _MYVECTOR_H_

template<typename T, int size> class Vector

{

public:

Vector();

~Vector();

T& operator[](int); private:

T* arr;

};

template<typename T, int size> Vector<T, size>::Vector()

{

arr = new T[size]; for(int i =0; i<size; i++)

arr[i] = 0;

}

template<typename T, int size>

Vector<T, size>::~Vector()

{

delete[] arr;

}

template<typename T, int size>

T& Vector<T, size>::operator [](int index)

{

if(index<0||index >= size) throw int(index);

return arr[index];

}

#endif

Рис. 22.8. Определение шаблона безопасного массива Vector

178

//файл использования шаблона test.cpp

#include <iostream> #include "myvector.h" #include <stdlib.h> #include <time.h> using namespace std;

int main()

{

const int size1 = 10, size2 = 15; Vector<int, size1> obint1; Vector<int, size2> obint2; srand(time(0));

try

{

for(int i=0; i<size1;i++)

{

obint1[i] = rand()%101-100; cout<<obint1[i]<<'\t';

}

cout<<endl;

//cout<<obint2[size2]<<endl; - этот оператор приведет к выходу

//за границы массива и генерации исключения for(int i=0; i<size2;i++)

{

obint2[i] = rand()%101; cout<<obint2[i]<<'\t';

}

cout<<endl;

return 0;

}

catch(int i)

{

cout<<"Wrong index "<<i<<endl;

}

}

Рис. 22.9. Использование шаблона безопасного массива Vector

На рис.22.8 - 22.9 показана программа, создающая шаблон безопасного массива. У класса Vector только один метод – перегруженная операция индексации. Если при обращении к элементу такого массива указать несуществующий индекс, будет сгенерировано исключение. Это позволит обезопасить программу на этапе выполнения.

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

179

операторную функцию operator[] в качестве l-value, то есть вызов функции может быть помещен слева от знака присваивания. И работа с объектом класса Vector ведется точно так же, как если бы это был обычный массив.

Шаблон класса Vector использует два параметра [2]: первый – это параметр типа, а второй аргумент шаблона параметром типа не является. Это аргумент заранее известного типа int, который затем используется в качестве размера создаваемого массива. Задается этот параметр точно так же, как любой параметр функции – указывается тип аргумента и имя. При создании экземпляров шаблона Vector значение второго параметра должно быть известно на момент компиляции, то есть это должна быть константа.

На тип параметра шаблона, который не является параметром типа, накладываются определенные ограничения. В этом случае разрешено использовать только целочисленные типы, ссылки и указатели. Кроме того, изменение значения таких параметров является недопустимым. То есть, например, в теле функции operator[]() следующая инструкция является недопустимой:

size = 10;

При компиляции программы на рис. 22.8 - 22.9 будут созданы две специализации шаблона Vector, потому что не смотря на один и тот же тип элементов, размеры создаваемых массивов разные.

Шаблон класса Vector будет хорошо работать со всеми встроенными и пользовательскими типами данных. Если в качестве элемента массива будет выступать другой массив, то шаблон класса Vector необходимо явным образом специализировать.

При создании шаблонов можно использовать аргументы по умолчанию. В объявлении массива на рис. 22.8 это могло бы выглядеть следующим образом: template<typename T=int, int size=10>

class Vector{...};

При создании экземпляров класса Vector будут действовать те же правила, что и при указании значений по умолчанию для функций. То есть объект типа Vector можно создать тремя способами:

1.Вообще без задания типа и размера массива, тогда тип элементов будет равен int, а размер массива будет 10 элементов.

2.Указав только тип элементов, размер будет равен 10.

3.Указав и тип элементов, и размер массива.

Шаблоны могут вступать в различные отношения между другими шаблонами и между обычными классами [1].

Шаблоны и наследование связаны друг с другом следующим образом:

1. Шаблон класса может производным от шаблона класса (см.

рис. 22.10);

2.Шаблон класса может являться производным от обычного класса;

3.Специализация шаблона класса может быть производной от шаблона класса;

180

4. Обычный класс может быть производным от специализации шаблона класса (см. рис. 22.11 - 22.12).

template<class T> class A

{

protected: T a;

public:

A(T b){a=b;}

T geta(){return a;} void seta(T b){a=b;}

};

template<class T> class B:public A<T>

{

protected: T b;

public:

B(T a, T c):A<T>(c){b=a;} T getb(){return b;}

void setb(T a){b=a;}

};

int main()

{

A<int> a(3);

B<float> b(5.6,17.1); cout<<b.getb()<<'\t'<<b.geta()<<endl; cout<< a.geta()<<endl;

return 0;

}

Рис. 22.10. Наследование шаблона класса от шаблона класса

Шаблоны классов могут вступать между собой в отношения дружественности. Кроме того шаблоны классов могут дружить с обычными классами, а также с шаблонными (рис. 22.11) и с обычными функциями

template<class T> class C; template<class T>

class A{

friend class C<T>; protected:

T a; public:

A(T b){a=b;}

T geta(){return a;} void seta(T b){a=b;}};

Рис. 22.11. Объявление дружественным шаблон класса

181