Class Template Argument Deduction in C++17

In this article, we will learn about Class Template Argument Deduction(CTAD) in C++17 and with examples. CTAD is a feature in C++17 that allows the template arguments to be deduced from constructor arguments. In simple words, we can say that instead of explicitly specifying the template arguments the compiler can automatically deduce them based on the constructor arguments.

Implicitly-Generated Deduction Guides

When a class template has a constructor that uses each template parameter in its parameter list, the compiler can generate an implicit deduction guide for that class template. This deduction guide allows the class template to be instantiated without explicitly providing template arguments.

Example

C++

// C++ Program to illustrate the implicitly-generated
// deduction guides in C++17
#include <iostream>

// class template
template <typename T> class MyContainer {
public:
    MyContainer(T value)
    {
        std::cout << "Created MyContainer<"
                  << typeid(T).name()
                  << "> with value: " << value << std::endl;
    }
};

// driver code
int main()
{
    // not specifying the type of the template
    auto container1 = MyContainer(42);
    auto container2 = MyContainer("Hello");

    return 0;
}

Output

Created MyContainer<i> with value: 42
Created MyContainer<PKc> with value: Hello

User-Defined Deduction Guides

User-defined deduction guides allow you to provide custom rules for class template argument deduction. These guides help the compiler deduce the template arguments based on the constructor arguments.

Example

C++

// C++ program to demonstrates the usage of user-defined
// deduction guides in C++17
#include <iostream>

// class template
template <typename T> class MyContainer {
public:
    MyContainer(T value)
    {
        std::cout << "Created MyContainer<"
                  << typeid(T).name()
                  << "> with value: " << value << std::endl;
    }
};

// User-defined deduction guide
template <typename T> MyContainer(T) -> MyContainer<T>;

int main()
{
    // creating class template instance
    auto container1 = MyContainer(42);
    auto container2 = MyContainer("Hello");

    return 0;
}

Output

Created MyContainer<i> with value: 42
Created MyContainer<PKc> with value: Hello

Deduction for Alias Templates

The deduction for alias templates allows you to deduce the template arguments for an alias template based on its underlying type or value.

Example 1

C++

// C++ program to demonstrate the usage of the deduction for
// alias templates:
#include <iostream>

template <typename T> using MyAlias = T;

int main()
{
    MyAlias<int> alias1 = 42;
    MyAlias<char> alias2 = 'A';

    std::cout << "alias1: " << alias1 << std::endl;
    std::cout << "alias2: " << alias2 << std::endl;

    return 0;
}

Output

alias1: 42
alias2: A

Example 2

In the below code, we will make use of the above syntax to demonstrate the use of the Class Template Argument Deduction in C++17.

C++

// C++ program to illustrate the class template argument deduction
#include <iostream>
#include <vector>

using namespace std;

// Define a class template called MyContainer
template <typename T> class MyContainer {
private:
    vector<T> vec; // Private member variable of type vector

public:
    // Constructor of MyContainer class that takes an
    // initializer list
    MyContainer(const initializer_list<T>& list)
        : vec(list)
    {
    }

    // Print function to display the elements of the vector
    void print() const
    {
        for (const auto& val : vec) {
            cout << val << " ";
        }
        cout << endl;
    }
};

int main()
{
    // Create an instance of MyContainer using class
    // template argument deduction
    // introduced in C++17
    auto myContainer = MyContainer({ 1, 2, 3, 4, 5 });

    // Print the elements of the container using the print()
    // function
    myContainer.print();

    return 0;
}

Output

1 2 3 4 5

Note: Just like class templates, the arguments of function templates can also be automatically deduced and this feature has been the part of standard C++ since much earlier that Class Template Argument Deduction.

Advantages of Class Template Argument Deduction

The advantages of using the Class Template Argument Deduction are:

• It improves the complexity of the code
• It reduces human error from the code
• It increases the flexibility of the code when you use the template in multiple different types of code
• It increases the performance as it has generosity and fewer lines of code.