Advanced template (runner's notes)

Non type template parameters

There are two types of template parameters

1. Type template parameters : And follow class or typename The following parameter type name

   ​

2. Non type template parameters : Is to use a constant as a class ( function ) A parameter of the template , In the class ( function ) This parameter can be used as a constant in the template

   ​

   

there N Is constant , Is the existence of an initialization length that can be used as an array .

Be careful :

1. Floating point numbers , Class objects and strings are not allowed as non type template parameters .
2. Non type template parameters must be in the compiler to determine the result .

Template specialization

When using templates, we may need to deal with some fixed types, otherwise we will have problems with the code .

For example, we implement a less Function as a comparison of size .

At this point, you need to specialize the template .

And special function implementation operations for special types . Template specialization is divided into Class template specialization Function template specialization

among Function template specialization In fact, most of them can be solved by instantiation .

So we usually use template specialization on classes .

Full specialization

If there is the following code :

template<class T1,class T2>
class test
{
    
public:
	test()
	{
    
		cout << "test()T1 T2" << endl;
	}
};
template<>
class test<char,int>
{
    
public:
	test()
	{
    
		cout << "test()char int" << endl;
	}
};

int main()
{
    
	test<int, int>();
	test<char, int>();
	return 0;
}

The execution result is shown in the figure above :

Here our test The class is realized through specialization when the class needs to be for example char int Type .

This specialization is called full specialization . And all template parameters are specialized .

Partial specialization

If there is the following code :

template<class T1,class T2>
class test
{
    
public:
	test()
	{
    
		cout << "test()T1 T2" << endl;
	}
};

Partial specialization can be divided into two kinds of specialization

• Partial specialization

template<class T1>
class test<T1 ,char>
{
    
public:
	test()
	{
    
		cout << "test()T1 char" << endl;
	}
};

The above code will be when T2 The type is char When I transferred .

• Type restriction specialization

We can also specify a type for specialization, such as The pointer , quote .

The code is as follows :

template<class T1, class T2>
class test<T1*,T2*>// Specialization of pointer 
{
    
public:
	test()
	{
    
		cout << "test()<T1*,T2*>" << endl;
	}
};

template<class T1, class T2>// Specialization of reference types 
class test<T1&, T2&>
{
    
public:
	test()
	{
    
		cout << "test<T1&, T2&>" << endl;
	}
};

template<class T1, class T2>// Reference plus pointer 
class test<T1&, T2*>
{
    
public:
	test()
	{
    
		cout << "test<T1&, T2*>" << endl;
	}
};