Class Template Argument Deduction for template dependent parameter

Question

Let's start with a simple add method for class number:

class number {
    int num;
public:
    number(int num = 0): num(num) {}
    operator int() const { return num; }
};

number add(number t1, number t2) {
    return t1 + t2;
}

int main() {
    auto result1 = add(1, 2); // auto-casting, works fine
}

Now we want to turn number into a template class:

template<class T>
class number {
    T num;
public:
    number(T num = 0): num(num) {}
    operator T() const { return num; }
};

template<class T>
number<T> add(number<T> t1, number<T> t2) {
    return t1 + t2;
}

Trying to call add the same as we called the simple non-templated one, based (theoretically!) on CTAD:

int main() {
    number a = 3; // works, using CTAD
    // auto result1 = add(1, 2); // <== what we wish for, but can't find method
    // auto result2 = add(a, 2); // this also doesn't work, no ADL here :(
    auto result3 = add<int>(1, 2); // this works, but is not what we wish
}

Note that if add was a friend function, calling it with one of the parameters being a number would work, based on ADL:

template<class T>
class number {
    T num;
public:
    number(T num = 0): num(num) {}
    operator T() const { return num; }
    friend number add(number t1, number t2) {
        return t1 + t2;
    }
};

int main() {
    number a = 3; // works, using CTAD
    auto result1 = add(a, 2); // works, based on ADL
    // auto result2 = add(1, 2); // still doesn't work, no ADL here :(
}

Any suggestion how to allow the template class to behave similarly to the non-template, having auto casting when calling add?

EDIT: This question was edited based on posted comments. It should be emphasized that for a generic function like add having such an auto casting might be a wrong idea, but suppose that the method is very specific, something like doSomethingWithNumbers.

It's not clear what the problem here is. Why should `add(1.0, 2.0)` call a function that has absolutely no type relation to the types of `1.0` and `2.0`? Why would the compiler even think to look at `number`'s `add` function as a possibility, especially if it's in some other namespace? — Nicol Bolas, Jul 07 '20 at 16:40
Also, it's not clear what this has to do with CTAD, since nothing in this code uses CTAD. And no, the definition of `add` doesn't count. Within the definition of a template, the template's name without template arguments doubles as the name of the current instantiation of the template. — Nicol Bolas, Jul 07 '20 at 16:43
@bolov yes it does, but the question is how to avoid the need to explicitly create the required type, i.e. to achieve the same behavior as with the non-template `number` class. — Amir Kirsh, Jul 07 '20 at 17:54
Amir, i'd personally advise _against_ implicitness, but since you seem to desire it, i would suggest something along the lines of https://godbolt.org/z/RBXyzE — Taekahn, Jul 07 '20 at 17:55
@Taekahn this option appeared in the previous version of the question and was left out after editing. It indeed does the job. One can also add `requires` on the template parameter type to narrow it to the proper one only. Seems like this is the only way to achieve that. — Amir Kirsh, Jul 07 '20 at 18:00

score 3 · Answer 1 · answered Jul 07 '20 at 19:56

In the line of a comment by @Taekahn, we can achieve the desired behavior, though it is not an automatic casting:

// the additional `requires` on number is not mandatory for the example
// but it is reasonable that number would be restricted
template<class T> requires std::integral<T> || std::floating_point<T>
class number {
    T num;
public:
    number(T num = 0): num(num) {}
    operator T() const { return num; }
};

template<typename T>
concept Number = requires(T t) {
    number(std::move(t)); // anything that a number can be created from
                          // that includes number itself
};

auto add(Number auto t1, Number auto t2) {
    return number{std::move(t1)} + number{std::move(t2)};
}

int main() {
    number a = 3;
    auto result1 = add(1, 2);
    auto result2 = add(a, 2);
    auto result3 = add<double>(1, 2);
}

Code: https://godbolt.org/z/_nxmeR

Yehezkel B. · Accepted Answer · 2020-07-07T20:01:32.060

I think the answer is simple. In the first case, with the free function template, what kicks in first is overloading resolution and function template argument deduction. As the compiler has no way to detect T from the int passed as argument (clang says: candidate template ignored: could not match 'number<type-parameter-0-0>' against 'int'), the overloading resolution fails and the program is ill formed.

When the function is defined as friend, it's a non-template function. The compiler created it when instantiating the class (for number<int>; first line in main). Now, when it finds it (using ADL), the parameter types are already set (both are number<int> because it comes from number<int> instantiation), and what's left is to decide on how to convert the passed argument from int to number<int>, where the implicit conversion (by the matching c-tor) is used. No CTAD here either.

A similar (but not exactly the same) case is discussed by Scott Meyers in Effective C++ (3rd edition), Item 46: Define non-member functions inside templates when type conversions are desired.

Edit: So to answer the question, function template argument deduction and implicit type conversion for the arguments can't be mixed. Choose one. (Which is what Meyers explains in the mentioned item.)

Great reference to Meyers. Old but still relevant. As I understand there is no way, as of C++20, to achieve auto casting for a parameter of a template dependent type, as requested in the question. A workaround appears [in my own answer](https://stackoverflow.com/questions/62779901/class-template-argument-deduction-for-template-dependent-parameter/62782962#62782962), but it is just a workaround. — Amir Kirsh, Jul 07 '20 at 20:18
"Old but still relevant" should be the motto for all of the old books by Scott Meyers :) Almost nothing changed wrt the topics discussed there — Yehezkel B., Jul 08 '20 at 21:08

Class Template Argument Deduction for template dependent parameter

2 Answers2