Question

关于以下代码的两个问题：

template <class T> class A {
protected:
    T j;
public:
    A(T k) :j(k) {cout << *this;}
    ~A() { cout << *this; }
    A(const A<T> &a) {
        j = a.j;
        cout << *this;
    }
    virtual void print() const {cout << j << ' ';}

    friend ostream &operator << (ostream &os, const A<T> &a) {
        a.print();
        return os;
    }
    operator T() {  return j;}
};

template <class T> class inherit:public A<T> {
    T field;
public:
    inherit(const T&t) :A<T>(t), field(1+t) {
        cout << *this;
    }
    void print() const {
        A<T>::print();
        cout << field << ' ';
    }
};
int main(){
    inherit <int> b(3);

    inherit <string> c("asdf");
    string k="str";
    c + k;//error no operator +
    b + 5;//no error
}

为什么inherit <int> b(3);会导致inherit的副本？为什么要复制而不是使用默认的ctor从头开始创建inherit的新实例？
为什么b+5;会导致转化运算符operator T()以及为什么c+k不会发生这种情况？

Answer 1

为什么inherit <int> b(3);会导致继承的副本？为什么要使用默认的ctor复制而不是从头创建一个新的继承实例？

首先，它不会导致复制构造函数，实际上实例从头开始。

未使用默认构造函数，因为您没有调用默认构造函数。默认构造函数将使用空参数列表调用（在这种情况下，您还必须省略括号以避免烦恼的解析）：

inherit <int> b; // this would call the default constructor

如果将参数传递给构造函数，则将调用非默认构造函数。 inherit <int> b(3);会调用inherit(const T&)，在此模板实例中inherit(const int&)。它不是inherit的复制构造函数。

为什么b + 5;通向铸造操作员操作员T（）

因为没有operator+(const inherit<int>&, int)也没有定义类似的成员函数。因此，重载决策寻找可以隐式转换操作数的替代方案。恰好相反，内置的operator+(int, int)存在，inherit<int>可以隐式转换为A<int>（因为它是基础），A<int>可以转换为int（因为投射算子）。因此，该操作员最终被调用。

为什么c + k不会发生？

首先，你甚至无法实例化inherit <string>，因为构造函数试图在参数字符串中添加一个int，它没有有效的重载。

现在，假设构造函数已修复以便inherit<string>可以存在，c + k似乎仍然不起作用。我怀疑这是因为字符串需要比int更多的转换，因为它不是原语，并且您已达到用户定义的转换序列可以具有的最大深度。您可以明确地将inherit<string>转换为string以缩短转化顺序：

static_cast<std::string>(c) + k; // this works

Answer 2

为什么b + 5;导致转换运算符运算符T（）以及为什么c + k不会发生？

编译器抱怨完全不同的代码。如果您移除main()内的+，则可以看到它仍然抱怨operator+：

http://melpon.org/wandbox/permlink/H3cUUaf8fSnbYDwA

原因在于这一行：

inherit(const T&t) :A<T>(t), field(1+t) {

您有1 + t，其中t是std::string。 <{1}}对std::string没有运算符+，因此无法编译。

关于一段代码与模板，转换运算符和复制ctor的问题

2 个答案: