• Articles
  • C++11 - New features - Variadic template
Published by
May 3, 2012 (last update: May 31, 2012)

C++11 - New features - Variadic templates

Score: 3.5/5 (143 votes)
*****

Introduction:

Before the possibilities of the new C++ language standard, C++11, the use of templates was quite limited when it came to implementing for instance function objects (functors) & tuple facilities. Implementing these sort of things using earlier C++ standard often require similiar code to be repeated various times without forgetting preprocessor metaprogramming. However, thanks to variadic templates, programming new features using templates has become easier, clearer & more memory-efficient.

Although the D programming language also provides the use of variadic templates, only variadic templates offered by C++11 standard will be covered here, so knowledge of D programming language's variadic templates is not required in order to read & understand this article. There are assumptions, however, that the reader of this article understands what class & function templates are & how to declare, define & use them.

No image found. What is a variadic template?

Variadic template is a template, which can take an arbitrary number of template arguments of any type. Both the classes & functions can be variadic. Here's a variadic class template:

1
2
template<typename... Arguments>
class VariadicTemplate;


Any of the following ways to create an instance of this class template is valid:

1
2
3
VariadicTemplate<double, float> instance;
VariadicTemplate<bool, unsigned short int, long> instance;
VariadicTemplate<char, std::vector<int>, std::string, std::string, std::vector<long long>> instance;


The number of variadic template arguments can also be zero, so the following

VariadicTemplate<> instance;

is also valid C++11.

However, if you create a template like this:

1
2
template<typename T, typename... Arguments>
class VariadicTemplate;


You must set at least one type as a template argument (for typename T), unless default type has been initilialized, like in the following declaration:

1
2
template<typename T = int, typename... Arguments>
class VariadicTemplate;

No image found. Syntax - the ellipsis operator (...):

The ellipsis operator (...) is an operator used in different contexts in C++. It's name comes from an ellipsis mechanism in C. In this mechanism programmer can create a function taking variable number of parameters. Probably the most famous function in both C & C++ to take advantage of this mechanism is printf-function in C standard library:

int printf (const char* format, ... );

Ellipsis mechanism can also be used with preprocessor in a form of a macro. A macro taking a variable number of parameters is called a variadic macro.

#define VARIADIC_MACRO(...)

In C++, this ellipsis operator got a new meaning in different context called exception handling. The operator is used in catch blocks after try blocks:

1
2
3
4
5
6
try{
    // Try block.
}
catch(...){
    // Catch block.
}


Here, the ellipsis operator indicates that the catch block takes in any exception thrown from the try block as it's parameter, no matter the type.

In C++11, variadic templates brought yet another meaning for this operator. The operator works somewhat like in ellipsis mechanism as already stated, but it's bit more complex:

1
2
template<typename... Arguments>
void SampleFunction(Arguments... parameters);


Here's a function template. The contents of the variadic template arguments are called parameter packs. These packs will then be unpacked inside the function parameters. For example, if you create a function call to the previous variadic function template...

SampleFunction<int, int>(16, 24);

...an equivalent function template would be like this:

1
2
template<typename T, typename U>
void SampleFunction(T param1, U param2);

No image found. Syntax - the sizeof... operator (sizeof...):

Another operator used with variadic templates is the sizeof...-operator. Unlike the sizeof operator, which can be used to determine the size of a type (for example sizeof(int) or sizeof(double)), sizeof... operator can be used to determine the amount of types given into a variadic template. This can be achieved like this:

1
2
3
4
5
template<typename... Arguments>
class VariadicTemplate{
private:
    static const unsigned short int size = sizeof...(Arguments);
};

No image found. Syntax - two ellipsis operators together (......):

In some circumstances, there can be two ellipsis operators put together (......). These two operators can also be separated (written as ... ...).

Probably the most clear way, however, is to separate these two operators with a comma (..., ...). Both ways with a comma or without a comma are acceptable.

This kind of syntax can appear with variadic function templates using ellipsis mechanism:

1
2
3
4
template<typename... Arguments>
void SampleFunction(Arguments......){

}

As already stated, these two ellipsis operator put together can be written differently, so the following examples

1
2
3
4
template<typename... Arguments>
void SampleFunction(Arguments... ...){

}

1
2
3
4
template<typename... Arguments>
void SampleFunction(Arguments..., ...){

}

work as well.

No image found. Author's opinions & thoughts: For the sake of readability, use the last method to mark the two following ellipsis operators. The previous alternatives may be found confusing and/or cumbersome. Some may find it a matter of taste, though.

No image found. Uses of variadic templates - inheritance & initialization lists:

When it comes to classes, variadic templates can be used with inheritance & initialization lists. Inheritance taking advantage of variadic templates can be accomplished like this:

1
2
template<typename... BaseClasses>
class VariadicTemplate : public BaseClasses...


And, if we want to create a constructor inside this class using initialization list to call the constructors of all the given base classes as template arguments, we'd have to do it this way:

1
2
3
4
5
6
7
template<typename... BaseClasses>
class VariadicTemplate : public BaseClasses...{
public:
    VariadicTemplate(BaseClasses&&... base_classes) : BaseClasses(base_classes)...{

    }
};


As you can see there's a new operator introduced in C++11 in the constructor's parameter list - an rvalue operator (&&), which allows rvalue references. This article is not intended to cover the use of this operator, but for information how to use this operator (& rvalue references in general), please follow this link:
http://thbecker.net/articles/rvalue_references/section_01.html

No image found. Uses of variadic templates - variadic class template specialization:

Like class templates, variadic class templates can also be specialized. With templates, the specialization happens like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename T>
class Template{
public:
    void SampleFunction(T param){

    }
};

template<>
class Template<int>{
public:
    void SampleFunction(int param){

    }
};


But with variadic templates it's like the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
template<typename... Arguments>
class VariadicTemplate{
public:
    void SampleFunction(Arguments... params){

    }
};

template<>
class VariadicTemplate<double, int, long>{
public:
    void SampleFunction(double param1, int param2, long param3){

    }
};


No image found. Caution: Some compilers may not support variadic class template specialization yet, or their implementation may be somewhat incomplete.

No image found. See also:

If you are interested in seeing a C++11 standard class template utilizing variadic templates, please take a look at already mentioned tuple from the link below:
http://www.cplusplus.com/reference/std/tuple/tuple/

Another field where variadic templates may come in handy is delegates. If you are already familiar with managed C++ and/or C#, picking up C++ delegates may not be a problem. You might find good use for them in C++ anyway.

No image found. Conclusion:

Templates have been a powerful feature in C++. Now, after the introduction of variadic templates, templates have proven themselves even more powerful. Variadic templates are a trustworthy solution to implement delegates and tuples. And, instead of C-style ellipsis mechanism, variadic templates can offer a typesafer solution to replace them.

More information - compiler support:

If you are unfamiliar or simply unaware of your compiler's feature support, please visit this link:
http://wiki.apache.org/stdcxx/C++0xCompilerSupport

Special thanks to:

- God
- all the helpful sources (please see below)

Sources:

Text sources:
http://digitalmars.com/d/1.0/variadic-function-templates.html
http://en.wikipedia.org/wiki/Variadic_template
http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html
http://linuxprograms.wordpress.com/2008/03/07/c-ellipsis-operator-printf/
http://stackoverflow.com/questions/5625600/what-is-the-meaning-of-token/5625782#5625782
http://stackoverflow.com/questions/7767202/template-specialization-with-variadic-templates
http://www.cplusplus.com/doc/tutorial/exceptions/
http://www.devx.com/cplus/Article/41533
http://www.fredosaurus.com/notes-cpp/expressions/sizeof.html
http://www.generic-programming.org/~dgregor/cpp/variadic-templates.html