C++ 哪种指针赋值更好（C+；+；）

foo.h

foo.cpp（第1版）

foo.cpp（第2版）

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

class1的对象始终具有固定大小（例如，其中包含固定变量的类）

class1的对象可能具有大小可变的成员（例如，其中包含可能具有不同大小的矩阵的类）

---

---

您能推荐其他更好的方法来完成我在这些代码段中所做的工作吗？

不管任何赋值，类的实例都具有恒定的大小。

---

如果将成员变量指定给某个指针，则实例的大小不会更改。内存中的一些垃圾（如果您先初始化它，则为空值）将被其他分配对象的地址替换。

类的实例大小不变，而不考虑任何赋值。 如果将成员变量指定给某个指针，则实例的大小不会更改。内存中的一些垃圾（如果您首先初始化了它，则为空值）将被其他分配对象的地址替换

如果ptr！=NULL检查在

删除之前是多余的，因为它在内部进行检查

这些变体中哪一种更好取决于具体情况。两者都有各自的用途

不要在这里使用指针。如果必须，请使用

std:：unique_ptr

（需要C++11）或

boost:：shared_ptr

在任何情况下，构造函数中的成员都应该进行初始化，而不是分配。也就是说，写如下：

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

这使用了一个

如果ptr！=NULL检查在

删除之前是多余的，因为它在内部进行检查

这些变体中哪一种更好取决于具体情况。两者都有各自的用途

不要在这里使用指针。如果必须，请使用

std:：unique_ptr

（需要C++11）或

boost:：shared_ptr

在任何情况下，构造函数中的成员都应该进行初始化，而不是分配。也就是说，写如下：

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

这使用了一个

根据第一个示例重新分配对象可能比分配新对象更好（效率更高，也更容易避免内存泄漏），如第二个示例中的内存泄漏所示

看起来你根本不需要指针；只需在类中嵌入一个对象：

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()));
};

class-foo{
私人：
std:：unique_ptr classobjectpointer；
公众：
foo（）：ClassObjectPointer（新的class1）{}
//隐式复制和析构函数都可以
foomethod（）{*ClassObjectPointer=some_method（）；}
//或者，如果不可赋值，则为ClassObjectPointer.reset（新的class1（*some_method（））；
};

如果确实希望自己管理它，则需要根据重写默认的复制构造函数和复制赋值运算符，确保在重新分配指针时删除旧对象，并注意异常安全。并且在删除之前不需要检查

NULL

，也不需要在析构函数中分配

NULL

。

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

看起来你根本不需要指针；只需在类中嵌入一个对象：

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()));
};

class-foo{
私人：
std:：unique_ptr classobjectpointer；
公众：
foo（）：ClassObjectPointer（新的class1）{}
//隐式复制和析构函数都可以
foomethod（）{*ClassObjectPointer=some_method（）；}
//或者，如果不可赋值，则为ClassObjectPointer.reset（新的class1（*some_method（））；
};

---

如果确实希望自己管理它，则需要根据重写默认的复制构造函数和复制赋值运算符，确保在重新分配指针时删除旧对象，并注意异常安全。而且在删除之前不需要检查

NULL

，也不需要在析构函数中指定

NULL

。

您有什么问题？你在挣扎什么，你在问什么，这还不清楚。@DavidHeffernan我需要创建一个

class1

的对象，它可以有可变的大小，但不知道哪种分配空间的方式更好。你在代码中标识为复制构造函数的东西，不是复制构造函数。复制构造函数不接受指针。@BenjaminLindley复制构造函数不接受对要复制的对象的引用作为输入吗？@Matteo:是的，但通过在对象前面加上

&

，您提供的是指针，而不是引用。从调用方的角度来看，通过引用获取参数的函数与通过值获取参数的函数是无法区分的。您的问题是什么？你在挣扎什么，你在问什么，这还不清楚。@DavidHeffernan我需要创建一个

class1

的对象，它可以有可变的大小，但不知道哪种分配空间的方式更好。你在代码中标识为复制构造函数的东西，不是复制构造函数。复制构造函数不接受指针。@BenjaminLindley复制构造函数不接受对要复制的对象的引用作为输入吗？@Matteo:是的，但要在