When Should You Use Explicit Template Instantiation?

Explicit Template Instantiation: Clarifying Its Purpose and Applications

The concept of explicit template instantiation, which involves explicitly defining a template class for specific data types, can be puzzling initially. This article aims to provide clarity on its applications.

When to Utilize Explicit Template Instantiation

Explicit template instantiation becomes relevant when there's a need for a template class to work solely with a predefined set of types. Instead of generating code for every possible type that the template supports, explicit instantiation allows developers to specify the exact types they wish to support.

How Explicit Template Instantiation Works

To utilize explicit template instantiation, follow these steps:

1. Declare the template class in a header file as you would a regular class.
2. Place the template definition in a separate source file similar to a regular class definition.
3. Explicitly instantiate only the desired template versions at the end of the source file.

Example

Consider the following example:

Header File (StringAdapter.h)

template<typename t>
class StringAdapter
{
public:
    StringAdapter(T* data);
    void doAdapterStuff();
private:
    std::basic_string<t> m_data;
};
typedef StringAdapter<char> StrAdapter;
typedef StringAdapter<wchar_t> WStrAdapter;</wchar_t></char></t></typename>

Source File (StringAdapter.cpp)

#include "StringAdapter.h"

template<typename t>
StringAdapter<t>::StringAdapter(T* data)
    :m_data(data)
{}

template<typename t>
void StringAdapter<t>::doAdapterStuff()
{
    /* Manipulate a string */
}

// Explicitly instantiate desired template versions
template class StringAdapter<char>;
template class StringAdapter<wchar_t>;</wchar_t></char></t></typename></t></typename>

Main Function

#include "StringAdapter.h"

int main()
{
  StrAdapter  x("hi There");
  x.doAdapterStuff();
}

In this example, only the character and wchar_t versions of the StringAdapter class are explicitly instantiated. This means that the template code is generated only for those two specific data types.

Understanding explicit template instantiation empowers developers to control the generation of template code, making code more efficient and maintainable. By selectively instantiating templates for specific scenarios, developers can optimize memory usage and reduce compile times, leading to improved application performance.

The above is the detailed content of When Should You Use Explicit Template Instantiation?. For more information, please follow other related articles on the PHP Chinese website!