哪种指针分配更好（C ++）

Question

foo.h中

#include "class1.h"

class foo{

    private:
        class1* class1ObjectPointer;

    public:
        foo();
        virtual ~foo();

        void foomethod();

}

foo.cpp （版本1）

#include "foo.h"

foo::foo()
{
    this->class1ObjectPointer = new class1();
}


foo::~foo()
{
    if( this->class1ObjectPointer != NULL ){

        delete class1ObjectPointer;
        this->class1ObjectPointer = NULL;
    }
}


foo::foomethod(){

    *(this->class1ObjectPointer) = some_method(); 
    //suppose some method returns an object of class1

}

foo.cpp （版本2）

#include "foo.h"

foo::foo()
{
    this->class1ObjectPointer = NULL;
}


foo::~foo()
{
    if( this->class1ObjectPointer != NULL ){

        delete class1ObjectPointer;
        this->class1ObjectPointer = NULL;
    }
}


foo::foomethod(){

    class1 object;
    object = some_method(); 
    //suppose some method returns an object of class1
    this->class1ObjectPointer = new class1(object); // copy constructor
}

在以下情况下哪种指针分配更好：

1. class1的对象始终具有固定的大小（例如，其中具有固定变量的类）
2. class1的对象可能具有可变大小的成员（例如，其中具有矩阵的类可能具有不同的大小）

---

您是否可以提出其他更好的方式来完成我在这些摘要中所做的工作？

Answer 1

该类的实例的大小不变，无论分配如何。 如果将成员变量分配给某个指针，则实例的大小不会改变。 只是内存中的一些垃圾（如果您首先对其进行了初始化，则为NULL值）将被其他分配的对象的地址替换。

Answer 2

按照第一个示例重新分配对象可能比分配一个新对象更好（效率更高，并且更容易避免内存泄漏），正如第二个示例中的内存泄漏所示。

看起来很像根本不需要指针。 只需在您的类中嵌入一个对象：

class foo {
private:
    class1 class1Object;

public:
    // implicit constructors, assignment and destructor are fine
    void foomethod() {class1Object = some_method();}
};

第二种情况没有任何意义-特定类的对象大小都相同。

如果确实需要存储指针（也许是因为您需要多态），那么处理它的最简单方法是使用智能指针：

class foo {
private:
    std::unique_ptr<class1> class1ObjectPointer;

public:
    foo() : class1ObjectPointer(new class1) {}
    // implicit copying and destructor are fine

    foomethod() {*class1ObjectPointer = some_method();}
    // or, if not assignable, class1ObjectPointer.reset(new class1(*some_method()));
};

如果您真的想自己管理它，则需要按照“三规则”重写默认的复制构造函数和复制分配运算符，确保在重新分配指针时删除了旧对象，并注意异常安全性。 而且，无需在删除之前检查NULL或在析构函数中分配NULL 。

Answer 3

1. if ptr != NULL检查在delete是多余的，因为它在内部进行检查。

2. 这些变体中哪个更好取决于情况。 两者都有其用途。

3. 根本不要在这里使用指针。 如果需要，请使用std::unique_ptr （需要C ++ 11）或boost::shared_ptr 。

4. 无论如何，构造函数中的成员应该被初始化 ，而不是被分配。 也就是说，编写如下：

    foo::foo() : class1ObjectPointer(new class1) { } 

   这使用一个初始化列表 。