Автоматический вывод типов в шаблонах

 

Рассмотрим еще один пример шаблона - функцию сложения двух операндов:

 

template < typename T >
T add(T a, T b)

{

return a + b;

}

 

Отличие этого примера от abs в том, что предполагается передача двух аргументов одного и того же типа T. Если не указывать аргумент шаблона в явном виде, не действуют никакие правила преобразования типов, как для обычных функций. Компилятор позволяет в таком случае только однозначное соответствие во избежание недоразумений. Первые два примера компилируются, так как оба операнда имеют одинаковый однозначный тип, а последний - не компилируется, поскольку тип T из такого контекста неоднозначен:

 

int main ()

{

int x = add(2, 3); // ОК: add< int >

double y = add(2.5, 3.5); // ОК: add< double >

 

double z = add(2, 2.5); // Ошибка

}

 

error C2782: 'T add(T,T)': template parameter 'T' is ambiguous

see declaration of 'add'

could be 'double'

or 'int'

 

Проблему можно решить явным указанием типа либо преобразованием фактического аргумента:

 

double z1 = add< int >(2, 2.5); // ОК: add< int >, округление 2-го операнда

double z2 = add< double >(2, 2.5); // ОК: add< double >

 

double z3 = add((double) 2, 2.5); // ОК: add< double >

double z4 = add(2, (int) 2.5); // ОК: add< int >

 

Чтобы разрешить работу с несколькими типами сразу, шаблоны могут содержать несколько аргументов. Например:

 

template < typename RT, typename T1, typename T2 >
RT add (T1 a, T2 b)

{

return a + b;

}

 

Для явного указания аргументов такого шаблона при вызове следует перечислить фактические типы в угловых скобках через запятую:

 

short x = 20000;

int result = add< int, char, short >(‘a’, x);

 

Автоматический вывод типов может быть легко получен для передаваемых аргументов:

 

short x = 20000;

int result = add< int >(‘a’, x);

 

До С++’11 в подобных задачах тип результата приходилось указывать в явном виде в любом случае. Еще одну хитрость можно произвести на основе новейшей конструкции языка - операторе decltype. Такой оператор можно применить к любому выражению и использовать в контекстах, в которых обычно ожидается тип данных. Например:

 

decltype (2.5) x;

 

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

 

template < typename T1, typename T2 >

decltype (T1() + T2()) add (T1 a, T2 b)

{

return a + b;

}

 

Разберем данное выражение подробнее:

 

decltype (T1() + T2())

 

Во время компиляции (не во время выполнения!) создаются значения по умолчанию для типа T1 и типа T2. Для числовых типов это приведет к созданию нулевых значений, но соответствующих типов. Далее формируется выражение сложения. Его значение никого не интересует, зато компилятор может при помощи оператора decltype автоматически вывести его тип, в соответствии с правилами языка. В итоге, функция add получает правильный возвращаемый тип без явного указания. Наконец, правильно и без лишнего синтаксического мусора будет работать такой клиентский код:

 

short x = 20000;

int result = add(‘a’, x);

 

Использование оператора decltype в качестве возвращаемого типа функций визуально нравится далеко не всем, поскольку трудно воспринять границу между возвращаемым типом и названием функции. В связи с этим, в новейшем стандарте С++14 была предложена альтернативная запись, подчеркивающая автоматический вывод возвращаемого типа, в которой выражение на основе decltype указывается не в начале объявления, а в конце после аргументов:

 

template < typename T1, typename T2 >

auto add (T1 a, T2 b) -> decltype (T1() + T2())

{

return a + b;

}

 

Какую форму записи выбрать - дело вкуса программиста. Поведение обеих форм эквивалентно.

 

Шаблоны классов

 

Аналогично функциям, классы также можно параметризовать относительно одного или нескольких типов-аргументов. При помощи шаблонов классов удобно реализуются универсальные структуры данных. Как и в шаблоне функции, объявлению класса должна предшествовать часть template < typename T> со списком аргументов. Аргументов также может быть несколько.

 

При инстанцировании шаблона класса компилятор, также как и с функциями, создает копию его определения с подставленными фактическими типами. Также инстанцируются тела только тех методов, которые реально вызываются в коде. Интересной особенностью схемы компиляции является тот факт, что если метод конкретного экземпляра шаблона класса не вызывается ни кем в коде, то компилятор даже не пытается инстанцировать такой метод. Отсюда вытекает негласное правило, что при разработке шаблонов очень важно инстанцировать весь написанный код в целях простейшего тестирования, поскольку без реального вызова функции - ее тело не будет никем проверяться и может содержать невыявленные ошибки!

 

#include <iostream>

 

template < typename T>

class Test

{

public:

void f (T x)

{

// Вообще-то, не факт, что переменную типа T можно разыменовать!

* x = 5;

}

 

void g ()

{

std::cout << "Saying hello!" << std::endl;

}
};

 

int main ()

{

// Создаем экземпляр шаблона класса с типом int.

// Разыменовывать тип int, как требует функция f, нельзя,

// но все прекрасно работает, потому что мы не вызываем функцию f!

Test< int > t;

t.g();
}

 

 

Каждый инстанцированный вариант шаблона класса - это отдельный класс. Несмотря на порождение от одного и того же источника, типы Test<int> и Test<short> - это разные классы, их нельзя приравнивать друг другу.

 

Также из этого вытекает, что у каждого из экземпляров будут свои наборы статических членов. Предположим, в шаблоне класса имеется статический член, подсчитывающий количество объектов. Статические переменные-члены класса Test<int> не имеют ничего общего со статическими членами класса Test<short>, и потому счетчики нужно инициализировать в глобальной области отдельно, и манипулировать ими отдельно в дальнейшем:

 

#include <iostream>

 

template < typename T >

class Test

{

public:

static int ms_objectCounter;

public:

Test () { ++ ms_objectCounter; }

Test (const Test< T > & _t) { ++ ms_objectCounter; }

};

 

int Test< int >::ms_objectCounter;

int Test< short >::ms_objectCounter;

 

int main ()

{

Test< int > ti1;

Test< int > ti2 = ti1;

 

std::cout << Test< int >::ms_objectCounter << std::endl;

std::cout << Test< short >::ms_objectCounter << std::endl;

}

 

 

Аргументы шаблонов классов могут иметь типы по умолчанию, если какой-либо из типов используется чаще других:

 

template < typename T = int >

class Test

{

//...

};

 

До появления стандарта С++’11 иметь значения по умолчанию разрешалось только аргументам шаблонов классов, но не функций. В новой редакции это ограничение для функций было снято.

 

Ниже приведен полный пример полезного класса-шаблона для обобщенного АТД “стек” фиксированного размера. Отметим несколько основных правил написания шаблонов классов:

 

1. При определении шаблона класса может возникнуть путаница с использованием его имени внутри определения. Когда контекст требует использовать имя класса, например, чтобы задать конструктор, оно указывается как обычно:

 

// Конструктор

Stack (int _size = 10);

 

Когда же речь идет о классе как о типе, рекомендуется явно указывать его в обобщенном виде с указанием аргумента шаблона:

 

// Оператор копирующего присвоения

Stack< T > & operator = (const Stack< T >& _s);

 

2. Как и для обычного класса, реализация методов шаблона класса может находиться как внутри объявления класса, так и за его пределами. Если размещать реализацию методов отдельно от определения класса, то нужно использовать следующий синтаксис:

 

template < typename T >

Stack< T >::Stack (int _size)

: m_size(_size)

{

m_pData = new T[ m_size ];

m_pTop = m_pData;

}

 

3. Чаще всего тела методов шаблонов классов размещают непосредственно в заголовочном файле после объявления класса. Это работает корректно, даже если функции не объявляются как встраиваемые (inline). CPP-файла для шаблона-класса чаще всего не создают вообще. Именно так выглядит практически весь код стандартной библиотеки шаблонов. Такой стиль реализации, не свойственный обычным классам C++, обуславливается особенностями компоновки шаблонов. Пока примем это как утверждение без объяснения, а детально разъясним позже.

 

4. Пока не известен конкретный тип аргумента шаблона, ничего нельзя утверждать о размере этого объекта. Возникает вопрос способа передачи обобщенных значений в методы стека - по значению или по ссылке? Во избежание избыточных копирований для больших объектов обычно в обобщенном коде передают ссылки, надеясь что производительность передачи ссылки для маленьких объектов (например, char) не слишком уступит передаче по значению:

 

void push (const T& _value);

 

 

stack.hpp

 

#ifndef _STACK_HPP_

#define _STACK_HPP_

 

#include <stdexcept>

#include <initializer_list>

 

//*****************************************************************************

 

template < typename T >

class Stack

{

 

/*-----------------------------------------------------------------*/

 

public:

 

/*-----------------------------------------------------------------*/

 

// Конструктор

Stack (int _size = 10);

 

// Конструктор по списку инициализаторов

Stack (std::initializer_list< T > _l);

 

// Конструктор копий

Stack (const Stack< T > & _s);

 

// Конструктор перемещения

Stack (Stack< T > && _s);

 

// Деструктор

~Stack ();

 

// Оператор копирующего присвоения

Stack< T > & operator = (const Stack< T >& _s);

 

// Оператор перемещающего присвоения

Stack< T > & operator = (Stack< T > && _s);

 

// Метод добавления значения в стек

void push (const T& _value);

 

// Метод удаления значения с вершины стека

void pop ();

 

// Метод доступа к значению на вершине стека

T & top () const;

 

// Метод определения пустоты стека

bool isEmpty () const;

 

// Метод определения заполненности стека

bool isFull () const;

 

/*-----------------------------------------------------------------*/

 

private:

 

/*-----------------------------------------------------------------*/

 

// Размер стека

int m_size;

 

// Указатель на начало блока данных

T* m_pData;

 

// Указатель на вершину стека

T* m_pTop;

 

/*-----------------------------------------------------------------*/

 

 

};

 

//*****************************************************************************

 

// Реализация конструктора

template < typename T >

Stack< T >::Stack (int _size)

: m_size(_size)

{

// Проверка корректности размера стека

if (m_size <= 0)

throw std::logic_error("Non-positive size");

 

// Выделяем массив для хранения данных стека

m_pData = new T[ m_size ];

 

// Устанавливаем вершину в позицию начала блока данных

m_pTop = m_pData;

}

 

//*****************************************************************************

 

// Реализация конструктора по списку инициализаторов

template < typename T >

Stack< T >::Stack (std::initializer_list< T > _l)

: Stack(_l.size())

{

// Поэлементное копирование содержимого списка инициализаторов

for (const T & x: _l)

push(x);

}

 

//*****************************************************************************

 

// Реализация конструктора копий

template < typename T >

Stack< T >::Stack (const Stack< T >& _s)

: m_size(_s.m_size)

{

// Выделяем массив для хранения данных стека

m_pData = new T[ m_size ];

m_pTop = m_pData;

 

// Поочередно вставлем элементы

int nActual = _s.m_pTop - _s.m_pData;

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

push(_s.m_pData[ i ]);

}

 

//*****************************************************************************

 

// Реализация конструктора перемещения

template < typename T >

Stack< T >::Stack (Stack< T > && _s)

: m_size(_s.m_size),

m_pData(_s.m_pData),

m_pTop(_s.m_pTop)

{

// Отбираем ресурсы у “умирающего” другого стека

_s.m_pData = _s.m_pTop = nullptr;

}

 

//*****************************************************************************

 

// Реализация деструктора

template < typename T >

Stack< T >::~Stack ()

{

delete[] m_pData;

}

 

//*****************************************************************************

 

// Реализация оператора копирующего присвоения

template < typename T >

Stack< T >& Stack< T >:: operator = (const Stack< T >& _s)

{

// Защита от присвоения на самого себя

if (this == & _s)

return * this;

 

// Освобождаем старый блок и выделяем новый

delete[] m_pData;

m_size = _s.m_size;

m_pData = new T[ m_size ];

 

// Копируем полезные данные из другого стека

int nActual = _s.m_pTop - _s.m_pData;

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

m_pData[ i ] = _s.m_pData[ i ];

 

// Выставляем вершину стека в аналогичную другому стеку позицию

m_pTop = m_pData + nActual;

 

// Возвращаем ссылку на себя

return * this;

}

 

//*****************************************************************************

 

// Реализация оператора перемещающего присвоения

template < typename T >

Stack< T >& Stack< T >:: operator = (Stack< T > && _s)

{

// Защита от присвоения на самого себя

if (this == & _s)

return * this;

 

// Освобождаем старый блок данных

delete[] m_pData;

 

// Присваиваем себе ресурсы другого “умирающего” стека

m_size = _s.m_size;

m_pData = _s.m_pData;

m_pTop = _s.m_pTop;

 

// Отцепляем ресурсы от другого стека

_s.m_pData = _s.m_pTop = nullptr;

 

// Возвращаем ссылку на себя

return * this;

}

 

//*****************************************************************************

 

// Реализация метода добавления значения в стек

template < typename T>

void Stack< T >::push (const T& _value)

{

// Стек не должен быть заполнен на 100% в данный момент

if (isFull())

throw std::logic_error("Stack overflow error");

 

// Размещаем новое значение в стеке и увеличиваем указатель-вершину

* m_pTop++ = _value;

}

 

//*****************************************************************************

 

// Реализация метода удаления значения с вершины стека

template < typename T >

void Stack< T >::pop ()

{

// Стек не должен быть пустым в данный момент

if (isEmpty())

throw std::logic_error("Stack underflow error");

 

// Уменьшаем указатель-вершину

m_pTop--;

}

 

//*****************************************************************************

 

// Реализация метода доступа к значению на вершине стека

template < typename T >

T& Stack< T >::top () const

{

// Стек не должен быть пустым в данный момент

if (isEmpty())

throw std::logic_error("Stack is empty");

 

// Возвращаем ссылку на значение, находящееся под указателем-вершиной

return *(m_pTop - 1);

}

 

//*****************************************************************************

 

// Реализация метода определения пустоты стека

template < typename T >