C++ 高级C++；元编程不编译

我正在读这本书，在第2.2.3节我遇到了一段代码。（第49页）未编译（我当前的编译器是Visual Studio 2013）。错误出现在赋值时，但书中说赋值“ok:它最终调用basic_inner:：operator=”。我错过什么了吗

template <typename X, typename T>
struct basic_inner
{
    template <typename T2>
    basic_inner& operator=(const basic_inner<X, T2>&)
    {
        // do something...
        return *this;
    }
};

template <typename T>
struct outer
{
    template <typename X>
    struct inner : public basic_inner<X, T>
    {
        inner& operator=(const basic_inner<X, T> &that)
        {
            static_cast<basic_inner<X, T>&>(*this) = that;
            return *this;
        }
    };
};

template <>
struct outer<int>
{
    template <typename X>
    struct inner : public basic_inner<X, int>
    {
        inner& operator=(const basic_inner<X, int> &that)
        {
            static_cast<basic_inner<X, int>&>(*this) = that;
            return *this;
        }
    };
};

模板
结构基本单元内部
{
模板
基本内部和运算符=（常量基本内部和）
{
//做点什么。。。
归还*这个；
}
};
模板
结构外部
{
模板
结构内部：公共基本内部
{
内部运算符=（const basic_inner&that）
{
静态_cast（*此）=那个；
归还*这个；
}
};
};
模板
结构外部
{
模板
结构内部：公共基本内部
{
内部运算符=（const basic_inner&that）
{
静态_cast（*此）=那个；
归还*这个；
}
};
};

客户端代码为：

outer<double>::inner<void> x1;
outer<int>::inner<void> x2;

x1 = x2;    // <-- error: no operator found which takes right-hand operand of type 'outer<int>::inner<void>'(or there is no acceptable conversion)

外部：：内部x1；
外部：内部x2；
x1=x2；// 我猜由于名称隐藏，
basic_inner
类的赋值运算符在派生类
inner
中不可见。您可以使用basic_internal:：operator=

到你的

外部

类，并获得如下内容

template <typename T>
struct outer {
  template <typename X>
  struct inner : public basic_inner<X, T> {
    using basic_inner<X, T>::operator=;
    inner& operator=(const basic_inner<X, T>& that) {
      static_cast<basic_inner<X, T>&>(*this) = that;
      return *this;
    }
  };
};

template <>
struct outer<int> {
  template <typename X>
  struct inner : public basic_inner<X, int> {
    using basic_inner<X, int>::operator=;
    inner& operator=(const basic_inner<X, int>& that) {
      static_cast<basic_inner<X, int>&>(*this) = that;
      return *this;
    }
  };
};

模板
结构外部{
模板
结构内部：公共基本内部{
使用基本的内部：：运算符=；
内部运算符=（const basic_inner&that）{
静态_cast（*此）=那个；
归还*这个；
}
};
};
模板
结构外部{
模板
结构内部：公共基本内部{
使用基本的内部：：运算符=；
内部运算符=（const basic_inner&that）{
静态_cast（*此）=那个；
归还*这个；
}
};
};

大多数教科书都有不可靠的代码——查看作者的网站，他们通常会不时不好意思地承认这一点。更妙的是，修复它并发送电子邮件给他们-他们真的不喜欢这样。这本书是否为这种奇怪的代码提供了动机？@jrok抱歉，我无法理解它的演示。我猜不同专业化的内部类具有相同的细节，因此它们可以相互分配。+1，但是。。。我猜这不是代码作者的意图。通过

使用

声明，既不会调用

内部：：运算符=

，也不会调用显式专门化中的运算符。请参阅（注意

cout

语句和输出）。这个密码让我完全困惑，wtf。