Шаблоны

i1; // Неопределенное значение
int

i2 = int(); // Переменная инициализируется нулем

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

Явная инициализация базовых типов

template
void F()
{
T x = T();
. . .
}

не всегда последователен.
следует указывать везде, кроме трех мест

в объявлениях классов или определениях их функций:
1. За ключевым словом class в самом начале.
2. При указании имени конструктора.
3. При указании имени деструктора.
Аргументы конструкторов и деструкторов должны быть параметризо-ванными, как и все использования имени класса за исключением трех указанных случаев. При любом использовании параметризованного типа или функции необходимо указывать параметр.
В трех указанных ситуациях компилятор может сделать разумные предположения по поводу отсутствующих символов.

Передача параметра

Type* data;
public:
ListNode(Type* d, ListNode* n =

NULL);
~ListNode();
Type* Data();
ListNode* Next();
};

Где не надо ?

довольно редко. Увидев такой класс, я обычно затеваю с автором

долгую беседу о принципах построения программ. Тем не менее, иногда использование многоаргументных шаблонов бывает оправданным.
Синтаксис выглядит аналогично, разве что вместо используется список типа .
Наконец, параметр не обязан быть классом. Он может быть структурой или еще чем-нибудь, хотя именно классы прочно удерживают ведущие позиции на рынке параметров. »

(из книги Джефф Элджер. С++. Библиотека программиста)

А если несколько параметров?

Type element;

public:
clt (Type e) { element

= e; };
Type& get(){ return element; }

friend ostream& operator << (ostream &os, clt & Obj)
{
return os << "Element " << Nobj++ << "=" << Obj.element << endl;
}
};

Шаблоны классов со статическими членами

main()
{
clt Num(5);
clt Str("Message");
clt

dbl(5.9);
cout << Num << Str;
Num.get()++;
Str.get() = "Hi-hi";
cout << Num << Str;
clt Obj(12);
cout << Obj << dbl;
char s; cin >> s;
}

Шаблоны классов со статическими членами

нет.
Параметризованный класс может выступать в качестве базового; в этом

случае производный класс также будет параметризованным с тем же форматом аргументов, что и в базовом классе.
В производном классе могут добавляться новые параметры, но разбираться в полученной куче вам надоест уже с третьей строки…
Чаще всего встречается наследование параметризованного типа от непараметризованного.

Наследование

всех функций которого занимает 1000 строк. При каждом его использовании

для нового типа компилятор радостно выплевывает очередные 1000 строк расширенного кода. Это слишком высокая цена за безопасность типа.
2) Допустим, вы продаете библиотеку классов и не хотите поставлять исходный текст, а только интерфейсы. Если библиотека содержит параметризованные функции, они должны находиться в открытом для всего мира файле .h. Обидно.
3) Допустим, кто-то передает вам замечательный, но небезопасный по отношению к типам класс или библиотеку классов. Может быть, он был написан на компиляторе, который не поддерживает шаблоны, или автор просто не верит в шаблоны. Вам хочется подправить код и сделать его безопасным с помощью шаблонов. Но хотите ли вы переделывать все подряд, включать весь код реализации в файлы .h и добавлять в объявления класса параметры и символы <>?

Комбинации простых и параметризованных типов

с простым, непараметризованным типом.
Когда это будет сделано, в 99

случаях из 100 параметризованный тип «заворачивает» простой тип в симпатичную, мягкую и безопасную по отношению к типам оболочку.
При этом простой класс не изменяется — просто параметризованный класс помещается между небезопасным классом и пользователем.

Комбинации простых и параметризованных типов

Если вы попытаетесь ввести безопасность типов в производном классе с

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

(из книги Джефф Элджер. С++. Библиотека программиста)

Небезопасные типы в открытых базовых классах

закрытым базовым классом безопасного шаблона.
Небезопасные типы в закрытых базовых

классах

class UnsafeNode { // ListNode из предыдущего примера
private:
UnsafeNode* next;
void* data;
public:
UnsafeNode(void* d, UnsafeNode* n);
virtual ~UnsafeNode();
UnsafeNode* Next();
void* Data();
};
template
class SafeNode : private UnsafeNode {
public:
SafeNode(Type* d, SafeNode* n) : UnsafeNode(d, n) {}
virtual ~SafeNode() { delete (Type*)Data(); }
SafeNode* Next() { return (SafeNode*)UnsafeNode::Next(); }
Type* Data() { return (Type*)UnsafeNode::Data(); }
};

Базовый класс недоступен для клиентов производного шаблона

тип. Рассмотрим пример:

Ключевое слово typename
template
class MyClass {
typename SubType

* ptr;
. . .
};

В этом примере ключевое слово typename поясняет, что SubType является подтипом класса T. Тогда ptr – указатель на тип T::SubType.
Без typename идентификатор SubType интерпретируется как статический член класса, а следующая строка воспринимается

как умножение значения SubTyp типа T на ptr: T::SubType * ptr .
Поскольку идентификатор SubType объявлен типом, любой тип, используемый вместо T, должен иметь в себе внутренний тип SubType.
Например, использование типа Q в
качестве аргумента шаблона, возможно
только при условии, что в Q определен
внутренний тип SubType:

MyClass x;
// Объявление класса
class Q {
typedef int SubType;
. . .
};

общем случае подтип может быть абстрактным типом данных (например классом).

В этом случае:
class Q {
class SubType;
. . .
};
Ключевое слово typename всегда должно квалифицировать идентификатор шаблона как тип, даже если другая интерпретация не имеет смысла. В С++ любой идентификатор шаблона, указанный без ключевого слова typename, интерпретируется как значение.
Ключевое слово typename также может использоваться вместо слова class в определении шаблона:
template
class clt {
. . .
};

Еще о typename

такой нетипизированный параметр все равно считается частью определения типа.
Так

например, аргумент шаблона стандартного класса bitset <> содержит количество входящих в него бит.

bitset <32> field32; // поле на 32 бита
bitset <50> field50; // поле на 50 бит

Эти поля будут относится к разным типам, поскольку при их определении задаются разные значения аргументов шаблона. Следовательно, их нельзя присваивать или сравнивать друг с другом (при отсутствии соответствующего преобразования типа).

Нетипизированные параметры шаблонов

объявлять объекты класса MyClass как с одним, так и с

двумя аргументами.

template >
class MyClass . . .

При передаче одного аргумента вместо второго используется параметр по умолчанию:
MyClass x1; // Эквивалентно: MyClass > x1;

Аргументы шаблонов по умолчанию могут определяться на основе предыдущих аргументов.

Параметры шаблонов по умолчанию

a {
private:
virtual void f(int) { cout

b : public a {
public:
class a; friend
void f(double) { cout<<"b double"; }
void f(int) { cout<<"b int"; }
};
 
int main (void) {
b* o = new b;
o->f(0.5);
return 0;
}

Варианты ответа:

возникнет ошибка компиляции
b int
b double
a int

a {
private:
virtual void f(int) { cout

b : public a {
public:
class a; friend
void f(double) { cout<<"b double"; }
void f(int) { cout<<"b int"; }
};
 
int main (void) {
b* o = new b;
o->f(0.5);
return 0;
}

Варианты ответа:

возникнет ошибка компиляции
b int
b double
a int

В класса b директива friend относится к f(double), т.е. она дружественная функция (не член класса), хоть и определена в классе. В main() идет вызов o->f(), т.е. функции, являющейся ЧЛЕНОМ КЛАССА b, т.е. функции b::f(int).

public:
A() { }

operator int() { return 10; };
operator float() const { return 2.0; };
};
class B
{
public:
B() { }
operator int() const { return 5; };
operator float() { return 1.0; };
};
int main()
{
A a;
B b;
std::cout << a + b << std::endl;
return 0;
}

Варианты ответа:

Код не корректен: Выбор операторов приведения для операндов сложения не определен в данном контексте
7
Код не корректен по другой причине
15
11
3

public:
A() { }

operator int() { return 10; };
operator float() const { return 2.0; };
};
class B
{
public:
B() { }
operator int() const { return 5; };
operator float() { return 1.0; };
};
int main()
{
A a;
B b;
std::cout << a + b << std::endl;
return 0;
}

Варианты ответа:

Код не корректен: Выбор операторов приведения для операндов сложения не определен в данном контексте
7
Код не корректен по другой причине
15
11
3

Смотреть необходимо не на типы описанных операторов приведения, а на их константность. Для неконстантных экземпляров будут выбраны они.

virtual A &Get() {
std::cout

*this;
}
};
struct B : A {
B &Get() {
std::cout << "B“; return *this;
}
};
int main(int, char *argv[]) {
B b;
A &a1(b), a2(a1), *a3(&a2), *a4(&a1);
b.Get();
a1.Get();
a2.Get();
a3->Get();
a4->Get();
}

virtual A &Get() {
std::cout

*this;
}
};
struct B : A {
B &Get() {
std::cout << "B“; return *this;
}
};
int main(int, char *argv[]) {
B b;
A &a1(b), a2(a1), *a3(&a2), *a4(&a1);
b.Get();
a1.Get();
a2.Get();
a3->Get();
a4->Get();
}

BBAAB