fork(1) download

copy

template <typename T>
struct Class {
	Class(T const &t) { }
};
 
template <typename T_Lhs, typename T_Rhs>
struct ClassAnd {
	ClassAnd(T_Lhs const &lhs, T_Rhs const &rhs) { }
};
 
template <typename T, typename T_Rhs>
ClassAnd<Class<T>, T_Rhs> operator&(Class<T> const &lhs, T_Rhs const &rhs) {
	return ClassAnd<Class<T>, T_Rhs>(lhs, rhs);
}
 
template <typename T0, typename T1, typename T_Rhs>
ClassAnd<ClassAnd<T0, T1>, T_Rhs> operator&(ClassAnd<T0, T1> const &lhs, T_Rhs const &rhs) {
	return ClassAnd<ClassAnd<T0, T1>, T_Rhs>(lhs, rhs);
}
 
// Addition of ClassNot and the appropriate operators causes an ambiguity in operator&.
template <typename T>
struct ClassNot {
	ClassNot(T const &t) : value(t) { }
	T value;
};
 
template <typename T_Lhs, typename T_Rhs>
struct ClassAndNot {
	ClassAndNot(T_Lhs const &lhs, T_Rhs const &rhs) { }
};
 
template <typename T_Lhs, typename T_Rhs>
ClassAndNot<T_Lhs, T_Rhs> operator&(T_Lhs const &lhs, ClassNot<T_Rhs> const &rhs) {
	return ClassAndNot<T_Lhs, T_Rhs>(lhs, rhs.value);
}
 
template <typename T_Rhs>
ClassNot<T_Rhs> operator!(T_Rhs const &rhs) {
	return ClassNot<T_Rhs>(rhs);
}
 
// Sample usage.
int main() {
	Class<int> a(42);
	Class<double> b(3.14);
	auto c = a & !b;
}
 

prog.cpp: In function ‘int main()’:
prog.cpp:47:13: error: ambiguous overload for ‘operator&’ (operand types are ‘Class<int>’ and ‘ClassNot<Class<double> >’)
  auto c = a & !b;
             ^
prog.cpp:47:13: note: candidates are:
prog.cpp:12:27: note: ClassAnd<Class<T>, T_Rhs> operator&(const Class<T>&, const T_Rhs&) [with T = int; T_Rhs = ClassNot<Class<double> >]
 ClassAnd<Class<T>, T_Rhs> operator&(Class<T> const &lhs, T_Rhs const &rhs) {
                           ^
prog.cpp:34:27: note: ClassAndNot<T_Lhs, T_Rhs> operator&(const T_Lhs&, const ClassNot<T_Rhs>&) [with T_Lhs = Class<int>; T_Rhs = Class<double>]
 ClassAndNot<T_Lhs, T_Rhs> operator&(T_Lhs const &lhs, ClassNot<T_Rhs> const &rhs) {
                           ^

Standard output is empty