Why Doesn't C Allow Template Parameter Inference for Constructors?

Inference of Template Parameters from Constructors

The C language allows for the inference of template parameters from function parameters, but not from class constructors. This can raise the question: why not allow this inference for constructors?

One reason that template inference is not allowed for constructors is that constructors are not the only point of entry for a class. Copy constructors and assignment operators provide additional ways to create objects of a class. Allowing template inference for constructors would require the compiler to consider all of these entry points when determining the template parameters, which could lead to syntactic ambiguity.

class MyClass {
    int a;
    int b;

public:
    MyClass(int a, int b): a(a), b(b) {}
};

In this example, if template inference were allowed for constructors, it would be unclear which template parameters should be used when creating a MyClass object using the copy constructor or assignment operator.

Another reason that template inference is not allowed for constructors is that it could lead to unexpected behavior. Consider the following code:

class MyContainer {
    std::vector<T> vec;
};

int main() {
    MyContainer<int> container; // explicitly specify template parameter
    MyContainer container2(vec); // infer template parameter from constructor
}

In this example, the MyContainer class can be constructed with either an explicitly specified template parameter or a vector of a specific type. If template inference were allowed for constructors, the second line of code would create a MyContainer of type T. However, this may not be the intended behavior, since the user may have wanted to create a MyContainer of type int.

Due to these concerns, template inference is not allowed for class constructors. However, in C 17, partial template specialization can be used to achieve a similar effect. Partial template specialization allows the user to specify template parameters for a specific type, while leaving other template parameters to be inferred.

template <typename T>
class MyContainer {
    std::vector<T> vec;
};

template <>
class MyContainer<int> {
    std::vector<int> vec;
};

int main() {
    MyContainer container; // infer template parameter to 'int'
    MyContainer<double> container2; // explicitly specify template parameter
}

In this example, the MyContainer class has a partial template specialization for int. This means that when a MyContainer is created with an int type, the template parameter will be automatically inferred to be int. For other types, the template parameter must be explicitly specified.

The above is the detailed content of Why Doesn't C Allow Template Parameter Inference for Constructors?. For more information, please follow other related articles on the PHP Chinese website!