c++ - 推迟 boost::scoped_ptr 的初始化

Question

我定义了一个成员变量如下。由于变量不会传递，所以我决定在这里使用 scoped_ptr 而不是 shared_ptr。

class ClassName
{
public:
    ClassName() 
    {
        Initialize();
    }

    virtual void Initialize() = 0;

protected:
    boost::scoped_ptr<int> m_scpInt;
}

class ClassNameB : public ClassName
{
public:
    virtual void Initialize()
    {
        m_scpInt.reset(new int(100));
    }
}

由于 scoped_ptr 的限制，如果我决定在以后推迟变量的初始化，我唯一的选择就是调用 reset。

Q1> 这是一个好的做法吗？

Q2>否则，有没有更好的解决方案？

谢谢

///更新-1///

这才是我真正想做的。

我想强制每个派生类定义一个名为 Initialize 的函数，该函数依次调用函数 InitializeVarA 和 InitializeVarB。正如您所指出的，我们不能在构造函数中调用虚函数。

class ClassName
{
public:
    ClassName() 
    {
    }       
    virtual void Initialize()
        {
            InitializeVarA();
            InitializeVarB();
        }           
    protected:
        virtual void InitializeVarA() {}
        virtual void InitializeVarB() {}
}

class ClassNameB : public ClassName
{
public:
    ClassNameB() 
    {
    }       
    virtual void Initialize()
        {
            InitializeVarA();
            InitializeVarB();
        }           
    protected:
        virtual void InitializeVarA() {}
        virtual void InitializeVarB() {}
}

ClassNameB cb;
cb.Initialize();

我有比这更好的解决方案吗？

Answer 1

Is this a good practice?

使用reset 来重置作用域指针是可以的。

尝试通过从基类的构造函数调用虚函数来初始化派生类不仅是不好的做法；这是不对的。此时，对象的动态类型是基类，函数是纯虚拟的，因此调用它会产生未定义的行为。

即使你让它成为非纯的，你仍然不能在那一点调用派生类的重写，所以指针不会被重置。

Otherwise, is there a better solution?

您可以在派生类的构造函数中执行此操作，它会在基类的构造函数之后立即被调用:

class Base {
public:
    Base() { /* don't call any virtual functions here */ }

protected:
    boost::scoped_ptr<int> p;
};

class Derived : public Base {
public:
    Derived() {
        p.reset(new int(100));
    }
};

或者您可以将分配的内存传递给基类构造函数并从中初始化指针。但这有点危险 - 您必须确保在任何可能引发异常或内存泄漏的事情发生之前立即初始化指针。

class Base {
public:
    Base(int * p) : p(p) {}

private: // doesn't need to be protected now
         // (unless something else in the derived class needs access)
    boost::scoped_ptr<int> p;
};

class Derived : public Base {
public:
    Derived() : Base(new int(100)) {}
};

在 C++11 中，您可以使用可移动的 unique_ptr 来避免泄漏的风险:

class Base {
public:
    typedef std::unique_ptr<int> ptr;
    Base(ptr && p) : p(p) {}

private:
    ptr p;
};

class Derived : public Base {
public:
    Derived() : Base(ptr(new int(100))) {}
};