Question

The following doesn’t compile, how can I do this? I think the example shows my intent, but I’ll try to add a blurb if people are confused.

template<typename T>
class A
{
private:
    struct B
    {
        template<typename T2> 
        B& operator=( const A<T2>::B& right ){} //  how can I make this work?
    };

    template<typename T2> friend class A;
    template<typename T2> friend class A<T2>::B;
};

Answer 1

The fundamental idea of your assignment operator is flawed, as even with the addition of a typename, it’s a non-deducible context. As such, the template parameter will never be deduced and the assignment operator will never work unless you explicitly specify a type like B.operator=<some_type>(other_B).

An easier version would be to just make it a normal function template, and SFINAE your way out.

#include <type_traits>

template<class> struct is_a_B;

template<class B2>
typename std::enable_if<
  is_a_B<B2>::value,
  B&
>::type operator=(B2 const& other){
  // ...
}

Now all that’s left is the is_a_B type trait. You can make this easy on yourself with possible false positives:

template<class B>
struct is_a_B{
  typedef char yes;
  typedef yes (&no)[2];

  template<class T>
  static yes test(typename T::I_am_a_B_type*);
  template<class T>
  static no  test(...);

  static bool const value = sizeof(test<B>(0)) == sizeof(yes);
};

Just provide the I_am_a_B_type typedef in your B class.

Live example on Ideone. Comment out the b1 = 5; line and it compiles as seen here.

---

And now for the slightly more perverted complicated way with no false-positives. 🙂

template<bool Cond, class OnTrue>
struct and_v{
  static bool const value = OnTrue::value;
};

template<class OnTrue>
struct and_v<false, OnTrue>{
  static bool const value = false;
};

template<class B>
struct is_a_B{
  typedef char yes;
  typedef yes (&no)[2];

  template<class T>
  static yes has_parent(typename T::parent*);
  template<class T>
  static no  has_parent(...);

  template<class T>
  static yes is_A(A<T>*);
  static no  is_A(...);

  template<class T>
  struct lazy_test{
    typedef typename std::add_pointer<typename T::parent>::type p_type;
    static bool const value = sizeof(is_A(p_type(0))) == sizeof(yes);
  };

  static bool const value = and_v<sizeof(has_parent<B>(0)) == sizeof(yes),
                                  lazy_test<B>>::value;
};

For this one you need a typedef A<T> parent; inside B. It’s staged in two parts:

• First I test if a parent typedef exists, and if it does
• If it’s actually a typedef of the A class template.

Sadly, the logical operators (&&, ||, ?:) don’t short-circuit in template code like I hoped, so I had to write those and_v templates + a lazy tester that only gets evaluated if a parent typedef exists.

Live example on Ideone. Again, comment out the b1 = 5; line to make it compile as seen here.