Can I prevent implicit conversion in parameter to assignment operator - c++

Question

I am implementing a type (TParameter) which shall be both a boolean (to indicate if the value is valid) and a data value of arbitrary type.
The idea is that if a method takes a parameter of some type, then I can set it to false, to indicate that the value is invalid.
Like this:
someVariable = 123; // use the value 123
someVariable = false; // mark variable as invalid/to-be-ignored
A simplified version of my code:
template <class T>
class TParameter
{
public:
TParameter()
: m_value(),
m_valid(false)
{}
// assignment operators
TParameter& operator= (const T& value)
{
m_value = value;
m_valid = true;
return *this;
}
TParameter& operator= (bool valid)
{
m_valid = valid;
return *this;
}
private:
T m_value;
bool m_valid;
};
void test()
{
TParameter<int16_t> param;
param = false;
param = int16_t(123);
param = 123;
}
When compiling the code I get the error:
ambiguous overload for ‘operator=’ (operand types are ‘TParameter<short int>’ and ‘int’)
The problem is that integer values can be implicitly cast to a bool, and therefore the last line in test() does not compile.
Is it possible to tell the compiler that TParameter& operator= (bool valid) shall only be used if the parameter is a bool (i.e. disable implicit cast to bool)?

Answer 1

You can make the 1st overload template, then the 2nd overload will be preferred only when being passed a bool (because non-template function is preferred over template under same situation). Otherwise, the template version will be selected because it's an exact match.
template <typename X>
TParameter& operator= (const X& value)
{
m_value = value;
m_valid = true;
return *this;
}
TParameter& operator= (bool valid)
{
m_valid = valid;
return *this;
}
LIVE
BTW: In your code, implicit conversion happens when the operator= being called; int is converted to int16_t and then passed to operator=. In the code above, the implicit conversion happens inside the operator=, i.e. m_value = value;.