在类中存储指针或对象

Store pointers or objects in classes?

本文关键字：对象 指针 存储      更新时间：2023-10-16

只是一个设计/优化问题。什么时候存储指针或对象，为什么?例如，我相信这两种方法都有效(除非编译错误):

class A{
  std::unique_ptr<Object> object_ptr;
};
A::A():object_ptr(new Object()){}
class B{
  Object object;
};
B::B():object(Object()){}

我相信一个区别是在堆栈或堆上实例化?

例如:

   int main(){
      std::unique_ptr<A> a_ptr;
      std::unique_ptr<B> b_ptr;
      a_ptr = new A(); //(*object_ptr) on heap, (*a_ptr) on heap?
      b_ptr = new B(); //(*object_ptr) on heap, object on heap?
      A a;   //a on stack, (*object_ptr) on heap?
      B b;   //b on stack, object on stack?
}

且sizeof(A)应为<sizeof(B)吗?我还遗漏了什么问题吗?(Daniel在评论里的相关文章中提醒了我关于继承的问题)>

因此，由于堆栈分配通常比堆分配快，但A的大小比B小，这些权衡是否不能在没有测试性能的情况下得到回答，即使使用移动语义?或者一些经验法则，当使用一个比另一个更有利时?(圣哈辛托纠正我关于堆栈/堆分配更快，而不是堆栈/堆)

我猜更多的副本构造会导致相同的性能问题，(3个副本的性能影响是初始化第一个实例的3倍)。但移动构造可能更有利使用堆栈尽可能多??

这是一个相关的问题，但不完全相同。c++ STL:我应该存储整个对象，还是对象指针?

谢谢!

如果您的A class中有一个大对象，那么我会存储指向它的指针，但是对于小对象或基本类型，在大多数情况下，您不应该真的需要存储指针。

同样，当某些东西存储在堆栈或堆(freestore)上时，实际上依赖于实现，并且A a并不总是保证在堆栈上。

最好将其称为自动对象，因为它的存储持续时间由声明它的函数的作用域决定。当函数返回时，a将被销毁。

指针需要使用new，它确实会带来一些开销，但在今天的机器上，我想说它在大多数情况下是微不足道的，除非你启动new来处理数百万个对象，否则你会开始看到性能问题。

每一种情况都是不同的，什么时候应该和不应该使用指针，而不是使用自动对象，很大程度上取决于你的情况。

这取决于许多特定的因素，每种方法都有其优点。我想说的是，如果要通过动态分配专门使用外部对象，那么不妨让所有成员都成为直接成员，避免额外的成员分配。另一方面，如果外部对象是自动分配的，则大成员可能应该通过unique_ptr来处理。

仅通过指针处理成员还有一个额外的好处:您可以消除编译时的依赖关系，并且外部类的头文件可以使用内部类的前向声明，而不需要完全包含内部类的头文件("PIMPL")。在大型项目中，这种脱钩可能在经济上是明智的。

堆并不比堆栈"慢"。堆分配可能比堆栈分配慢，如果您以没有大量连续内存访问的方式设计对象和数据结构，则糟糕的缓存局部性可能会导致大量缓存丢失。所以从这个角度来看，这取决于你的设计和代码使用目标是什么。

即使把这个放在一边，你也必须质疑你的复制语义。如果你想要深度复制你的对象(你的对象的对象也被深度复制)，那么为什么还要存储指针呢?如果由于复制语义可以共享内存，那么存储指针，但要确保不要在dr中释放两次内存。

我倾向于在两种情况下使用指针:类成员初始化顺序非常重要，并且我将依赖项注入到对象中。在大多数其他情况下，我使用非指针类型。

编辑:当我使用指针时，还有两种额外的情况:1)避免循环包含依赖(尽管我可能在某些情况下使用引用)，2)使用多态函数调用的意图。

在一些情况下，您几乎别无选择，只能存储指针。一个明显的例子是当您创建二叉树之类的东西时:

template <class T>
struct tree_node { 
    struct tree_node *left, *right;
    T data;
}

在这种情况下，定义基本上是递归的，并且您事先不知道树节点可能有多少后代。您几乎被(至少是某种形式的)存储指针所困，并根据需要分配后代节点。

也有像动态字符串这样的情况，你在父对象中只有一个对象(或对象数组)，但是它的大小可以在足够大的范围内变化，你只需要(至少提供可能性)使用动态分配。对于字符串来说，小尺寸是很常见的，因此有一个相当广泛使用的"短字符串优化"，其中字符串对象直接包含足够的字符串空间，达到一定的限制，以及一个指针，允许在字符串超过该大小时进行动态分配:

template <class T>
class some_string { 
    static const limit = 20;
    size_t allocated;
    size_t in_use;
    union { 
        T short_data[limit];
        T *long_data;
    };
    // ...
};

使用指针而不是直接存储子对象的一个不太明显的原因是为了异常安全。举一个明显的例子，如果您只在父对象中存储指针，那么为那些提供nothrow保证的对象提供swap(通常确实如此)就变得微不足道了:

template <class T>
class parent { 
    T *data;
    void friend swap(parent &a, parent &b) throw() { 
         T *temp = a.data;
         a.data = b.data;
         b.data = temp;
    }
};

只有几个(通常有效的)假设:

  1. 的指针是有效的开始，和
  2. 分配有效指针永远不会抛出异常

…对于这个swap来说，无条件地给予nothrow保证是微不足道的(即，我们可以说:"swap不会抛出")。如果parent直接存储对象而不是指针，则只能有条件地保证(例如，当且仅当T的复制构造函数或赋值操作符抛出时，swap才会抛出)

对于c++ 11，经常(通常?)使用这样的指针可以很容易地提供一个非常有效的move构造函数(这也提供了nothrow保证)。当然，使用指向(大部分)数据的指针并不是唯一的快速移动构造方法——但这是一种简单的方法。

最后，我怀疑您在问这个问题时已经想到了一些情况——其中涉及的逻辑不一定指示您应该使用自动分配还是动态分配。在这种情况下，这(显然)是一种判断。从纯理论的角度来看，你在这些情况下使用什么可能根本没有区别。然而，从实际的角度来看，它可以产生相当大的不同。尽管C和c++标准都不能保证(甚至暗示)这类事情，但现实情况是，在大多数典型的系统中，使用自动分配的对象最终会在堆栈上。在大多数典型的系统(例如，Windows, Linux)上，堆栈被限制在可用内存的相当小的一部分(通常在个位数到低两位数的mb量级)。

这意味着如果在任何给定时间可能存在的所有这些类型的对象可能超过几兆字节(或更多)，则需要确保(至少大部分)数据是动态分配的，而不是自动分配的。有两种方法可以做到这一点:当/如果父对象可能超过可用的堆栈空间时，您可以让用户动态分配父对象，或者您可以让用户使用相对较小的"shell"对象来代表用户动态分配空间。

如果这可能是一个问题，那么类处理动态分配而不是强迫用户这样做几乎总是可取的。这有两个明显的优点:

  1. 用户可以使用基于堆栈的资源管理(SBRM，又名RAII)，
  2. 有限的堆栈空间的影响是有限的，而不是"渗透"通过整个设计。

底线:特别是对于预先不知道存储类型的模板，我倾向于使用指针和动态分配。我会保留子对象的直接存储，主要用于我知道存储类型(几乎?)总是非常小的情况，或者分析表明动态分配会导致真正的速度问题。但是，对于后一种情况，我至少会考虑一些替代方案，例如重载该类的operator new。

相关文章：