Variadic Template C++: Implementing Unsophisticated Tuple

From C++11, std::tuple is an incredible expansion to Modern C++ that offers a fixed-size col­lec­tion of het­ero­ge­neous values. Un­for­tu­nately, tu­ples can be somewhat dubious to manage in a conventional fash­ion. But, subsequently released C++ stan­dard in­tro­duced a few fea­tures and helpers that greatly re­duce the nec­es­sary boil­er­plate. 

So, in this article, I will explain the variadic template in C++ with the help of unsophisticated tuple implementation. I'll also walk you through a tricky part of tuple i.e. loop through tuple element. Because I have covered the variadic template in my prior article i.e. C++ Template: A Quick UpToDate Look, my focus here would be a blend of variadic template and tuple implementation with more up to date C++ gauges.

 Motivation

It is often useful to define class/struct/union/function that accepts a variable number and type of arguments.

If you have already used C, you'll know that printf function can accept any number of arguments. Such functions are entirely implemented through macros or ellipses operator. And because of that it has several disadvantages, like type-safety, cannot accept references as arguments, etc.

Variadic Class Template: Implementing Tuple Class

So, let's build our own ADT in the same way as std::tuple with the help of variadic template.

The variadic template in C++ usually starts with the general (empty) definition that also serves as the base-case for template recursion termination in the later specialization:

xxxxxxxxxx

template <typename... T>

struct Tuple { };

This already allows us to define an empty structure i.e. Tuple<> object;, albeit that isn't very useful yet. Next comes the recursive case specialization:

xxxxxxxxxx

template<

            typename T, 

            typename... Rest    // Template parameter pack

        >

struct Tuple<T, Rest...> {      // Class parameter pack

    T first;

    Tuple<Rest...> rest;        // Parameter pack expansion

    Tuple(const T& f, const Rest& ... r)

        : first(f)

        , rest(r...) {

    }

};

Tuple<bool>                 t1(false);           // Case 1

Tuple<int, char, string>    t2(1, 'a', "ABC");   // Case 2

How Does Variadic Class Template Works?

To understand variadic class template, consider the two use case above i.e. Tuple<int, char, string> t2(1, 'a', "ABC");

•  The declaration first matches against the specialization, yielding a structure with int first; and Tuple<char, string> rest; data members.
•  The rest definition again matches with specialization, yielding a structure with char first; and Tuple<string> rest; data members.
•  The rest definition again matches this specialization, creating its own string first; and Tuple<> rest; members.
•  Finally, this last rest matches against the base-case definition, producing an empty structure.

You can visualize this as follows:

xxxxxxxxxx

Tuple<int, char, string>

-> int first

-> Tuple<char, string> rest

    -> char first

    -> Tuple<string> rest

        -> string first

        -> Tuple<> rest

            -> (empty)

Variadic Function Template: Implementing get<>() Function for Tuple Class

So far, we have designed a data structure with a variable number and type of data members. But still, it isn't useful, as there is no mechanism to retrieve data from our Tuple class. So let's design one:

xxxxxxxxxx

template<

            size_t idx, 

            template <typename...> class Tuple, 

            typename... Args

        >

auto get(Tuple<Args...> &t) {

    return GetHelper<idx, Tuple<Args...>>::get(t);

}

As you can see, this get function is templatized on the idx. So, usage can be like get<1>(t), similar to std::tuple. Though, the actual work is done by a static function in a helper class i.e. GetHelper.

Note also the use of a C++14-style auto return type that makes our lives significantly simpler, as otherwise, we would need quite a complicated expression for the return type.

So, on to the helper class. This time, we will need an empty forward declaration and two specializations. First the empty declaration:

xxxxxxxxxx

template<

            size_t idx, 

            typename T

        >

struct GetHelper;

Now, the base-case (when idx==0). In this specialization, we just return the first member:

xxxxxxxxxx

template<

            typename T, 

            typename... Rest

        >

struct GetHelper<0, Tuple<T, Rest...>> {

    static T get(Tuple<T, Rest...> &data) {

        return data.first;

    }

};

In the recursive case, we decrement idx and invoke the GetHelper for the rest member:

xxxxxxxxxx

template<

            size_t idx, 

            typename T, 

            typename... Rest

        >

struct GetHelper<idx, Tuple<T, Rest...>> {

    static auto get(Tuple<T, Rest...> &data) {

        return GetHelper<idx - 1, Tuple<Rest...>>::get(data.rest);

    }

};

To work through an example, suppose we have Tuple data and we need get<1>(data). This invokes GetHelper<1, Tuple<T, Rest...>>>::get(data) (the 2nd specialization).

This in turn invokes GetHelper<0, Tuple<T, Rest...>>>::get(data.rest). Finally, it returns (by the 1st specialization as now idx is 0) data.rest.first.

So that's it! Here is the whole functioning code, with some example use in the main function:

xxxxxxxxxx

// Forward Declaration & Base Case -----------------------------------------

template<

            size_t idx,

            typename T

        >

struct GetHelper { };

template <typename... T>

struct Tuple { };

// -------------------------------------------------------------------------

// GetHelper ---------------------------------------------------------------

template<

            typename T,

            typename... Rest

        >

struct GetHelper<0, Tuple<T, Rest...>> { // Specialization for index 0

    static T get(Tuple<T, Rest...> &data) {

        return data.first;

    }

};

template<

            size_t idx,

            typename T,

            typename... Rest

        >

struct GetHelper<idx, Tuple<T, Rest...>> { // GetHelper Implementation

    static auto get(Tuple<T, Rest...> &data) {

        return GetHelper<idx - 1, Tuple<Rest...>>::get(data.rest);

    }

};

// -------------------------------------------------------------------------

// Tuple Implementation ----------------------------------------------------

template<

            typename T,

            typename... Rest

        >

struct Tuple<T, Rest...> {

    T                   first;

    Tuple<Rest...>      rest;

    Tuple(const T &f, const Rest &... r)

        : first(f)

        , rest(r...) {

    }

};

// -------------------------------------------------------------------------

// get Implementation ------------------------------------------------------

template<

            size_t idx, 

            template <typename...> class Tuple, 

            typename... Args

        >

auto get(Tuple<Args...> &t) {

    return GetHelper<idx, Tuple<Args...>>::get(t);

}

// -------------------------------------------------------------------------

int main() {

    Tuple<int, char, string> t(500, 'a', "ABC");

    cout << get<1>(t) << endl;

    return 0;

}

Variadic Template vs Fold Expression

1.  Recursion
2.  Fold Expression(From C++17)

• Less code to write
• Faster code (without optimizations), as you just have a single expression instead of multiple function calls
• Faster to compile, as you deal with fewer template instantiation

Processing a Parameter Pack With Recursion

As we have seen earlier, the variadic template starts with empty definition i.e. base case for recursion.

xxxxxxxxxx

void  print()  {}

Then the recursive case specialization:

x

template<   

            typename First, 

            typename... Rest                    // Template parameter pack

        >     

void print(First first, Rest... rest) {         // Function parameter pack

    cout << first << endl;

    print(rest...);                             // Parameter pack expansion

} 

This is now sufficient for us to use the print function with variable number and type of arguments. For example:

xxxxxxxxxx

print(500, 'a', "ABC");

Processing a Parameter Pack With Fold Expression

xxxxxxxxxx

template<   

            typename First, 

            typename... Rest                    // Template parameter pack

        >     

void print(First first, Rest... rest) {         // Function parameter pack

    cout << first << endl;

    print(rest...);                             // Parameter pack expansion

} 

See, no cryptic boilerplate required. Isn't this solution looks neater?

There are total 3 types of folding: Unary fold, Binary fold & Fold over a comma. Here we have done left folding over a comma. You can read more about Fold Expression here.

Loop-Through/Iterate Over Tuple Elements in C++

If I give you a task to print the elements of tuple, the first thing that comes to your mind is:

xxxxxxxxxx

template <typename... Args>

void print(const std::tuple<Args...> &t) {

    for (const auto &elem : t) // Error: no begin/end iterator

        cout << elem << endl;

}

But, this just can't work. std::tuple doesn't have begin & end iterator. OK! So, now you might try raw loop right?

xxxxxxxxxx

template <typename... Args>

void print(const std::tuple<Args...>&   t) {

    for (int i = 0; i < sizeof...(Args); ++i)

        cout << std::get<i>(t) << endl;    // Error :( , `i` needs to be compile time constant

}

No! you can't. I know that std::get<> works with a number as non-type template argument.

But, that number has to be compile-time constant to make this working. So there are many solutions & we will go through quite enough ones.

C++11: Loop Through Tuple Elements

xxxxxxxxxx

// Template recursion

template <size_t i, typename... Args>

struct printer  {

    static void print(const tuple<Args...> &t) {

        cout << get<i>(t) << endl;

        printer<i + 1, Args...>::print(t);

    }

};

// Terminating template specialisation

template <typename... Args>

struct printer<sizeof...(Args), Args...> {

    static void print(const tuple<Args...> &) {}

};

template <typename... Args>

void print(const tuple<Args...> &t) {

    printer<0, Args...>::print(t);

}

tuple<int, char, string> t(1, 'A', "ABC");

print(t);

// Note: might not work in GCC, I've used clang

This isn't that complicated as it looks, believe me. If you know recursion & template specialisation, it won't take you more than 30 seconds to figure out what's going on here.

For our example tuple<int, char, string> t(1, 'A', "ABC");, printer::print() calls template recursion i,e, template<size_t i, typename... Args> struct printer{}; each time with incremented non-type template parameter i. And when i == sizeof...(Args), our recusion stops by calling template specialization i.e. template<typename... Args> struct printer<sizeof...(Args), Args...> { };.

 C++17: Loop Through Tuple Elements

With C++ 17, it's slightly better because we have Fold Expressions. So, we don't need recursion any more.

xxxxxxxxxx

template <typename... Args>

void print(const std::tuple<Args...> &t) {

    std::apply([](const auto &... args) {

        ((cout << args << endl), ...);

    }, t);

}

std::apply designed as tuple helper that accepts functor or lambda expression. Though you can do better if wants to dispatch to different implementation according to type, you might use overloaded class as:

xxxxxxxxxx

template <class... Ts>

struct overloaded : Ts... {

    using Ts::operator()...;

};

// Deduction guide, google `CTAD for aggregates` for more info

template <class... Ts>

overloaded(Ts...) -> overloaded<Ts...>;   // not needed from C++20

auto f = overloaded {

    [](const int &a)        { cout << "From int: " << a << endl; },

    [](const char &b)       { cout << "From char: " << b << endl; },

    [](const string &c)     { cout << "From string: " << c << endl; },

};

tuple<int, char, string>    t(1, 'A', "ABC");

std::apply([&](const auto &... e) { (f(e), ...); }, t);

C++23: Loop Through Tuple Elements

xxxxxxxxxx

template <typename... Args>

void print(const std::tuple<Args...> &t) {

    for... (const auto &elem : t)

        cout << elem << endl;

}

So, from C++23 we might have expansion statement i.e. for...(). That looks like a loop, though it isn't. It just stencil out each call with scope as:

xxxxxxxxxx

template <typename... Args>

void print(const tuple<Args...> &t) {

    {

        const auto &elem = get<0>(t);

        cout << elem << endl;

    }

    {

        const auto &elem = get<1>(t);

        cout << elem << endl;

    }

    {

        const auto &elem = get<2>(t);

        cout << elem << endl;

    }

}

And it is obvious that there is no break and continue, as it isn't loop.

It basically works for every standard container which can access by std::get<>(). For example, a plain array, std::tuple, std::pair, std::array, unexpanded argument packs, constexpr ranges, etc.

Closing Words

There are still many things missing in our tuple class like copy constructor, move constructors, some operators and helper classes(like std::tuple_size). But I hope now you get the idea of how it can be implemented using the variadic template. By the way, implementing those missing things will be a good start for learning variadic template on your own.

Have Any Suggestions, Query or Wants to Say Hi? Take the Pressure Off, You Are Just a Click Away.