fork download

copy

#include "stdio.h"
 
namespace A {
    template <typename T>
    struct Key {
      T value;
    };
 
    template <
        typename T,
        template<typename> class KeyType
    >
    bool operator==(const KeyType<T> &a, const KeyType<T> &b) {
      return a.value == b.value;
    }
}
namespace B {
    template <typename KT>
    struct MappedVal {
      KT key;
    };
 
    template <
        typename KT,
        template<typename> class MappedType
    >
    bool operator==(const MappedType<KT> &a, const MappedType<KT> &b) {
      return (a.key == b.key);
    }
}
 
int main() {
  A::Key<short> key1, key2;
  key1.value = 1;
  key2.value = 1;
 
  B::MappedVal<A::Key<short> > val1, val2;
  val1.key = key1;
 
  val2.key = key1;
 
  bool test1 = (key1 == key2);
  bool test2 = (val1 == val2);
 
  printf("key1 == key2: %s\n", (test1 ? "true" : "false"));
  printf("val1 == val2: %s\n", (test2 ? "true" : "false"));
 
  return 0;
}

prog.cpp: In function ‘int main()’:
prog.cpp:43:22: error: ambiguous overload for ‘operator==’ (operand types are ‘B::MappedVal<A::Key<short int> >’ and ‘B::MappedVal<A::Key<short int> >’)
   bool test2 = (val1 == val2);
                      ^
prog.cpp:43:22: note: candidates are:
prog.cpp:27:10: note: bool B::operator==(const MappedType<KT>&, const MappedType<KT>&) [with KT = A::Key<short int>; MappedType = B::MappedVal]
     bool operator==(const MappedType<KT> &a, const MappedType<KT> &b) {
          ^
prog.cpp:13:10: note: bool A::operator==(const KeyType<T>&, const KeyType<T>&) [with T = A::Key<short int>; KeyType = B::MappedVal]
     bool operator==(const KeyType<T> &a, const KeyType<T> &b) {
          ^

Standard output is empty