我的 std::vector 应该包含指针还是结构？

Question

我知道保存指针会产生额外的取消引用操作的开销，但它可以节省我的时间，包括包含结构定义的（可能很大）头文件。

然而，我的偏好是由具有 std::vector的优点来确定。 *ptr2Vect 成员。即，不必对每个元素调用删除。这有多大的性能优势呢？ Vector真的可以在堆栈上分配对象吗？我对模板类相当陌生，想知道动态数组是否可以在堆栈上扩展，价格是多少？

_编辑_

我无法理解默认的复制构造函数和operator=成员，并且试图将事物保留为简单的结构。我没有明确定义实现，因此担心将向量元素设置为对象而不是指针会在赋值时创建临时对象，该对象将被破坏，从而破坏其副本。

_编辑_

很抱歉延迟提供相关信息（我对我的代码感到害羞）。

我想调用push_back(newObj)。现在，如果我不使用指针，我就会遇到一个大问题，因为我不想执行深层复制，但我的 dtor 将释放复制构造函数调用的 LHS 和 RHS 共享的内存。

Answer 1

作为一般经验法则，我会说您可能不想将指针放入容器中，除非有充分的理由。

考虑指针的可能原因：

• 您有虚拟函数
• 您有类层次结构
• 您不知道使用它们的对象的大小。 （在这种情况下你只能使用指针或引用，并且不能有引用向量）
• 你的对象非常大（可能对此进行基准测试）

不将指针放入容器中的最大原因是它使它更容易避免犯错误和意外泄漏内存。当您开始考虑例外情况时尤其如此。

容器中没有指针可以更轻松地使用 STL ，请考虑：

#include <vector>
#include <string>
#include <iostream>
#include <iterator>
#include <algorithm>

int main() {
  std::vector<std::string> test;
  test.push_back("hello world");
  std::copy(test.begin(), test.end(), 
            std::ostream_iterator<std::string>(std::cout, "\n"));
}

对比：（

#include <vector>
#include <string>
#include <iostream>
#include <iterator>
#include <algorithm>

int main() {
  std::vector<std::string*> test;
  // if push_back throws then this will leak:
  test.push_back(new std::string("hello world"));
  // Can't do:
  std::copy(test.begin(), test.end(), 
            std::ostream_iterator<std::string>(std::cout, "\n"));
  // Will now leak too
}

我永远不会这样做）

或者可能：

#include <vector>
#include <string>
#include <iostream>
#include <iterator>
#include <algorithm>

int main() {
  std::vector<std::string*> test;
  std::string str("hello world");
  test.push_back(&str);
  // Can't do:
  std::copy(test.begin(), test.end(), std::ostream_iterator<std::string>(std::cout, "\n"));
}

但是这一点让我感到不舒服——完全不清楚代码中其他地方的删除会是一件非常糟糕的事情，而且即使没有泄漏问题，你仍然不能非常舒服地使用STL算法。

Answer 2

指针取消引用的“开销”基本上为零。也就是说，与在其位置引用对象相比，您将很难测量它。谨防早期优化和过度优化，这是所有编程罪恶的根源。

您应该选择对应用最有意义的方式（指针或对象）。

Answer 3

首先，我同意那些说要以最有意义的方式编写代码的人的观点，并且不要担心这样的微观优化，直到您的分析工具告诉您这样做。

也就是说，您应该更多地担心访问您的数据，而不是分配和释放数据。如果对向量元素的访问模式具有良好的局部性（例如，循环遍历所有元素，或一起访问附近的元素），那么指针向量可能会破坏该局部性并对性能造成重大影响。

当然，对速度的首要关注是使用好的算法。但第二个问题是拥有良好的局部性，因为内存速度很慢……而且相对于 CPU，它每年都会变慢。

因此，对于小型、简单的对象，vector 几乎肯定会比 vector 更快，而且可能快很多 更快。

至于“向量真的可以在堆栈上分配对象吗”，从语义角度来看，答案是肯定的，但从实现角度来看，答案是否定的（最有可能）。典型的向量实现在内部由三个指针组成：Base、Current 和 End。所有三个都指向堆上的连续块，向量的析构函数将释放该块。 （同样，这是一个典型的实现；理论上，您的编译器和/或运行时可能会做其他事情。但我打赌它不会。）

这样的实现通过重新分配该块和复制数据来支持动态扩展。这并不像听起来那么慢，原因有两个：（1）线性内存访问（例如复制）非常快； (2) 每次重新分配都会将块的大小增加一个因子，这意味着 push_back 仍然是 O(1) 摊销。

Answer 4

针对指针与结构体没有提到的一件事是内存的连续性（在嵌入式方面更重要）。基本上，结构体向量将分配在 1 个内存块中，而指向结构体的指针向量（可能）将分配在整个位置。内存和数据缓存的碎片将因此受到严重影响。

Answer 5

你的问题不是很清楚。首先讨论指针向量，然后编写如下内容： std::vector*ptr2Vect。

1. std::vector; *ptr2Vect 是一个myStruct 对象指向向量的指针。该向量不存储指针，因此您无需担心所持有对象的内存管理 - 只需确保 myStruct 是可复制构造的。您确实需要手动管理指向向量的指针的清理（ptr2Vect）
2. 大多数现代系统都可以非常有效地使用指针，如果您问此类问题，那么您正在遵循该路线对于过早的优化，停下来，退一步。
3. vector 依赖于动态分配，但是它如何扩展，它进行管理（你可以在一定程度上控制它，例如，如果你事先知道大小，你可以 reserve ）

从我从问题中收集到的信息来看，您确实还没有到需要担心自动/动态分配和指针取消引用的开销的地步。这些是你最不关心的，只要学会编写好的代码 - 所有其他的东西都会稍后出现（如果有必要的话）

Answer 6

但是，我的偏好是由拥有 std::vector *ptr2Vect 成员的优势来确定。 Namey，不必对每个元素调用删除。这有多大的性能优势？

这取决于元素的数量，但它可以为您节省大量的内存和时间。请参阅：

继承的成本是多少？

向量真的可以在堆栈上分配对象吗？

是的。向量可以为此目的保留内部分配，或者编译器可以在某些情况下对此进行优化。这不是您应该依赖的功能/优化。您可以根据您的需求创建自己的分配器或 pod 数组容器。

我对模板类相当陌生，想知道动态数组是否可以在堆栈上扩展以及以什么价格？

如果大小恒定，那么特定的实现（例如boost::array）可以节省大量的运行时开销。我已经为不同的上下文编写了几种类型。

Answer 7

我给你的第一个建议是，“你不必将指向向量的指针”作为成员。你想要一个简单的
向量 myVector; OR向量<我的向量；

其次，您将根据以下问题做出决定：

1. 向量的大小是多少？ （最多有多少个元素）
   说 n
2. struct 的大小是多少？ (尺寸(T))
   说 s
3. 复制该结构的成本是多少？
   说 c
4. 你的结构持有一些资源吗？ （例如一些文件句柄或信号量等）？
   如果它持有一些资源，那么向量会让你的生活变得更加复杂。

现在 n,s,c 将确定向量的运行时开销
对于向量，n、s、c 造成的成本为零。
对于向量，由于 n,s,c 导致的成本为 n*s sizeUnits + n*cexecutionUnits。

我自己的经验法则：不存在经验法则。首先用向量编码，如果它不够好，然后用向量

如果你的程序是一个小程序，在你使用你的向量后将退出进程，那么我什至不会费心去释放它们。
如果没有，那么只需运行
for(auto it=v.begin();it!=v.end();++it) 删除 *it;