C++: force the compiler to use one of two competing operators

Question

I've been playing with C++ recently, and I just stumbled upon an interesting precedence issue. I have one class with two operators: "cast to double" and "+". Like so:

class Weight {
  double value_;
 public:
  explicit Weight(double value) : value_(value) {}
  operator double() const { return value_; }
  Weight operator+(const Weight& other) { return Weight(value_ + other.value_); }
};

When I try to add two instances of this class...

class Weighted {
  Weight weight_;
 public:
  Weighted(const Weight& weight) : weight_(weight) {}
  virtual Weighted twice() const {
    Weight w = weight_ + weight_;
    return Weighted(w);
  }
};

...something unexpected happens: the compiler sees the "+" sign and casts the two weight_s to double. It then spits out a compilation error, because it can't implicitly cast the resulting double back to a Weight object, due to my explicit one-argument constructor.

The question: how can I tell the compiler to use my own Weight::operator+ to add the two objects, and to ignore the cast operator for this expression? Preferably without calling weight_.operator+(weight_), which defeats the purpose.

---

Update: Many thanks to chris for pointing out that the compiler is right not to use my class's operator+ because that operator is not const and the objects that are being +ed are const.

I now know of three ways to fix the above in VS2012. Do see the accepted answer from chris for additional information.

1. Add the explicit qualifier to Weight::operator double(). This doesn't work in VS 2012 (no support), but it stands to reason that it's a good solution for compilers that do accept this approach (from the accepted answer).
2. Remove the virtual qualifier from method Weighted::twice, but don't ask me why this works in VS.
3. Add the const qualifier to method Weight::operator+ (from the accepted answer).

Answer 1

Current version:

First of all, the virtual should have nothing to do with it. I'll bet that's a problem with MSVC, especially considering there's no difference on Clang. Anyway, your twice function is marked const. This means that members will be const Weight instead of Weight. This is a problem for operator+ because it only accepts a non-const this. Therefore, the only way the compiler can go is to convert them to double and add those.

Another problem is that adding explicit causes it to compile. In fact, this should remove the compiler's last resort of converting to double. This is indeed what happens on Clang:

error: invalid operands to binary expression ('const Weight' and 'const Weight')
Weight w = weight_ + weight_;
note: candidate function not viable: 'this' argument has type 'const Weight', but method is not marked const

Finally, making operator+ const (or a free function) is the correct solution. When you do this, you might think you'll add back this route and thus have another error from ambiguity between this and the double route, but Weight to const Weight & is a standard conversion, whereas Weight to double is a user-defined conversion, so the standard one is used and everything works.

---

As of the updated code in the question, this is fine. The reason it won't compile is the fault of MSVC. For reference, it does compile on Clang. It also compiles on MSVC12 and the 2013 CTP.

---

You may be storing the result in a Foo, but there is still an implicit conversion from double to Foo needed. You should return Foo(value_ + other.value_) in your addition operator so that the conversion is explicit. I recommend making the operator a free function as well because free operators are (almost) always at least as good as members. While I'm at it, a constructor initializer list would be a welcome change, too.

In addition, from C++11 onward, a generally preferred choice is to make your conversion operator explicit:

explicit operator double() const {return value_;}

Also note the const added in because no state is being changed.