template class specialization c++

You can specialize a class template for certain template arguments. Similar to the overloading of function templates, specializing class templates allows you to optimize implementations for certain types or to fix a misbehavior of certain types for an instantiation of the class template. However, if you specialize a class template, you must also specialize all member functions. Although it is possible to specialize a single member function, once you have done so, you can no longer specialize the whole class.

To specialize a class template, you have to declare the class with a leading template<> and a specification of the types for which the class template is specialized. The types are used as a template argument and must be specified directly following the name of the class:

template<> class Stack<std::string> { . };

For these specializations, any definition of a member function must be defined as an "ordinary" member function, with each occurrence of T being replaced by the specialized type:

void Stack<std::string>::push (std::string const& elem) { elems.push_back(elem); // append copy of passed elem }

Here is a complete example of a specialization of Stack<> for type std::string:

// basics/stack2.hpp #include <deque> #include <string> #include <stdexcept> #include "stack1.hpp" template<> class Stack<std::string> { private: std::deque<std::string> elems; // elements public: void push(std::string const&); // push element void pop(); // pop element std::string top() const; // return top element bool empty() const { // return whether the stack is empty return elems.empty(); } }; void Stack<std::string>::push (std::string const& elem) { elems.push_back(elem); // append copy of passed elem } void Stack<std::string>::pop () { if (elems.empty()) { throw std::out_of_range ("Stack<std::string>::pop(): empty stack"); } elems.pop_back(); // remove last element } std::string Stack<std::string>::top () const { if (elems.empty()) { throw std::out_of_range ("Stack<std::string>::top(): empty stack"); } return elems.back(); // return copy of last element }

In this example, a deque instead of a vector is used to manage the elements inside the stack. Although this has no particular benefit here, it does demonstrate that the implementation of a specialization might look very different from the implementation of the primary template.

In fact, there is a benefit for using a deque instead of a vector to implement a stack: A deque frees memory when elements are removed, and it can't happen that elements have to be moved as a result of reallocation. However, this is no particular benefit for strings. For this reason it is probably a good idea to use a deque in the primary class template (as is the case in class std::stack<> of the C++ standard library).

-----------------------------------------------------------------
See Also:
-----------------------------------------------------------------

• Complete Tutorial of C++ Template's
• Standard Template Library Tutorial
• Inter Process Communication Tutorial
• Advance Programming in C & C++

-----------------------------------------------------------------

The Art of Learning with Innovation,
eLearning Courses for C and C++ Programming Language - The Most appreciated course !!!

Copyright © ccplusplus.com