Overview of basic concepts of C ++ class template Specialization

In the previous article, we introduced the specific application methods of C ++ class templates in detail. Compared with friends, we should be able to fully understand class templates. Then how does C ++ class template become special? In fact, the special C ++ class template is described as a concept similar to the heavy load.

In my understanding, special processing allows us to perform special processing on some special parameters. The special processing of C ++ class templates is done after the class name. Features are classified into global features and local features. For global specialization, the example in the book is to use deque as the container for the Stack <T> template if the parameter is of the std: string type, while the rest remains unchanged. Therefore, we need to perform the std: string special processing on the Stack <T> template. The Code is as follows:

 
 

  
  
#include < deque> 
  
  
#include < string> 
  
  
#include < stdexcept> 
  
  
#include "Stack.h"  
  
  
template< > 
  
  
class Stack< std::string>{  
  
  
private:  
  
  
std::deque< std::string> elems;  
  
  
public:  
  
  
void push(std::string const&);  
  
  
void pop();  
  
  
std::string top() const;  
  
  
bool empty() const{  
  
  
return elems.empty();  
  
  
}  
  
  
};  
  
  
void Stack< std::string>::push(std::string const& elem)  
  
  
{  
  
  
elems.push_back(elem);  
  
  
}  
  
  
void Stack< std::string>::pop()  
  
  
{  
  
  
if(elems.empty())  
  
  
{  
  
  
throw std::out_of_range("Stack< std::string>::pop()==> empty stack.");  
  
  
}  
  
  
elems.pop_back();  
  
  
}  
  
  
std::string Stack< std::string>::top() const  
  
  
{  
  
  
if(elems.empty())  
  
  
{  
  
  
throw std::out_of_range("Stack< std::string>::pop()==> empty stack.");  
  
  
}  
  
  
return elems.back();  
  
  
} 
 
 

Note that the special definition of C ++ class templates is completely different from that of common class templates. The main differences are:

Template <> is added before the special class template, and no parameter is specified. The type parameter is specified after the class name.

In the function definition, all the original type T is changed to the special type std: string. In fact, you can rewrite member functions based on special requirements. You can even define other functions.

Add the source code to the project and compile and run it. You will find that when you use std: string to instantiate the stack, the "overload" version in the StringStack file is actually called. The call of each method is the same. That is to say, special processing is actually required for specific parameters. In this respect, it is indeed similar to the heavy load.

However, I think there is a difference between feature-based and overload-based. Suppose there is a function Func (int, int), and another function loads it as Func (string, string ). In fact, we can also say that the int Func reloads the string Func, Which is mutual. However, this cannot be said by TDE. Because special processing is specific to a certain type of processing, we can say that the special template reloads a template, but it cannot be said that a template reloads the special template. This is a single direction. In addition, if we do not need the Func (int, int) function, we can delete it completely. However, C ++ class templates cannot be exclusive from the dependent class templates. In the preceding example, if you delete the Stack. h file, the definition of the StringStack. h file will fail.

StringStack is a special Stack template. However, the relationship between them is not that close, except for the name. For example, the member functions in the Stack template do not have to appear in StringStack. Similarly, the functions in StringStack do not have to be functions in Stack. That is to say, the special template class can completely rewrite the specified template function as needed, or discard the members in the original template function, and define the member function. There are no restrictions in this regard.

After understanding the global features, it is easy to understand the local features. Local features require that the specified version of the specified class template be used under the specified conditions.