关于 C++ 模板 class 中重载运算符 T() 的问题

Question

I have this little piece of code:

template<typename T>
class Test
{
public:
    //operator T() const { return toto; }
    T toto{ nullptr };
};

void function(int* a) {}

int main(int argc, char** argv)
{
    Test<int*> a;
    function(a);

    return 0;
}

It doesn't compile unless the line operator T() const { return toto; } operator T() const { return toto; } is un-commented. This magically works, but I am not sure why (if I un-comment the line).

I do understand that if the line is commented, the type of a when passed to function() is incompatible with the expected type int* . So, of course, the compiler complains... no problem.

I also understand that the operator returns the actual type of the object, therefore in this particular case the compiler is happy.

I don't understand why the operator is called in this particular case.

Is doing function(a) the same thing as doing function(a()) , only the () are implicit?

Answer 1

operator T() const { return toto; } operator T() const { return toto; } is a user defined conversion operator , it is not operator() . It's used to define that your class is convertible to a different type.

operator() would look like this instead:

void operator()() const {... }

In your case, you are using int* as T . If you substitute it yourself in the operator, you will see that it becomes operator int*() const { return toto; } operator int*() const { return toto; } which means "my class can be converted to an int* and the result of that conversion is evaluated as return toto; ".

The function function() only accepts an int* as its argument. When you provide a Test instance, the call is only legal if there is a way to convert from Test to int* , which is why the operator T is required for the code to compile.