Peter Bindels <dascandy <at> gmail.com> writes:
If it's a template class, which I strongly suspect it is (and if it's the class mentioned above, it is) you can add them all as direct forwards which will fail to compile if and only if you try to use them without the base class supporting them. I'm not sure how you'd get this to work with C++0x concepts though.
Until C++0x concepts are added, we can use boost::concept_check to get a better compilation error for this case. As a sidenote: I think it might be possible to not define the operator at all if we have a type which doesn't support += if we want to. It'd look something like this: struct null_base {}; struct operator_plus_equal_base { template<T> operator+=(....) }; template<class T> class observable_value : public some_mpl_expression<T>::type {}; where some_mpl_expression is a boost::mpl expression which results in either null_base or operator_plus_equal_base depending on whether += exists for a given type T or not. I suppose that this solution wouldn't add much value, it's just interesting :) Best Regards, Johan Torp