Question

#include "stdafx.h"
#include <memory>

using namespace std;

class MyClass1
{
public:
    MyClass1(int a, int b, int c, int d) :data1(a), data2(b), data3(c), data4(d) {}
    ~MyClass1() = default;
private:
    int data1;
    int data2;
    int data3;
    int data4;
};

class MyClass2
{
public:
    MyClass2(int a, int b, int c, int d) :data1(a), data2(new int(b)), data3(make_shared<int>(c)), data4(make_unique<int>(d)) {}
    ~MyClass2() { delete data2; }
private:
    int data1;
    int* data2;
    shared_ptr<int> data3;
    unique_ptr<int> data4;
};

int main()
{
    MyClass1 mc1automatic(1, 2, 3, 4); // Case 1 : Every integer allocated on stack
    MyClass2 mc2automatic(1, 2, 3, 4); // Case 2 : Every integer except data1 allocated on heap
    unique_ptr<MyClass1> mc1dynamic = make_unique<MyClass1>(1, 2, 3, 4); // Case 3 : Every integer allocated on heap
    unique_ptr<MyClass2> mc2dynamic = make_unique<MyClass2>(1, 2, 3, 4); // Case 4 : Every integer allocated on heap
    return 0;
}

在此示例中，mc1dynamic和mc2dynamic都指向的对象尽管蓝图将它们声明为自动变量，但仍动态分配其类成员（MyClass1中的每个数据，MyClass2中的data1）。

如果我确定可以动态分配对象（在本例中为MyClass1，MyClass2），为什么我会选择像在MyClass2中一样动态地声明类成员？

Answer 1

我应该何时动态声明类成员？

不能动态地“声明”成员。我想你的意思是问什么时候动态分配。

在某些情况下，您需要动态分配：

子对象的生存期并不直接与所有者相关联-例如，当您想要共享所有权时：在这种情况下，您将希望使用共享指针。
您需要一个编译防火墙来隐藏实现细节。使用动态分配可以更简单地实现PIMPL模式。唯一指针在这里很有用。
sizeof非常大，您想在自动存储中分配所有者对象。这里需要动态分配，因为通常自动存储对象中可用的内存有限。唯一指针在这里也很有用-除非big成员是数组，否则矢量容器可能会更简单。
您正在实现一个数据结构，其大小在运行时确定。请注意，标准库为您提供了常用的数据结构，很少需要实现自定义数据结构。但是，如果这样做，唯一指针可能会很有用。

否则，直接成员通常是一个更好的选择。

请注意，像MyClass2::data2这样的裸露指针绝对不是一个好主意。

Answer 2

因为容易弄乱原始指针，并且绝大多数用例已被现有的智能指针类型覆盖（典型模式由std :: shared_ptr或std :: unique_ptr之一覆盖，很少有std :: weak_ptr覆盖）。请注意，将原始指针传递给函数是不同的，因为在整个调用过程中它应保持稳定，如果不正确，则无论如何都需要使用原始指针以外的其他东西。

OOP：我应该何时动态声明类成员？

2 个答案: