Any way to define a "doubling" operator? - c++

Question

I have a class that represents a quantity that can only take on integer or half-integer values, and so stores its value internally as an integer that is twice the value. That is: a value of 0.5 is stored as 1, 1 as 2, 1.5 as 3, etc. Let's call it class A with a stored value int TwoA_.
This forces the A values to be properly integer or half-integer. Since I often need to use them as their true values, I have naturally made a cast to double operator that simply returns 0.5 * TwoA_.
However, very frequently I need to use twice the value. I thought it would be neat to code 2 * a (a being an object of type A) to directly return the value TwoA_ stored inside a.
Ideally, I'd like to make an operator that only does this when multiplied by 2 from the left. All other situations would be covered by the implicit cast.
Is there any way to do this in c++? I though of some sort of templated multiplication operator.
The simple solution of just defining
friend double operator*(int lhs, const A& rhs)
{ return (lhs == 2) ? rhs.TwoA_ : lhs * static_cast<double>(rhs); }
is not what I'm looking for. 2 * a is guaranteed to be an int (but generically an_int * a is not), and I would like to return an int.
This is a question of curiosity; if you only want to comment "why would you want to do that?" (or some variation thereof), please hold your tongue.
An edit: I meant multiplication on the left by the integer literal 2 (not an integer variable which is tested to see if it has the value 2)

Answer 1

Understanding your question to be if you can overload the * operator such that it returns a different data type based on the value of one of the parameters, the short answer is: No.
The long answer: No, but maybe yes.
double operator*(const int lhs, const A& rhs);
That operator would have to know AT COMPILE TIME if lhs is 2 or not, and that cannot be guaranteed. Which means a decision as to how to handle the case of lhs being 2 or not must be done at runtime. But the data type that an operator returns must be known at compile time...
double operator*(const some_type_1& lhs, const A& rhs);
int operator*(const some_type_2& lhs, const A& rhs);
This would get you two different return types, but only with compile-time knowledge of what those argument types are.
template<int T>
struct special_number{};
//...
template<>
int operator*(const special_number<2>&, const A& rhs){
return rhs.TwoA_;
}
template<int T>
double operator*(const special_number<T>&, const A& rhs){
return (static_cast<double>(rhs) / 2.0) * T;
}
//usage
int answer1 = special_number<2> * my_a_object;
double answer2 = special_number<3> * my_a_object;
This would do just that.

Answer 2

struct two_t {
constexpr two_t() {};
template<class T>
constexpr operator T()const{return 2;}
};
constexpr two_t two;
Now:
friend double operator*(two_t lhs, const A& rhs)
{ return rhs.TwoA_; }
friend double operator*(const A& lhs, two_t lhs)
{ return lhs.TwoA_; }
is about the best you can do.
The type of an expression is not dependent on the values, except in the special case where the constant 0 can be converted to a pointer and can cause different overload resolutions.
That special case cannot be leveraged to make 2 special when passed as an argment to *.
Now
constexpr std::ptrdiff_t from_digits(std::integer_sequence<char>) {
return 0;
}
constexpr std::ptrdiff_t compile_time_pow( std::ptrdiff_t base, std::size_t exp ) {
return exp ? base * compile_time_pow( base, exp-1 ) : std::ptrdiff_t(1);
}
template<char c0, char...cs>
constexpr std::ptrdiff_t from_digits(std::integer_sequence<char, c0, cs...>) {
return
compile_time_pow(10, sizeof...(cs))*(c0-'0')
+ from_digits( std::integer_sequence<char, cs...>{} );
}
template<char...cs>
constexpr auto operator"" _integer() {
return std::integral_constant<std::ptrdiff_t, from_digits( std::integer_sequence<char, cs...>{} )>{};
}
Now 2_integer is a compile_time std::ptrdiff_t of value 2, with the value encoded in its type.
Thus 2_integer * a could be overridden to return a differnet type than 3_integer * a, or 2 * a.