C++ для начинающих Шаблоны классов Первое знакомство

Опубликовано 26.09.2012 | Автор: admin

Шаблоны — это автоподстановка типа. Иногда внутри классов выгодно использовать автоподстановку типа.

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

Напишем простой класс, суммирующий два значения. Предположительно мы совсем новички и даже не разделяем виды типов:

    //Листинг #1.1      Сумма двух значений         Visual Studio
#include <iostream>

using std::cin;
using std::cout;

class MyClass {
	int x, y;
public:
	int sum(int x, int y) {
		return x + y;		//отдаём сумму, типом суммы будет целое int
	}
};

int main() {

	MyClass object;
	cout << object.sum(15, 8) << '\n';		//15 + 8 = 23, это и выводится на экран, как и должно быть. Всё правильно
	std::cin.get();
}

//Листинг #1.1 Сумма двух значений Visual Studio

#include <iostream>

using std::cin;

using std::cout;

class MyClass {

int x, y;

public:

int sum(int x, int y) {

return x + y; //отдаём сумму, типом суммы будет целое int

}

};

int main() {

MyClass object;

cout << object.sum(15, 8) << '\n'; //15 + 8 = 23, это и выводится на экран, как и должно быть. Всё правильно

std::cin.get();

}

Всё прекрасно, мы справились, написали работающую программу. Но в один прекрасный момент нам понадобилось усовершенствовать программу так, чтобы она вычисляла не целые числа. Мы начинаем менять типы:

//Листинг #1.2      Сумма двух значений     Visual Studio
#include <iostream>

using std::cin;
using std::cout;

class MyClass {
	int x, y;
public:
	double sum(double x, double y) {		//поменяли все int на double, чтобы наверняка!
		return x + y;
	}
};

int main() {

	MyClass object;
	cout << object.sum(15.3, 8) << '\n';		//15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно
	std::cin.get();
}

//Листинг #1.2 Сумма двух значений Visual Studio

#include <iostream>

using std::cin;

using std::cout;

class MyClass {

int x, y;

public:

double sum(double x, double y) { //поменяли все int на double, чтобы наверняка!

return x + y;

}

};

int main() {

MyClass object;

cout << object.sum(15.3, 8) << '\n'; //15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно

std::cin.get();

}

Мы снова радуемся. Вот оно, мы справились, всё заработало. Но наступает момент, когда к складываемым значением добавляется нечисловой тип. Для удобства понимания этим типом будет тип std::string. И тут нас ждёт простор реализаций… Во-первых, мы можем перегрузить функцию внутри класса:

//Листинг #1.3      Сумма двух объектов
#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::string;

class MyClass {
	int x, y;
public:
	double sum(double x, double y) {
		return x + y;
	}

	string sum(string x, string y) {		//сделали перегрузку функции sum
		return x + y;
	}
};

int main() {

	MyClass object;
	cout << object.sum(15.3, 8) << '\n';		//15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно
	cout << object.sum("Hello, ", "world!") << '\n';	//Объединили строки путём сложения
	std::cin.get();
}

//Листинг #1.3 Сумма двух объектов

#include <iostream>

#include <string>

using std::cin;

using std::cout;

using std::string;

class MyClass {

int x, y;

public:

double sum(double x, double y) {

return x + y;

}

string sum(string x, string y) { //сделали перегрузку функции sum

return x + y;

}

};

int main() {

MyClass object;

cout << object.sum(15.3, 8) << '\n'; //15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно

cout << object.sum("Hello, ", "world!") << '\n'; //Объединили строки путём сложения

std::cin.get();

}

Мы такие радуемся до поры до времени, программа работает правильно, и тут в один момент приходит необходимость складывать другой тип объектов. Мы думаем, и что же, это каждый раз нужно функции перегружать? Не, так не пойдёт, слишком напряжно. Думаем, такие, думаем и придумываем использовать шаблоны функции. И изменяем класс:

//Листинг #2
#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::string;

class MyClass {
	int x, y;
public:
	template <typename T>
	T sum(T x, T y) {
		return x + y;
	}
};

int main() {

	MyClass object;
	cout << object.sum<double>(15.3, 8) << '\n';		//15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно
	cout << object.sum<string>("Hello, ", "world!") << '\n';	//Объединили строки путём сложения
	std::cin.get();
}

//Листинг #2

#include <iostream>

#include <string>

using std::cin;

using std::cout;

using std::string;

class MyClass {

int x, y;

public:

template <typename T>

T sum(T x, T y) {

return x + y;

}

};

int main() {

MyClass object;

cout << object.sum<double>(15.3, 8) << '\n'; //15.3 + 8 = 23.3, это и выводится на экран, как и должно быть. Всё правильно

cout << object.sum<string>("Hello, ", "world!") << '\n'; //Объединили строки путём сложения

std::cin.get();

}

Код сократился, теперь нам нет нужды дёргаться лишний раз, если вдруг добавиться что-то новое, умеющее проводить операцию +. И живём мы некоторое время и пишем коды в подобном стиле, а потом нас осеняет одна идея: "А нельзя ли нам не указывать каждый раз функциям типы?. Ведь каждый вызов функции сопровождается явным указанием необходимых типов. Ведь с каждым новым ручным указанием типа повышается риск написать тип не тот. Так сказать, немного типом промахнуться и не успеть заметить. Думаем мы, как быть, думаем и понимаем, что если мы научим объект опозновать тип, то опознаваемый объектом тип можно без проблем подставлять в нужные функции. Преимущество научения объекта нужному типу в том, что объекту тип нужно отдать единожды, в противовес многократной подаче типа функциям. А что нам для этого нужно? Правильно, шаблонный класс! И переделываем мы программу, делая класс шаблонным:

//Листинг #3        Шаблонный класс
#include <iostream>
#include <string>

using std::cin;
using std::cout;
using std::string;


template <typename T>
class MyClass {
	int x, y;
public:

	T sum(T x, T y) {
		return x + y;
	}
};

int main() {

	MyClass<double> object_double;
	MyClass<string> object_string;

	cout << object_double.sum(35.3, 88.2) << '\n';		//35.3 + 88.2 = 123.5
	cout << object_string.sum("Hello ", "world!") << '\n';		//ОК, сложили строки

	std::cin.get();
}

//Листинг #3 Шаблонный класс

#include <iostream>

#include <string>

using std::cin;

using std::cout;

using std::string;

template <typename T>

class MyClass {

int x, y;

public:

T sum(T x, T y) {

return x + y;

}

};

int main() {

MyClass<double> object_double;

MyClass<string> object_string;

cout << object_double.sum(35.3, 88.2) << '\n'; //35.3 + 88.2 = 123.5

cout << object_string.sum("Hello ", "world!") << '\n'; //ОК, сложили строки

std::cin.get();

}

Теперь мы можем создавать объекты под подходящие типы и от определённых для объектов типов отталкиваться. Обратите внимание, что мы избавились от шаблонности функции, подставляя туда тип, уже подставленный в объект.

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

Если вы создаёте многофайловый проект, то и сам класс и его реализацию помещайте в один и тот же файл. Обычно файлу дают расширение .hpp, чтобы было понятно, что в файле реализован шаблонный класс.

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

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

//Листинг #4
#include <iostream>
#include <string>

using std::cerr;
using std::cin;
using std::cout;
using std::string;

template <typename T>
class MyArray {
public:
	enum {N = 10};		//Массив в 10 элементов
	void add(const T value, const int index);		//В параметре используем подставляемый объектом тип
	void print();
private:
	int cursor = 0;		//позиция в массиве
	T arr[N];			//Массив, тип которого определяется объектом класса, подставляется в класс и приходит сюда как T
};

/*ФУНКЦИЯ ДОБАВЛЕНИЯ ЭЛЕМЕНТА В МАССИВ*/
template <typename T>
void MyArray<T>::add(const T value, const int index) {
	cursor = index;
	if (cursor <0 || cursor >= N) {
		cerr << "index " << cursor << " invalid, cancel\n";		//Сообщаем о нарушении границы и об отмене операции
		return;
	}


	arr[cursor] = value;	//Если позиция вставки легальна для массива arr, то записываем туда значение

}

/*ФУНКЦИЯ ВЫВОДА МАССИВА НА ЭКРАН*/
template <typename T>
void MyArray<T>::print() {
	for (int i = 0; i < N; i++) {
		cout << '{' << arr[i] << "}\t";
	}
}

int main() {
	string S[10] = {		//Элементы этого массива будут использованы для записи в массив нашего класса
		"Hello",
		"World",
		"How",
		"my name Wasa",
		"Algebra, Geometry, Rus language"
	};

	MyArray<int> int_arr;
	MyArray<string> string_arr;

	//Заполняем численный массив значениями по порядку
	for (int i = 0; i < 20; i++) {		//Предположительно, мы ошиблись и вышли за пределы массива
		int_arr.add(i, i);				//Добавляем значения
	}

	///////////////////////////////////////////

	//Заполняем строковой массив строками. Можно посредством клавиатуры, но мне удобнее немного автоматизировать, поэтому из существующего массива
	for (int i = 0; i < sizeof(S) / sizeof(string); i++) {
		string_arr.add(S[i], i);	//Заполняем
	}

	cout << "\n\noutput block\n";		//Начинаем выводить информацию (почто чтобы было видно, что вывод начался)

	cout << "int_arr:\n";
	int_arr.print();			//выводим массив целых чисел

	cout << "\nstring_array:\n";
	string_arr.print();			//выводим массив строк

	cin.get();
}

//Листинг #4

#include <iostream>

#include <string>

using std::cerr;

using std::cin;

using std::cout;

using std::string;

template <typename T>

class MyArray {

public:

enum {N = 10}; //Массив в 10 элементов

void add(const T value, const int index); //В параметре используем подставляемый объектом тип

void print();

private:

int cursor = 0; //позиция в массиве

T arr[N]; //Массив, тип которого определяется объектом класса, подставляется в класс и приходит сюда как T

};

/*ФУНКЦИЯ ДОБАВЛЕНИЯ ЭЛЕМЕНТА В МАССИВ*/

template <typename T>

void MyArray<T>::add(const T value, const int index) {

cursor = index;

if (cursor <0 || cursor >= N) {

cerr << "index " << cursor << " invalid, cancel\n"; //Сообщаем о нарушении границы и об отмене операции

return;

}

arr[cursor] = value; //Если позиция вставки легальна для массива arr, то записываем туда значение

}

/*ФУНКЦИЯ ВЫВОДА МАССИВА НА ЭКРАН*/

template <typename T>

void MyArray<T>::print() {

for (int i = 0; i < N; i++) {

cout << '{' << arr[i] << "}\t";

}

int main() {

string S[10] = { //Элементы этого массива будут использованы для записи в массив нашего класса

"Hello",

"World",

"How",

"my name Wasa",

"Algebra, Geometry, Rus language"

};

MyArray<int> int_arr;

MyArray<string> string_arr;

//Заполняем численный массив значениями по порядку

for (int i = 0; i < 20; i++) { //Предположительно, мы ошиблись и вышли за пределы массива

int_arr.add(i, i); //Добавляем значения

}

///////////////////////////////////////////

//Заполняем строковой массив строками. Можно посредством клавиатуры, но мне удобнее немного автоматизировать, поэтому из существующего массива

for (int i = 0; i < sizeof(S) / sizeof(string); i++) {

string_arr.add(S[i], i); //Заполняем

}

cout << "\n\noutput block\n"; //Начинаем выводить информацию (почто чтобы было видно, что вывод начался)

cout << "int_arr:\n";

int_arr.print(); //выводим массив целых чисел

cout << "\nstring_array:\n";

string_arr.print(); //выводим массив строк

cin.get();

}

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

Если вам всё-таки придётся использовать шаблонные функции внутри шаблонных классов, то выделять из такого класса такие функции можно по вот такой формуле:

template <typename T_class>
class MyClass {
	template <typename T_fooparam>
	T_class foo(T_fooparam);
};

template <typename T_class>			//Шаблон класса
	template <typename T_fooparam>	//Шаблон функции
	T_class MyClass<T_class>::foo(T_fooparam fooparam) {
		return T_class();		//сейчас это просто возвращение какого-нибудь объекта, неважно какого
	}

int main() {

}

template <typename T_class>

class MyClass {

template <typename T_fooparam>

T_class foo(T_fooparam);

};

template <typename T_class> //Шаблон класса

template <typename T_fooparam> //Шаблон функции

T_class MyClass<T_class>::foo(T_fooparam fooparam) {

return T_class(); //сейчас это просто возвращение какого-нибудь объекта, неважно какого

}

int main() {

}

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

Рубрика: Базовые знания, level "classer", Знакомства, Классы, Шаблонные классы, Шаблонные функции, Шаблоны

Аноним:

28.04.2013 в 2:46 пп

👿 👿 👿 👿

Ответить

SergeNikol:

08.12.2014 в 4:03 пп

Всем привет!

09.03.2016 в 4:55 пп

Запятые исправьте. Мозг выворачивает.

Руслан:

29.07.2016 в 10:28 пп

Все хорошо только ссылку на константу в visual studio не получается сделать. Может другие компиляторах это разрешено .

admin:

31.07.2016 в 11:53 пп

Как Вы пытаетесь? Я не могу или помочь, или подсказать, или адекватно ответить, не зная, как Вами испробовалось.

Ответить