C++ C++；通过“初始化内联变量”；构造函数初始化"；？

我正在做教授上次考试给我的一个练习

全文如下（原文为意大利语）：

编写类型为

T

的智能指针的类模板

SmartP

，用于重新定义智能指针的赋值、复制构造函数和析构函数。模板

SmartP

必须包含允许编译以下代码的最小公共接口（具有较少的菜单数），执行时将引发注释行

我的问题是C++如何通过“构造函数初始化”初始化内联变量？ 为什么如果我正常初始化变量，但不使用“构造函数初始化”？

ptr（newt T（*（p.ptr））仅允许在其主体之外的构造函数（也称为成员初始值设定项列表）中进行此类成员初始化。如果在构造函数体中使用这一行，则它是对名为
ptr
或
ptr.operator（）
的函数的调用。编译器告诉您完全相同，
C*
类型的
ptr
既不是函数也不是函数对象

只有两种方法可以初始化
ptr
，所有这些方法都在第一行和第三行中，您将它们标记为无错误

更多信息：
ptr（新T（*（p.ptr））仅允许在其主体之外的构造函数（也称为成员初始值设定项列表）中进行此类成员初始化。如果在构造函数体中使用这一行，则它是对名为
ptr
或
ptr.operator（）
的函数的调用。编译器告诉您完全相同，
C*
类型的
ptr
既不是函数也不是函数对象

只有两种方法可以初始化
ptr
，所有这些方法都在第一行和第三行中，您将它们标记为无错误

更多信息：
请尝试创建一个演示，重点是最小部分。另外，请将完整的错误输出复制粘贴到问题中。可能会有提供进一步提示的信息注释。这是一个奇怪的智能指针。因为它总是在复制或移动时创建新对象，而不是移动所有权，所以它总是在原始拥有的智能指针被销毁时销毁创建的对象，这意味着它执行的操作与将对象声明为自动变量完全相同。这似乎完全是多余的。而且
C类
也毫无意义。即使这只是一个例子，它也没有很好的理由用
new
分配内存，特别是当它总是泄漏内存时，因为它不会在任何地方调用
delete
。@胡桃木是的，te解决方案操作符=。这完全是错误的，因为我复制了一行用于测试，但我忘了将其更改回原来的一行。@ToldoDM我建议您编辑您的问题，以实际显示您所给出的代码，而不是您所做的一些修改，这样我们就不会对这些无关的问题感到困扰。请尝试创建一个，强调最小部分。另外，请将完整的错误输出复制粘贴到问题中。可能会有提供进一步提示的信息注释。这是一个奇怪的智能指针。因为它总是在复制或移动时创建新对象，而不是移动所有权，所以它总是在原始拥有的智能指针被销毁时销毁创建的对象，这意味着它执行的操作与将对象声明为自动变量完全相同。这似乎完全是多余的。而且
C类
也毫无意义。即使这只是一个例子，它也没有很好的理由用
new
分配内存，特别是当它总是泄漏内存时，因为它不会在任何地方调用
delete
。@胡桃木是的，te解决方案操作符=。这是完全错误的，因为我复制了一行用于测试，但我忘了将其更改回原来的一行。@ToldoDM我建议您编辑您的问题，以实际显示您获得的代码，而不是您所做的一些修改，这样我们就不会对这些无关的问题感到不安。
class C {
public:
    int* p;
    C(): p(new int(5)) {}
};

int main() {
    const int a = 1;
    const int *p = &a;
    SmartP<int> r;
    SmartP<int> s(&a);
    SmartP<int> t(s);
    cout << *s << " " << *t << " " << *p << endl; // 1 1 1
    cout << (s == t) << " " << !(s == p) << endl; // 0 1
    *s = 2;
    *t = 3;
    cout << *s << " " << *t << " " << *p << endl; // 2 3 1
    r = t;
    *r = 4;
    cout << *r << " " << *s << " " << *t << " " << *p << endl; // 4 2 3 1
    C c;
    SmartP<C> x(&c);
    SmartP<C> y(x);
    cout << (x == y) << endl; // 0
    cout << *(c.p) << endl; // 5
    *(c.p) = 6;
    cout << *(c.p) << endl; // 6
    SmartP<C> *q = new SmartP<C>(&c);
    delete q;
}

template<class T>
class SmartP{
private:
    T* ptr;
public:
    SmartP(const SmartP& p) { p.ptr!=0 ? ptr(new T(*(p.ptr))) : ptr(nullptr); };
    SmartP(const T* t = 0) { t!=0 ? ptr(new T(*t)) : ptr(nullptr); };
    ~SmartP() { delete ptr;}
    T& operator*() const { return *ptr;}
    bool operator==(const SmartP& p) const { return ptr == p.ptr;}
    SmartP& operator=(const SmartP& p) {
       delete ptr;
       p.ptr!=0 ? ptr(new T(*(p.ptr))) : ptr(nullptr);
       return *this;
    }
};

    SmartP(const SmartP& p) : ptr(new T(*(p.ptr))) {}; //no error
    SmartP(const SmartP& p) { ptr(new T(*(p.ptr))); }; //error
    SmartP(const SmartP& p) { ptr = new T(*(p.ptr)); }; //no error
    SmartP(const SmartP& p) {
        if(p.ptr!=0){
            ptr(new T(*(p.ptr))); //error
        } else {
            ptr(nullptr);
        }
    };