Question

I have classes:

class IntegerVector:
{
    IntegerVector operator * (const int scalar) const;
};

class RealVector:
{
    RealVector(const IntegerVector &other);
    RealVector operator * (const double scalar) const;
};

How can I force the expression: integer_vector*1.5 to be equivalent to RealVector(integer_vector)*1.5 rather than integer_vector*int(1.5) as it is now?

EDIT

BTW, there are lots of these operators, so defining RealVector IntegerVector::operator * (const double scalar) const is not very satisfactory.

Answer 1

In C++11, you could leverage the built-in type promotion like this:

#include <type_traits>

class IntegerVector;
class RealVector;

template <class T> struct VectorForType {};
template <> struct VectorForType<int> {typedef IntegerVector type;};
template <> struct VectorForType<double> {typedef RealVector type;};

// This is where we figure out what C++ would do..
template <class X, class Y> struct VectorForTypes
{
  typedef typename VectorForType<decltype(X()*Y())>::type type;
};


class IntegerVector
{
public:
    template <class T> struct ResultVector
    {
      typedef typename VectorForTypes<int, T>::type type;
    };

    template <class T>
    typename ResultVector<T>::type operator*(const T scalar) const;
};

class RealVector
{
public:
    template <class T> struct ResultVector
    {
      typedef typename VectorForTypes<double, T>::type type;
    };

    RealVector();
    RealVector(const IntegerVector &other);

    template <class T>
    typename ResultVector<T>::type operator*(const T scalar) const;
};


int main()
{
  IntegerVector v;
  auto Result=v*1.5;
  static_assert(std::is_same<decltype(Result), RealVector>::value, "Oh no!");
}

If you need this without decltype, you can probably implement the type promotion result as a meta-function too. I suppose an operator implementation would look something like this:

template <class T> inline
typename ResultVector<T>::type IntegerVector::operator*(const T scalar) const
{
  typename ResultVector<T>::type Result(this->GetLength());
  for (std::size_t i=0; i<this->GetLength(); ++i)
    Result[i]=(*this)*scalar;
  return Result;
}