Infer the return type of a template function. Templates

Creating a security template To create a security template based on any other template, select the Save As command from the template's context menu. The Microsoft Management Console will then prompt you to provide a name for the new template, after which it will appear in

10.2. Specifying a Function Template A function template describes how specific functions should be constructed when given many actual types or values. The design process is called template instantiation. It is executed implicitly, as a side effect of the call

10.11. Function Template Example This section provides an example that shows how function templates can be defined and used. This defines the sort() template, which is then used to sort the elements of the array. The array itself is represented by the Array class template (see

16.1. Defining a Class Template Let's say we need to define a class that supports a queuing mechanism. A queue is a data structure for storing a collection of objects; they are placed at the end of the queue and retrieved from the beginning. The behavior of the queue is described

You can prototype a function template by pre-declaring it. This declaration informs the compiler about the presence of the template and also informs the compiler about the expected parameters. For example, the Sort function template prototype would look like this:

template void Sort(T array, Tsize size);

The names of the formal parameters of a template may not be the same in the template pre-declaration and definition. So, for example, in the following snippet both the template prototype and the template definition refer to the same function:

template T max(T, T);

template

Type max(Type a, Type b)

if (a > b) return a; else return b;

Using a Function Template

A function template describes how a particular function can be constructed based on one or more actual types. The compiler automatically creates a function body representative for the types specified in the call. This process is called specification. It occurs when a template function is called.

For example, in the following example, the min() function is instantiated twice: once with type int and once with type double:

template

Type min(Type a, Type b)

if (a< b) return a; else return b;

int x = 4, y = 5, z;

double t = 6.56, r = 3.07, p;

Function Template Specialization

A specialized template function is a regular function whose name is the same as the function in the template, but which is defined for parameters of specific types. Specialized template functions are defined when a generic template is not suitable for a particular data type. For example, the template function min

template

Type min(Type a, Type b)

if (a< b) return a; else return b;

cannot be used for strings (for the char* type), since the compiler-generated code will simply compare their memory positions (addresses). To compare strings correctly, you can define a specialized function:

char* min(char* s1, char* s2)

if (strcmp(s1,s2)>0) return s2; else return s1;

Then you can access such a function in the same way as a template function:

int i1 = 3, i2 = 5;

cout<< “max int = ” << max(i1, i2) << endl;

char* s1 = “Golden Eagle”;

char* s2 = “Perigrine Falcon”;

cout<< “max str = “ << max(s1, s2) << endl;

Class Templates

Class template gives a general definition of a family of classes using arbitrary types or constants. Pattern defines template data members And template member functions. Once a class template has been defined, you can instruct the compiler to generate a new class based on it for a specific type or constant.

Class template syntax

template<<список аргументов шаблона>>

class<имя класса>

<тело класса>

The template keyword is followed by one or more arguments (parameters) enclosed in angle brackets and separated by commas. Each argument can be a class keyword followed by an identifier indicating the parameterized type. The template argument list cannot be empty.

Next comes the class definition. It is similar to a regular class definition, except that it uses a template argument list.

Template parameters consisting of the class keyword followed by an identifier are often called type parameters. In other words, they inform the compiler that the template expects a type as an argument.

We have already previously considered such a tool as templates in C++ when we created . Why you should use templates was written in the article with function templates. There we looked at the basic provisions of templates in C++. Let's remember them.

Any template begins with the word template, be it a function template or a class template. The template keyword is followed by angle brackets −< >, which list a list of template parameters. Each parameter must be preceded by the reserved word class or typename . The absence of these keywords will be interpreted by the compiler as . Some examples of template declarations:

Template

Template

Template

The typename keyword tells the compiler that the template will use a built-in data type such as: int , double , float , char , etc. And the class keyword tells the compiler that the function template will use custom data types as a parameter , that is, classes. But under no circumstances should you confuse a template parameter with a class template. If we need to create a class template with one parameter of type int and char , the class template will look like this:

Template

where T is a class template parameter that can accept any of the built-in data types, which is what we need.

And if the class template parameter must be of a custom type, such as Array , where Array is a class that describes an array, the class template will look like this:

Template class Name ( //class template body );

It’s better for you to figure this out from the beginning so that no errors arise later, even if the class template is written correctly.

Let's create a Stack class template, where , which stores similar data elements. You can push and pop data onto the stack. An element added to the stack is placed at the top of the stack. Elements of the stack are removed starting from the top. In the Stack class template, you need to create the main methods:

• Push— add an element to the stack;
• Pop- remove an element from the stack
• printStack— displaying the stack on the screen;

So, let’s implement these three methods, and in the end we will get the simplest class that implements the operation of the stack structure. Don't forget about constructors and destructors. See the code below.

#include "stdafx.h" #include template << "Заталкиваем элементы в стек: "; int ct = 0; while (ct++ != 5) { int temp; cin >> << "\nУдаляем два элемента из стека:\n"; myStack.pop(); // удаляем элемент из стека myStack.pop(); // удаляем элемент из стека myStack.printStack(); // вывод стека на экран return 0; } // конструктор template Stack ::Stack(int s) ( size = s > Stack bool Stack bool Stack void Stack ::printStack() ( for (int ix = size -1; ix >= 0; ix--) cout<< "|" << setw(4) << stackPtr << endl; }

// code Code::Blocks

// Dev-C++ code

#include using namespace std; #include template class Stack ( private: T *stackPtr; // pointer to the stack int size; // stack size T top; // top of the stack public: Stack(int = 10); // by default the stack size is 10 elements ~Stack() ; // destructor bool push(const T); // push an element onto the stack bool pop(); // remove an element from the stack void printStack()); int main() ( Stack myStack(5); // fill the stack cout<< "Заталкиваем элементы в стек: "; int ct = 0; while (ct++ != 5) { int temp; cin >> temp; myStack.push(temp); ) myStack.printStack(); // print the stack to the screen cout<< "\nУдаляем два элемента из стека:\n"; myStack.pop(); // удаляем элемент из стека myStack.pop(); // удаляем элемент из стека myStack.printStack(); // вывод стека на экран return 0; } // конструктор template Stack ::Stack(int s) ( size = s > 0 ? s: 10; // initialize the stack size stackPtr = new T; // allocate memory for the stack top = -1; // value -1 indicates that the stack empty ) // template destructor Stack ::~Stack() ( delete stackPtr; // delete the stack ) // element is a function of the Stack class for placing an element on the stack // return value is true, the operation completed successfully // false, the element was not added to the stack template bool Stack ::push(const T value) ( ​​if (top == size - 1) return false; // the stack is full top++; stackPtr = value; // push the element onto the stack return true; // successful completion of the operation ) // element function Stack class to remove an element from the stack // return value is true, the operation completed successfully // false, the stack is empty template bool Stack ::pop() ( if (top == - 1) return false; // the stack is empty stackPtr = 0; // remove an element from the stack top--; return true; // successful completion of the operation ) // displaying the stack on the screen template void Stack ::printStack() ( for (int ix = size -1; ix >= 0; ix--) cout<< "|" << setw(4) << stackPtr << endl; }

As you can see, the Stack class template is declared and defined in the file with the main function. Of course, this method of recycling templates is no good, but it will do for an example. Lines 7 - 20 declare the class template interface. The class declaration is done in the usual way, and before the class there is a template declaration, on line 7. When declaring a class template, always use this syntax.

Lines 47 - 100 contain the template function element of the Stack class, and before each function it is necessary to declare a template, exactly the same as before the class - template . That is, it turns out that the function element of a class template is declared in exactly the same way as ordinary function templates. If we described the implementation of methods inside a class, then the template header would be template There is no need to register for each function.

To bind each function element to a class template, as usual we use the binary scope resolution operation - :: with the name of the class template - Stack . Which is what we did in lines 49, 58, 68, 83, 96.

Note the declaration of the myStack object of the Stack class template in the main function, line 24. The angle brackets must explicitly indicate the data type used; this was not necessary in the function templates. Next, main runs some functions that demonstrate how the Stack class template works. The result of the program is shown below.

We push elements onto the stack: 12 3456 768 5 4564 |4564 | 5 | 768 |3456 | 12 Remove two elements from the stack: | 0 | 0 | 768 |3456 | 12

Function templates, in other words, are instructions according to which local versions of a templated function are created for a specific set of parameters and data types.

In fact, function templates are a powerful tool in C++ that make a programmer's job much easier. For example, we need to program a function that would display the elements of an array. The task is not difficult! But to write such a function, we must know the data type of the array that we will display on the screen. And then they tell us - there is more than one data type, we want the function to output arrays of types int, double, float and char.

As it turned out, the task became more complicated. And now we understand that we need to program as many as 4 functions that perform the same actions, but for different types of data. Since we are not yet familiar with function templates, we will do this: we will use .

// overloading the printArray function to display the array on the screen void printArray(const int * array, int count) ( for (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } void printArray(const double * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const float * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const char * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; }

Thus, we have 4 overloaded functions, for different data types. As you can see, they differ only in the function header; their body is absolutely the same. I wrote the function body once for the int type and copied it three times for other data types.

And, if you run the program with these functions, it will work properly. The compiler itself will determine which function to use when calling.

As you can see, there was quite a lot of code for such a simple operation. What if we need to program it as a function. It turns out that for each data type you will have to create your own function. That is, you yourself understand that the same code will be in several copies, this is of no use to us. That's why C++ came up with such a mechanism - function templates.

We create one template in which we describe all data types. This way the source will not be cluttered with unnecessary lines of code. Below we will look at an example program with a function template. So, let’s remember the condition: “program a function that would display the elements of the array.”

#include < count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray int main() { // размеры массивов const int iSize = 10, dSize = 7, fSize = 10, cSize = 5; // массивы разных типов данных int iArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; double dArray = {1.2345, 2.234, 3.57, 4.67876, 5.346, 6.1545, 7.7682}; float fArray = {1.34, 2.37, 3.23, 4.8, 5.879, 6.345, 73.434, 8.82, 9.33, 10.4}; char cArray = {"MARS"}; cout << "\t\t Шаблон функции вывода массива на экран\n\n"; // вызов локальной версии функции printArray для типа int через шаблон cout << "\nМассив типа int:\n"; printArray(iArray, iSize); // вызов локальной версии функции printArray для типа double через шаблон cout << "\nМассив типа double:\n"; printArray(dArray, dSize); // вызов локальной версии функции printArray для типа float через шаблон cout << "\nМассив типа float:\n"; printArray(fArray, fSize); // вызов локальной версии функции printArray для типа char через шаблон cout << "\nМассив типа char:\n";printArray(cArray, cSize); return 0; }

// code Code::Blocks

// Dev-C++ code

#include #include using namespace std; // function template printArray template void printArray(const T * array, int count) ( for (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray int main() { // размеры массивов const int iSize = 10, dSize = 7, fSize = 10, cSize = 5; // массивы разных типов данных int iArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; double dArray = {1.2345, 2.234, 3.57, 4.67876, 5.346, 6.1545, 7.7682}; float fArray = {1.34, 2.37, 3.23, 4.8, 5.879, 6.345, 73.434, 8.82, 9.33, 10.4}; char cArray = {"MARS"}; cout << "\t\t Шаблон функции вывода массива на экран\n\n"; // вызов локальной версии функции printArray для типа int через шаблон cout << "\nМассив типа int:\n"; printArray(iArray, iSize); // вызов локальной версии функции printArray для типа double через шаблон cout << "\nМассив типа double:\n"; printArray(dArray, dSize); // вызов локальной версии функции printArray для типа float через шаблон cout << "\nМассив типа float:\n"; printArray(fArray, fSize); // вызов локальной версии функции printArray для типа char через шаблон cout << "\nМассив типа char:\n";printArray(cArray, cSize); return 0; }

Please note that the code has been reduced by 4 times, since only one instance of the function is declared in the program - the template. In main I declared several arrays - four, for data types: int, double, float, char. After which, in lines 26, 28, 30, 32, the printArray function is called for different arrays. The result of the program is shown below.

Template for displaying an array on the screen Array of type int: 1 2 3 4 5 6 7 8 9 10 Array of type double: 1.2345 2.234 3.57 4.67876 5.346 6.1545 7.7682 Array of type float: 1.34 2.37 3.23 4.8 5.879 6. 345 73.434 8.82 9.33 10.4 Array of type char: M A R S

As you can see, the program works correctly, and for this we only needed to define the printArray function once in the form that is familiar to us. Please note that before the declaration of the function itself, on line 5, there is the following template entry . This entry suggests that the printArray function is actually a function template, since the first parameter of printArray contains a const T* data type, exactly the same as in line 5.

All function templates begin with the word template followed by angle brackets that list the parameters. Each parameter must be preceded by the reserved word class or typename .

Template

Template

Template

The typename keyword tells the compiler that the template will use a built-in data type such as: int , double , float , char , etc. And the class keyword tells the compiler that the function template will use custom data types as a parameter , that is, classes.

Our function template used built-in data types, so on line 5 we wrote template . Instead of T, you can substitute any other name you can think of. Let's take a closer look at the code fragment from the top program, I'll post it separately.

// function template printArray template void printArray(const T * array, int count) ( for (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray

Line 2 defines a template with one parameter, T, and this parameter will have one of the built-in data types because the typename keyword is specified.

Below, in lines 3 - 8, a function is declared that meets all the criteria for declaring a regular function, there is a header, there is a function body, the header contains the name and parameters of the function, everything is as usual. But what turns this function into a function template is a parameter with data type T , which is the only connection to the template declared earlier. If we wrote

Void printArray(const int * array, int count) ( for (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; }

then it would be a simple function for an array of type int .

So, in fact, T is not even a data type, it is a reserved place for any built-in data type. That is, when this function is called, the compiler parses the templated function's parameter and creates an instance for the appropriate data type: int, char, and so on.

Therefore, you should understand that even if the amount of code is smaller, this does not mean that the program will consume less memory. The compiler itself creates local copies of the template function and, accordingly, as much memory is consumed as if you had written all the function instances yourself, as is the case with overloading.
I hope I have conveyed the main idea about function templates to you. To reinforce the material, let's look at another example program using a function template.

#include "stdafx.h" #include #include < size; ix++) if (max < array) max = array; return max; } int main() { // тестируем шаблон функции searchMax для массива типа char char array = "aodsiafgerkeio"; int len = strlen(array); cout << "Максимальный элемент массива типа char: " << searchMax(array, len) << endl; // тестируем шаблон функции searchMax для массива типа int int iArray = {3,5,7,2,9}; cout << "Максимальный элемент массива типа int: " << searchMax(iArray, 5) << endl; return 0; }

// code Code::Blocks

// Dev-C++ code

#include #include using namespace std; // function template for finding the maximum value in the array template T searchMax(const T* array, int size) ( T max = array; // maximum value in the array for (int ix = 0; ix< size; ix++) if (max < array) max = array; return max; } int main() { // тестируем шаблон функции searchMax для массива типа char char array = "aodsiafgerkeio"; int len = strlen(array); cout << "Максимальный элемент массива типа char: " << searchMax(array, len) << endl; // тестируем шаблон функции searchMax для массива типа int int iArray = {3,5,7,2,9}; cout << "Максимальный элемент массива типа int: " << searchMax(iArray, 5) << endl; return 0; }

Here's another example of using function templates. The function template is declared on lines 5-13. The function must return the maximum value of the array, so the return value is of type T , because the data type of the array is not known in advance. By the way, a variable max of type T is declared inside the function; the maximum value of the array will be stored in it. As you can see, the T data type is used not only to specify function parameters, but also to indicate the return type, and can also be freely used to declare any variables within a function template.

Maximum element of an array of type char: s Maximum element of an array of type int: 9

Function templates can also be overloaded with other function templates by changing the number of parameters passed to the function. Another feature of overloading is that template functions can be overloaded with regular non-template functions. That is, the same function name is specified, with the same parameters, but for a specific data type, and everything will work correctly.

I was about to write a text about all sorts of cool data structures, and then it turned out that we had not yet examined several very important features of C++. Templates are one of them.

Templates are a very powerful tool. Template functions and classes can greatly simplify a programmer’s life and save a huge amount of time, effort and nerves. If you think that templates are not a very significant topic to study, know that you are mistaken.

Template functions

A simple example of a template function:

C++ code Type square (Type a) ( Type b; b = a*a; return b; ) int x = 5; int i; i = square(5); float y = 0.5; float f; f = square(y);

If we created functions the old fashioned way, then we would have to write two different functions: for the int type and for the float type. And if you needed the same function using other types, you would have to write it again. Using templates, you can limit yourself to just one instance of a function, leaving all the dirty work to the compiler.

Instead of using a specific type, the function uses a parametric type (or, in other words, a template argument). Here I called the parametric type the identifier Type. This identifier appears three times in a function: the return value, the function argument, and the definition of the variable s. That is, Type is used like any regular type.

But for the code to work, you need to add the following line before the function (I showed several syntax options, they all work):

C++ code template Type square (Type a) template < class Type >Type square (Type a) template< class Type >Type square (Type a)

So, the function must be preceded by the keyword template, and in angle brackets you must specify the name of the parametric type with the keyword class. Instead of the class keyword, you can use type - in general, there is no difference.

The parametric type identifier can also be anything. We will often use these: TypeA, TypeB, Datatype, T.

Important Note: Template functions must have an argument so that the compiler can determine which type to use.

You can use several parametric types in templates, and of course you can mix parametric types with standard ones (you just need to take care of the correct type casting). I will give an example that uses two parametric types TypeA, TypeB and the base type int:

C++ code template TypeB example_function (TypeA a, TypeB b) ( int x = 5; b = a + x; return b; )

But template functions are not the most interesting thing we'll look at today.

Template classes

In general, template classes are created in much the same way as template functions - the keyword template is written before the class name. Let's look at template classes using a stack as an example:

C++ code template class stack ( private: int top; Type s; public: stack (): top(0) () void push(Type var) ( top++; s = var; ) Type pop(); ); template Type stack::pop() ( Type var = s; top--; return var; ) Here we define

shared a stack of ten elements. These elements can be of any type, more on that below.

The only thing I want to draw your attention to is the definition of the push and pop functions. The push function is defined inside the class, and the pop function is defined outside it. For all functions declared outside the class, the template keyword must be specified. The expression before the function name is the same as the one before the class name.

Now let's see how to work with template classes:

C++ code stack s1; stack s2; s1.push(3); s1.push(2); s1.pop(); s2.push(0.5);

When creating an object, after the class name you need to put angle brackets in which to indicate the desired type. After this, the objects are used in the way we are used to.

Template classes have one amazing feature - in addition to standard types, they can also work with custom ones. Let's look at a small example. To do this, let's define a simple warrior class:

C++ code class warrior ( public: int health; warrior () : health(0) () ); stack s; warrior w1; warrior w2; warrior w3; s.push(w1); s.push(w3); s.pop(); s.push(w2);

Look, now you can put warrior type variables on stacks!!! You may not believe me, but this is very cool! You can see how cool this is when we create graphs and trees based on lists.

That's all according to the templates for now. Later we will look at more complex cases of using template classes.