CTAD is a feature introduced in C 17, which is used to automatically deduce template parameter types when creating class template instances, making the code more concise. 1. It deduces template parameters through constructor parameter types; 2. It supports custom classes, and if necessary, the derivation rules can be controlled through the deduction guide; 3. There are restrictions, such as they are not applicable to partial specialization, derivation may not be intuitive, and are affected by implicit conversions, etc.

CTAD (Class Template Argument Deduction) is a feature introduced by C 17. Its main function is to allow the compiler to automatically deduce template parameter types when creating class template instances. This is very similar to the type derivation of function templates, but before C 17, the template parameters of class templates had to be explicitly specified, which in some cases seemed cumbersome.

Why do you need CTAD?

When there is no CTAD, for example, if you use std::pair or std::vector , you need to write this:

 std::pair<int, double> p(1, 2.0);

If you have a temporary variable or the construction is complicated, explicitly writing the type becomes repetitive and prone to errors. With CTAD, you can write it directly:

 std::pair p(1, 2.0); // The compiler will automatically deduce int and double

This makes the code more concise, especially when the template parameters are long or deep nested.

How to use CTAD?

The core of CTAD is that the parameter type of the "constructor" determines the template parameter type of the class template. The compiler will deduce template parameters based on the actual parameters passed to the constructor.

For example:

 template<typename T>
struct MyVector {
    MyVector(T a, T b) {}
};

MyVector v(3, 5.0); // Deduce T = double, because 3 can be converted to double

Here, the compiler sees that two parameters are int and double , but the constructor requires that the two parameters are of the same type, so int is converted into double .

However, it should be noted that not all cases can be derived correctly. For example, the following situation will fail:

 MyVector v(3, "hello"); // Error: Unable to unify types

How to support CTAD in custom classes?

If the class template you wrote yourself also wants to support CTAD, you don't need to do anything extra. As long as the constructor parameters have clear types, the compiler can help you deduce them.

But sometimes you want to control the derivation method, such as enabling a certain derivation rule only under a specific constructor, you need to write a "deduction guide".

For example:

 template<typename T>
struct Wrapper {
    template<typename U>
    Wrapper(U value) : data(static_cast<T>(value)) {}
private:
    T data;
};

// deduction guide
template<typename U>
Wrapper(U) -> Wrapper<typename std::decay<U>::type>;

This way when you write:

 Wrapper w(42.0f);

It will be derived as Wrapper<float></float> instead of the default possible double .

CTAD Limitations and Precautions

• Not available for partial specialization : CTAD is derived based on the constructor of the main template. If the class template has multiple specialized versions, unexpected results may occur.
• Derivation is not always intuitive : for example, if the constructor uses template parameter packages, overload constructors, etc., the derivation result may not meet expectations.
• Note the effect of type conversion : Just like int mentioned above is converted to double , some implicit conversions affect the final derived type.

Examples of FAQs:

• Too many constructor templates lead to ambiguity
• The default parameters were used but no value was passed, resulting in the inability to derivate
• Type alias or typedef confuses the actual type

Let's summarize

CTAD is a convenient gadget that allows you to write less duplicate template parameters. But it is not omnipotent, and sometimes it still has to manually specify the type, especially when the logic is complex or the intention is not clear enough.

Basically that's it.

The above is the detailed content of C template argument deduction for class templates (CTAD) in C 17. For more information, please follow other related articles on the PHP Chinese website!