Template constructor in a class template - how to explicitly specify template argument for the 2nd parameter?

c++, templates

Solution

Fixing your code, the following would work:

template<class T> class TestTemplate {
public:
    //constructor 1
    template<class Y> TestTemplate(Y * p) {
        cout << "c1" << endl;
    }

    //constructor 2
    template<class Y, class D> TestTemplate(Y * p, D d) {
        cout << "c2" << endl;
    }

    template<class A, class B>
    void foo(A a, B b) {
        cout << "foo" << endl;
    }
};

int main() {
    TestTemplate<int> tp(new int());

    tp.foo<int*, string>(new int(), "hello");

    TestTemplate<int> tp2(new int(),2);
}

You cannot use `T` for the class template parameter and the constructor template parameter. But, to answer your question, from [14.5.2p5]:

Because the explicit template argument list follows the function template name, and because conversion member function templates and constructor member function templates are called without using a function name, there is no way to provide an explicit template argument list for these function templates.

Therefore, you cannot explicitly specify template arguments for constructor.

Problem

Template constructor in a class template - how to explicitly specify template argument for the 2nd parameter? compile error when tried to explicit specify template argument for constructor 2. How should I do it if I really want to explicit call constructor 2 ? Please note this is the same situation for boost::shared_ptr when you want to explicitly specify the deleter type. N.B. For non-construction function foo(), explicitly specify works fine. N.B I know it works fine without specify the 2nd one explicitly for the constructor 2 as template argument deduction normally just works fine, I am just curious how to specify it explicitly. ``` template<class T> class TestTemplate { public: //constructor 1 template<class Y> TestTemplate(T * p) { cout << "c1" << endl; } //constructor 2 template<class Y, class D> TestTemplate(Y * p, D d) { cout << "c2" << endl; } template<class T, class B> void foo(T a, B b) { cout << "foo" << endl; } }; int main() { TestTemplate<int> tp(new int());//this one works ok call constructor 1 //explicit template argument works ok tp.foo<int*, string>(new int(), "hello"); TestTemplate<int> tp2(new int(),2);//this one works ok call constructor 2 //compile error when tried to explicit specify template argument for constructor 2 //How should I do it if I really want to explicit call constructor 2? //TestTemplate<int*, int> tp3(new int(), 2); //wrong //TestTemplate<int*> tp3<int*,int>(new int(), 2); //wrong again return 0; } ```

Original source