C ++ arithmetic operator overloading - automatic extension?

Question

I have a Vector class, which is a 2D vector. For patterns x and y, any numerical type can be used. As an example, one of the overloaded arithmetic operators I * for multiplying a vector with a scalar:

 template <typename T, typename U> inline const Vector<T> operator*(const Vector<T>& vector, U scalar) { return Vector<T>(vector.x * scalar, vector.y * scalar); } 

(I also have a function with parameters in reverse order to enable scalar * Vector in addition to Vector * scalar ).

As you can see, I use <T, U> instead of a simple <T> , so the scalar should not be the same type as Vector. When I did not, unexpectedly Vector<double> * int will not compile (I thought that int would automatically expand).

In any case, I do not just want to return Vector<T> . I want to emulate inline types and return depending on which has higher precision, T or U For example, Vector<int> * double => Vector<double> while Vector<double> * short => Vector<double> .

Is it possible?

Answer 1

There are two solutions. In Pre C ++ 11, you can write a template, for example:

 template <typename T, typename U> struct WhatWillItBe { typedef T result_t; }; template <typename T> struct WhatWillItBe<T, double> { typedef double result_t; }; // ... lots more 

etc .. and write a lot of specializations, then you can use this to search for the return type, for example:

 template <typename T, typename U> inline const Vector<typename WhatWillItBe<T,U>::result_t> operator*(const Vector<T>& vector, U scalar) { return Vector<typename WhatWillItBe<T,U>::result_t>(vector.x * scalar, vector.y * scalar); } 

---

As an alternative, C ++ 11 makes this simple, you can write auto for the return type and use -> to indicate the type of the return value after the rest of the function:

 template <typename T, typename U> inline auto operator*(const Vector<T>& vector, U scalar) -> Vector<decltype(vector.x*scalar)> { return Vector<decltype(vector.x*scalar)>(vector.x * scalar, vector.y * scalar); } 

Which allows you to use decltype for the return type of the function, setting it based on what is natural for promotion using vector.x * scalar .

Answer 2

You can use common_type or decltype to weld something that will give you the result; and then you need to create the actual vector:

 template <typename A, typename B> std::vector<typename std::common_type<A, B>::type> operator*(std::vector<A> const & v, B const & x) { std::vector<typename std::common_type<A, B>::type> res; res.reserve(v.size()); for (A a : v) res.push_back(a * x); return res; } 

Using decltype , you can get the result type with:

 decltype(std::declval<A>() * std::declval<B>()) 

For std::common_type and std::declval you need #include <type_traits> .

With delayed return types ( auto and -> ), you can use decltype directly in function arguments, but using std::declval seems a bit more hygienic, as it does not require you to provide an actual instance of your type (and therefore it even applies in situations where this is not possible).