c++ assigment operator with two or more template arguments - c++

Question

Code example :
#include <cstdio>
class Test
{
public:
template<typename T, typename T2>
bool operator =(T& value)
{
return true;
}
};
template bool Test::operator= <int, bool>(int&);
int main()
{
Test t;
int gg = 1234;
t = gg;
}
Checked several compilers. Problem with line t=gg.
If i remove second template argument T2, Everything compiles and works. Is it not allowed to have several template argumens for assigment operator?

Answer 1

You may use as many templates parameters as you need.
The problem is that the compiler does not have a means to deduce other template parameters except the template parameters that are specified in the declaration of the operator parameter or that have a default argument.
So you will have to write something like the following
#include <iostream>
class Test
{
public:
template<typename T, typename T2>
bool operator =( T& )
{
return true;
}
};
template bool Test::operator= <int, bool>(int&);
int main()
{
Test t;
int gg = 1234;
t.operator =<int, bool>( gg );
}

Answer 2

Is it not allowed to have several template argumens for assigment operator? [sic]
It's not that it's not allowed, but rather that the compiler has no way to deduce the second argument.
If your function looked something like this:
template<typename T>
bool operator =(T& value)
Then template parameter T could be deduced: It will be the type of whatever you're trying to set t to. Since this is all the template parameters, you're good.
However, what happens when you have 2?
template<typename T, typename T2>
bool operator =(T& value)
T is easily deducible, but what about T2? How would the compiler know what T2 should be? The answer is it can't.
You do have the option of telling it, by calling the operator function directly:
t.operator=<int, bool>(gg);
But I would imagine that wouldn't be what you want.
Unfortunately for you, the following expression won't work:
t =<bool> gg;
So I think calling operator=() directly is your only option here.
Imagine that in operator i create object of type T2 and put it some list. I did not show full source code, because problem can be seen from this part
It sounds like you're using the operator=() for something it wasn't designed to do. operator=() is really only supposed to be used for copying the other object's state. If everything you need to set your state isn't inherent in the T, then you probably shouldn't be using operator=() for this purpose.
Consider splitting it into two separate functions, or move it into a non-operator function altogether. This way, it will be more clear to other people reading your code in the future what it is you're doing anyway.

Answer 3

Disclaimer, I really don't understand what you want to achieve, and I absolutely agree wit hte others, that you're probably trying doing something with the assignment operator that it's not intender for.
But here's a piece of code that is at least syntactically close to your requirement. Instead of specifying the two parameters in the operator declaration, you could make Test a class template and use plain old function overloading.
template<typename T1, typename T2>
struct Test {
T2 operator=(T1&) { return {}; }
T1 operator=(T2&) { return {}; }
};
struct Foo {};
int main() {
Test<int, Foo> t;
int gg = 1234;
Foo x = t = gg; // <- this really looks weird, but works.
Foo ff;
int i = t = ff;
}
If this is not what you want, then we proably need more information about your comcreate use case.
Live code here.

Answer 4

It sounds like what you actually want to do is derive a second type from your first template argument. This would normally be achieved through some sort of traits type:
#include <cstdio>
template < typename T >
struct TestTraits;
template <>
struct TestTraits< int >
{
typedef bool T2;
};
class Test
{
public:
template<typename T>
bool operator =(T& value)
{
using T2 = typename TestTraits< T >::T2;
return true;
}
};
int main()
{
Test t;
int gg = 1234;
t = gg;
}