Шаблоны элементы
Объявления шаблонов (классов, функций и переменных (начиная с C++14)) могут появляются внутри спецификации элемента любого класса, структуры или объединения, которые не являются локальным классом.
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
struct Printer { // общий функтор
std::ostream& os;
Printer(std::ostream& os) : os(os) {}
template<typename T>
void operator()(const T& obj) { os << obj << ' '; } // шаблон элемента
};
int main()
{
std::vector<int> v = {1,2,3};
std::for_each(v.begin(), v.end(), Printer(std::cout));
std::string s {"abc"};
std::ranges::for_each(s, Printer(std::cout));
}
Вывод:
1 2 3 a b c
Частичные специализации шаблона элемента могут появляться как в области видимости класса, так и в области видимости охватывающего пространства имён. Явные специализации могут появиться в любой области видимости, в которой может появиться основной шаблон.
struct A {
template<class T> struct B; // основной шаблон элемента
template<class T> struct B<T*> { }; // OK: частичная специализация
// template<> struct B<int*> { }; // OK через CWG 727: полная специализация
};
template<> struct A::B<int*> { }; // OK
template<class T> struct A::B<T&> { }; // OK
Если объявление включающего класса, в свою очередь, является шаблоном класса, когда шаблон элемента определён вне тела класса, он принимает два набора параметров шаблона: один для включающего класса, а другой для самого себя:
template<typename T1>
struct string {
// элемент шаблон функции
template<typename T2>
int compare(const T2&);
// конструкторы тоже могут быть шаблонами
template<typename T2>
string(const std::basic_string<T2>& s) { /*...*/ }
};
// вне определения класса string<T1>::compare<T2>
template<typename T1> // для включающего шаблона класса
template<typename T2> // для шаблона элемента
int string<T1>::compare(const T2& s) { /* ... */ }
Шаблоны функций-элементов
Деструкторы и конструкторы копирования не могут быть шаблонами. Если объявлен конструктор шаблона, экземпляр которого может быть создан с помощью сигнатуры типа конструктора копирования, вместо него используется неявно объявленный конструктор копирования.
Шаблон функции-элемента не может быть виртуальным, а шаблон функции-элемента в производном классе не может переопределять виртуальную функцию-элемент из базового класса.
class Base {
virtual void f(int);
};
struct Derived : Base {
// этот шаблон элемента не переопределяет Base::f
template <class T> void f(T);
// переопределение элемента не шаблона может вызвать шаблон:
void f(int i) override {
f<>(i);
}
};
Можно объявить нешаблонную функцию-элемент и шаблонную функцию-элемент с одним и тем же именем. В случае конфликта (когда некоторая специализация шаблона точно соответствует сигнатуре функции, не являющейся шаблоном), использование этого имени и типа относится к элементу, не являющемуся шаблоном, если не указан явный список аргументов шаблона.
template<typename T>
struct A {
void f(int); // элемент не шаблон
template<typename T2>
void f(T2); // шаблон элемента
};
//определение элемента шаблона
template<typename T>
template<typename T2>
void A<T>::f(T2)
{
// некоторый код
}
int main()
{
A<char> ac;
ac.f('c'); // вызывает функцию шаблон A<char>::f<char>(char)
ac.f(1); // вызывает функцию не шаблон A<char>::f(int)
ac.f<>(1); // вызывает функцию шаблон A<char>::f<int>(int)
}
Внеклассовое определение шаблона функции-элемента должно быть эквивалентно объявлению внутри класса (смотрите определение эквивалентности в перегрузке шаблона функции), в противном случае это считается перегрузкой.
struct X {
template<class T> T good(T n);
template<class T> T bad(T n);
};
template<class T> struct identity { using type = T; };
// OK: эквивалентное объявление
template<class V>
V X::good(V n) { return n; }
// Ошибка: не эквивалентно ни одному из объявлений внутри X
template<class T>
T X::bad(typename identity<T>::type n) { return n; }
Шаблоны функций преобразования
Определяемая пользователем функция преобразования может быть шаблоном.
struct A {
template<typename T>
operator T*(); // преобразование в указатель любого типа
};
// внеклассовое определение
template<typename T>
A::operator T*() {return nullptr;}
// явная специализация для char*
template<>
A::operator char*() {return nullptr;}
// явное создание экземпляра
template A::operator void*();
int main() {
A a;
int* ip = a.operator int*(); // явный вызов A::operator int*()
}
Во время разрешения перегрузки, специализации шаблонов функций преобразования не находятся поиском по имени. Вместо этого учитываются все видимые шаблоны функций преобразования, и каждая специализация, созданная с помощью вывода аргумента шаблона (которая имеет специальные правила для шаблонов функций преобразования), используется, как если бы она была найдена путём поиска по имени.
Using-объявления в производных классах не могут ссылаться на специализации шаблонов функций преобразования из базовых классов.
|
Пользовательский шаблон функции преобразования не может иметь выведенный тип возвращаемого значения: struct S {
operator auto() const { return 10; } // OK
template<class T> operator auto() const { return 42; } // ошибка
};
|
(начиная с C++14) |
Шаблоны переменных-элементовОбъявление шаблона переменной может появиться в области видимости класса, и в этом случае оно объявляет шаблон статического элемента данных. Подробнее смотрите шаблон переменной. |
(начиная с C++14) |
Отчёты о дефектах
Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:
| Номер | Применён | Поведение в стандарте | Корректное поведение |
|---|---|---|---|
| CWG 1878 | C++14 | operator auto был технически разрешённым | operator auto запрещён |
