Agfdhyk

Considering the following small code snippet:

template <typename T>

class A{

public:

    A() { };

    ~A() { };

    // ...

    template <typename outT = T> operator std::vector<outT>(){ /* implicit/explicit cast to std::vector */ }    

};



template <typename T = float>

void myFunc(const std::vector<T>& _arg){

    printf("myFuncn");

}



int main(int argc, char const *argv) { 

    A<int> foo;

    myFunc(foo);

}

When trying to compile, I get the error

template argument deduction/substitution failed: [...]  ‘A<int>’ is not derived from ‘const std::vector<T>’

While, on the other hand, if myFunc is not a template, it will compile and run just fine. I assume the error is caused by the fact that since myFunc accepts multiple vector types as argument, the compiler does not know to what type it should convert foo to. However, shouldn't the default template values be used as fallback in such case? Is there an alternative way to be able to pass an object of class A to myFunc?

Implicit conversions are not considered when attempting to deduce template parameters. Since A<int> cannot match const std::vector<T>, the myFunc template is not a viable candidate. This remains true even if you explicitly instantiate it beforehand (and even if the conversion operator is not templated).

For overload resolution, implicit conversion are considered, which is why the non-templated version works. The templated version never gets to participate because it is not a viable candidate.

The problem is that template argument deduction does not consider implicit conversions, so when you write myFunc(foo) the compiler is unable to determine a type for T. And that's really the end of the story.

See Template argument deduction on C++ reference.

Walter E. Brown gave a fantastic talk about how function templates work (including why you should call them function templates and not templatized functions) at CppCon2018 which I highly recommend.

See "C++ Function Templates: How Do They Really Work?" on youtube.

As noted in other answers, template resolution cannot consider implicit conversions. A simple way to solve the problem is to overload myFunc and do an explicit cast. Consider the following code:

#include <vector>

#include <iostream>



template <typename T>

class A{

public:

    A() { };

    ~A() { };

    // ...

  template <typename outT = T> operator std::vector<outT>() const { /* implicit/explicit cast to std::vector */

    std::cout << "I am doing a conversion" << std::endl;

    return std::vector<outT>(); }

};



template <typename T = float, typename... Args>

void myFunc(const std::vector<T, Args...>& _arg){

  std::cout << "myFunc" << std::endl;

}



template <typename T>

void myFunc(const A<T>& _arg)

{

  std::cout << "I am the second variant of myFunc" << std::endl;

  myFunc(static_cast<const std::vector<T>>(_arg));

}



int main(int argc, char const *argv) { 

    A<int> foo;

    std::cout << "-- First call of myFunc" << std::endl;

    myFunc(foo);

    std::cout << "-- Second call of myFunc" << std::endl;

    std::vector<double> x = foo;

    myFunc(x);



    return 0;

}

Output of the program is:

-- First call of myFunc

I am the second variant of myFunc

I am doing a conversion

myFunc

-- Second call of myFunc

I am doing a conversion

myFunc

When you pass foo to myFunc the compiler uses the second overload of myFunc which, through an explicit cast, calls the conversion operator. In the second case we directly assign foo to a std::vector, hence doing the conversion before passing the resulting std::vector to the first overload of myFunc. Notice that:

• you need a const conversion operator if you wnat to keep constness in the overloads of myFunc.




• you need an additional template parameter pack typename... Args in the first overload of myFunc to capture every specialization of std::vector (say, with a custom allocator).

Another option could be to declare A as class derived from std::vector. Something like the following code:

#include <vector>

#include <iostream>



template <typename T>

class A : public std::vector<T> {

public:

  A() : std::vector<T>(/* Some parameters to initialize the base class */) { }

};



template <typename T = float, typename... Args>

void myFunc(const std::vector<T, Args...>& _arg){

  std::cout << "myFunc" << std::endl;

}



int main(int argc, char const *argv) { 

    A<int> foo;

    myFunc(foo);



    return 0;

}

In this case you do not need a conversion and you call myFunc by slicing. A drawback to this approach is that you do the conversion to a std::vector in the constructor and, every time you modify A, you must keep the data of the base class std::vector up to date.