Question

I’m taking boost::operators (clang 2.1, boost 1.48.0) for a spin, and ran into the following behavior I can’t explain. It seems that when I add my own operator double() const method to my class Ex (as I’d like to allow my users to idiomatically use static_cast<double>() on instances of my class), I no longer get a compiler error when trying to use operator== between dissimilar classes. In fact, it seems that operator== is not called at all.

Without operator double() const, the class works completely as expected (save for that it now lacks a conversion operator), and I receive the correct complier error when trying f == h.

So what is the right way to add this conversion operator? Code below.

// clang++ -std=c++0x boost-operators-example.cpp -Wall -o ex  
#include <boost/operators.hpp>
#include <iostream>


template <typename T, int N>
class Ex : boost::operators<Ex<T,N>> {
 public:
  Ex(T data) : data_(data) {};
  Ex& operator=(const Ex& rhs) {
    data_ = rhs.data_;
    return *this;
  };
  T get() {
    return data_ * N;
  };
  // the troubling operator double()
  operator double() const {
    return double(data_) / N;
  };
  bool operator<(const Ex& rhs) const {
    return data_ < rhs.data_;
  };
  bool operator==(const Ex& rhs) const {
    return data_ == rhs.data_;
  };
 private:
  T data_;
};

int main(int argc, char **argv) {
  Ex<int,4> f(1);
  Ex<int,4> g(2);
  Ex<int,2> h(1);

  // this will fail for obvious reasons when operator double() is not defined
  //
  // error: cannot convert 'Ex<int, 4>' to 'double' without a conversion operator

  std::cout << static_cast<double>(f) << '\n';


  std::cout 
    // ok
    << (f == g) 

    // this is the error I'm supposed to get, but does not occur when I have
    // operator double() defined 
    //
    // error: invalid operands to binary expression 
    //  ('Ex<int, 4>' and 'Ex<int, 2>')
    // note: candidate function not viable: no known conversion from 
    //  'Ex<int, 2>' to 'const Ex<int, 4>' for 1st argument
    //   bool operator==(const Ex& rhs) const 
    << (f == h)  
    << '\n';
}

Answer 1

You should mark your operator double() as explicit. That allows the static cast, but prevents it being used as an implicit conversion when you test for equality (and in other cases).