malloc 和新与新的展示位置

Question

过去几天我一直在研究这个问题，到目前为止，除了教条论点或诉诸传统（即“这是 C++ 方式！”）之外，我还没有真正找到任何令人信服的东西。

如果我正在创建一个对象数组，那么使用以下命令的令人信服的原因（除了易用性之外）是什么：

#define MY_ARRAY_SIZE 10

//  ...

my_object * my_array=new my_object [MY_ARRAY_SIZE];

for (int i=0;i<MY_ARRAY_SIZE;++i) my_array[i]=my_object(i);

over

#define MEMORY_ERROR -1
#define MY_ARRAY_SIZE 10

//  ...

my_object * my_array=(my_object *)malloc(sizeof(my_object)*MY_ARRAY_SIZE);
if (my_object==NULL) throw MEMORY_ERROR;

for (int i=0;i<MY_ARRAY_SIZE;++i) new (my_array+i) my_object (i);

据我所知，后者比前者更有效（因为您没有将内存初始化为某些非-随机值/不必要地调用默认构造函数），唯一的区别实际上是你清理的一个：

delete [] my_array;

和另一个你清理的：

for (int i=0;i<MY_ARRAY_SIZE;++i) my_array[i].~T();

free(my_array);

我出于一个令人信服的原因而退出。据我所知，它是 C++（而不是 C），因此不应该使用 malloc 和 free 的事实并非如此 - 令人信服的和它教条一样多。我是否遗漏了一些使 new [] 优于 malloc 的东西？

我的意思是，据我所知，您甚至根本不能使用 new [] 来创建一个没有默认、无参数构造函数的数组，而因此可以使用malloc方法。

Answer 1

我出于令人信服的原因而退出。

这取决于你如何定义“引人注目”。迄今为止您所拒绝的许多论点对于大多数 C++ 程序员来说肯定是有吸引力的，因为您的建议不是在 C++ 中分配裸数组的标准方法。

简单的事实是：是的，您绝对可以按照您描述的方式做事。您所描述的内容没有理由不起作用。

但话又说回来，你可以在 C 中使用虚函数。如果你投入时间和精力，你可以用纯 C 实现类和继承。这些也都是完全实用的。

因此，重要的不是某件事能否发挥作用。但更多的是关于成本是什么。在 C 中实现继承和虚函数比在 C++ 中更容易出错。在 C 中实现它的方法有多种，这会导致实现不兼容。然而，因为它们是 C++ 的一流语言功能，所以有人不太可能手动实现该语言提供的功能。这样，大家的继承和虚函数就可以配合C++的规则了。

这也是同样的道理。那么手动 malloc/free 数组管理的收益和损失是什么？

我不能说我接下来要说的任何内容对你来说都是“令人信服的理由”。我相当怀疑它会，因为你似乎已经下定决心了。但郑重声明：

性能

您声明如下：

据我所知，后者比前者更有效（因为您不会将内存初始化为某些非随机值/不必要地调用默认构造函数），唯一的区别实际上是您清理：

这种说法表明效率增益主要在于所讨论对象的构造中。即调用了哪些构造函数。该语句假定您不想想要调用默认构造函数；您仅使用默认构造函数来创建数组，然后使用真正的初始化函数将实际数据放入对象中。

好吧...如果这不是您想要做的怎么办？如果您想要创建一个默认构造的空数组怎么办？在这种情况下，这种优势就完全消失了。

脆弱性

让我们假设数组中的每个对象都需要有一个专门的构造函数或对其进行调用的东西，这样初始化数组就需要这种东西。但请考虑您的销毁代码：

for (int i=0;i<MY_ARRAY_SIZE;++i) my_array[i].~T();

对于简单的情况，这很好。您有一个宏或 const 变量来表示您有多少个对象。然后循环遍历每个元素以销毁数据。这对于一个简单的例子来说非常好。

现在考虑一个真实的应用程序，而不是一个示例。您将在多少个不同的地方创建数组？几十个？数百个？每一个都需要有自己的 for 循环来初始化数组。每一个都需要有自己的 for 循环来销毁数组。

即使输入错误一次，您也可能会损坏内存。或者不删除某些东西。或者任何其他可怕的事情。

这里有一个重要的问题：对于给定的数组，你在哪里保存大小？您知道为创建的每个数组分配了多少项吗？每个数组可能都有自己的方式来知道它存储了多少项。因此每个析构函数循环都需要正确获取这些数据。如果弄错了……繁荣。

然后我们有异常安全，这是一个全新的蠕虫罐头。如果其中一个构造函数抛出异常，则需要销毁先前构造的对象。你的代码没有这样做；它不是异常安全的。

现在，考虑替代方案：

delete[] my_array;

这不会失败。它总是会破坏每一个元素。它跟踪数组的大小，并且是异常安全的。所以它保证能够工作。它不可能不工作（只要你用new[]分配它）。

当然，你可以说你可以将数组包装在一个对象中。这是有道理的。您甚至可以在数组的类型元素上模板化对象。这样，所有析构器代码都是相同的。大小包含在对象中。也许，只是也许，您意识到用户应该对内存分配的特定方式有一定的控制，这样它就不仅仅是malloc/free。

恭喜：您刚刚重新发明了 std::vector。

这就是为什么许多 C++ 程序员甚至不再输入 new[] 的原因。

灵活性

您的代码使用malloc/free。但假设我正在做一些分析。我意识到对于某些频繁创建的类型来说，malloc/free 的成本太高了。我为他们创建了一个特殊的内存管理器。但是如何将所有数组分配挂钩到它们呢？

好吧，我必须在代码库中搜索创建/销毁这些类型的数组的任何位置。然后我必须相应地改变他们的内存分配器。然后我必须不断监视代码库，以便其他人不会更改这些分配器或引入使用不同分配器的新数组代码。

如果我使用 new[]/delete[]，我可以使用运算符重载。我只是为这些类型的运算符 new[] 和 delete[] 提供重载。无需更改任何代码。对于某人来说，规避这些超载要困难得多；他们必须积极尝试。等等。

因此，我获得了更大的灵活性和合理的保证，我的分配器将在应该使用的地方使用。

可读性

考虑一下：

my_object *my_array = new my_object[10];
for (int i=0; i<MY_ARRAY_SIZE; ++i)
  my_array[i]=my_object(i);

//... Do stuff with the array

delete [] my_array;

与此比较：

my_object *my_array = (my_object *)malloc(sizeof(my_object) * MY_ARRAY_SIZE);
if(my_object==NULL)
  throw MEMORY_ERROR;

int i;
try
{
    for(i=0; i<MY_ARRAY_SIZE; ++i)
      new(my_array+i) my_object(i);
}
catch(...)  //Exception safety.
{
    for(i; i>0; --i)  //The i-th object was not successfully constructed
        my_array[i-1].~T();
    throw;
}

//... Do stuff with the array

for(int i=MY_ARRAY_SIZE; i>=0; --i)
  my_array[i].~T();
free(my_array);

客观地说，哪一个更容易阅读和理解正在发生的事情？

只需查看以下语句：(my_object *)malloc(sizeof(my_object) * MY_ARRAY_SIZE)。这是一个非常低级的事情。你没有分配任何东西的数组；你正在分配一大块内存。您必须手动计算内存块的大小，以匹配对象的大小*您想要的对象的数量。它甚至还有演员阵容。

相比之下，new my_object[10] 讲述了这个故事。 new 是“创建类型实例”的 C++ 关键字。 my_object[10] 是 my_object 类型的 10 个元素数组。它简单、明显且直观。没有转换，没有字节大小的计算，什么都没有。

malloc 方法需要学习如何惯用地使用malloc。 new 方法只需要了解 new 的工作原理即可。发生的事情变得不那么冗长并且更加明显。

此外，在 malloc 语句之后，您实际上并没有对象数组。 malloc 只是返回一个内存块，您已告诉 C++ 编译器假装该内存块是指向对象的指针（带有强制转换）。它不是一个对象数组，因为C++中的对象有生命周期。对象的生命周期直到其被构造之后才开始。该内存中还没有调用过构造函数，因此其中没有活动对象。

此时的 my_array 不是一个数组；它只是一个内存块。在您在下一步中构造它们之前，它不会成为 my_object 的数组。对于新程序员来说，这非常不直观；需要经验丰富的 C++ 技术人员（可能是从 C 语言学习的人）才能知道这些不是活动对象，应该小心对待。该指针的行为尚未像正确的 my_object* 那样，因为它尚未指向任何 my_object。

相比之下，在 new[] 情况下确实有活动对象。对象已构建；它们是活的并且完全成形。您可以像使用任何其他 my_object* 一样使用此指针。

Fin

以上均未表明此机制在适当的情况下没有潜在用处。但承认某物在某些情况下的效用是一回事。说它应该是默认的做事方式是另一回事。

Answer 2

如果您不想通过隐式构造函数调用来初始化内存，而只需要为 placement new 提供有保证的内存分配，那么使用 malloc 和 就完全没问题了。 >free 而不是 new[] 和 delete[]。

使用 new 而不是 malloc 的令人信服原因是 new 通过构造函数调用提供隐式初始化，从而节省额外的< code>memset 或相关函数调用会发布 malloc 并且对于 new 您不需要在每次分配后检查 NULL ，只需包含异常处理程序即可完成工作，从而节省您多余的错误检查，这与malloc。
这两个令人信服的理由不适用于您的使用。

哪一种性能高效只能通过分析来确定，您现在的方法没有任何问题。顺便说一句，我也没有看到为什么使用 malloc 而不是 new[] 的令人信服的理由。

Answer 3

我不会说。

最好的方法是：

std::vector<my_object>   my_array;
my_array.reserve(MY_ARRAY_SIZE);

for (int i=0;i<MY_ARRAY_SIZE;++i)
{    my_array.push_back(my_object(i));
}

这是因为内部向量可能正在为您进行新的放置。它还管理您没有考虑到的与内存管理相关的所有其他问题。

Answer 4

您在这里重新实现了 new[]/delete[]，并且您所编写的内容在开发专用分配器中非常常见。

与分配相比，调用简单构造函数的开销将花费很少的时间。它不一定“更高效”——它取决于默认构造函数和 operator= 的复杂性。

尚未提及的一件好事是，new[]/delete[] 可以知道数组的大小。 delete[] 只是执行正确的操作并在被要求时销毁所有元素。拖动一个附加变量（或三个）以便您准确地了解如何销毁数组是一件痛苦的事情。然而，专用的集合类型将是一个不错的选择。

为了方便起见，最好使用 new[]/delete[] 。它们带来的开销很小，并且可以使您避免许多愚蠢的错误。您是否有足够的理由取消此功能并在各处使用集合/容器来支持您的自定义构造？我已经实现了这个分配器——真正的混乱是为实践中所需的所有构造变体创建函子。无论如何，您通常会以牺牲程序为代价获得更精确的执行，而程序通常比每个人都知道的习惯用法更难维护。

Answer 5

恕我直言，两者都很难看，最好使用向量。只要确保提前分配空间以提高性能即可。

或者：

std::vector<my_object> my_array(MY_ARRAY_SIZE);

如果您想使用所有条目的默认值进行初始化。

my_object basic;
std::vector<my_object> my_array(MY_ARRAY_SIZE, basic);

或者，如果您不想构造对象但确实想保留空间：

std::vector<my_object> my_array;
my_array.reserve(MY_ARRAY_SIZE);

那么如果您需要将其作为 C 样式指针数组访问（只需确保在保留旧指针的同时不添加内容，但无论如何，你不能用常规的c风格数组来做到这一点。）

my_object* carray = &my_array[0];      
my_object* carray = &my_array.front(); // Or the C++ way

访问单个元素：

my_object value = my_array[i];    // The non-safe c-like faster way
my_object value = my_array.at(i); // With bounds checking, throws range exception

Typedef for beautiful：

typedef std::vector<my_object> object_vect;

通过引用将它们传递给函数：

void some_function(const object_vect& my_array);

编辑：
在 C++11 中还有 std::array。但它的问题是它的大小是通过模板完成的，因此您不能在运行时制作不同大小的大小，并且不能将其传递到函数中，除非它们期望完全相同的大小（或者模板函数本身）。但它对于缓冲区之类的东西很有用。

std::array<int, 1024> my_array;

编辑2：
另外，在 C++11 中，有一个新的 emplace_back 作为 push_back 的替代品。这基本上允许您“移动”您的对象（或直接在向量中构造您的对象）并为您保存一个副本。

std::vector<SomeClass> v;
SomeClass bob {"Bob", "Ross", 10.34f};
v.emplace_back(bob);
v.emplace_back("Another", "One", 111.0f); // <- Note this doesn't work with initialization lists ☹

Answer 6

哦，好吧，我在想，鉴于答案的数量，没有理由介入……但我想我和其他人一样被吸引了。让我们来看看

1. 为什么你的解决方案被破坏了
2. C++11 处理原始内存的新设施
3. 更简单的方法来完成这个
4. 任务 建议

1。为什么您的解决方案被破坏了

首先，您提供的两个片段并不相同。 new[] 正常工作，而您的在出现异常时会严重失败。

new[] 的作用是跟踪所构造的对象的数量，因此，如果在调用第三个构造函数期间发生异常，它会正确调用已经存在的第二个对象的析构函数构造的对象。

然而，您的解决方案严重失败：

• 要么您根本不处理异常（并且泄漏严重）
• ，要么您只是尝试调用整个数组的析构函数，即使它是半构建的（可能会崩溃，但谁知道未定义的行为）

所以两者显然不相等。 你的坏了

2。 C++11 用于处理原始内存的新设施

在 C++11 中，委员会成员已经意识到我们是多么喜欢摆弄原始内存，并且他们引入了一些设施来帮助我们更高效、更安全地这样做。

检查 cppreference 的 简介。此示例展示了新功能 (*)：

#include <iostream>
#include <string>
#include <memory>
#include <algorithm>

int main()
{
    const std::string s[] = {"This", "is", "a", "test", "."};
    std::string* p = std::get_temporary_buffer<std::string>(5).first;

    std::copy(std::begin(s), std::end(s),
              std::raw_storage_iterator<std::string*, std::string>(p));

    for(std::string* i = p; i!=p+5; ++i) {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    std::return_temporary_buffer(p);
}

请注意，get_temporary_buffer 不会抛出异常，它返回实际已分配内存作为 pair< 的第二个成员的元素数量。 /code> （因此 .first 来获取指针）。

(*) 或者也许并不像 MooingDuck 所说的那么新。

3。完成此操作的更简单方法

据我所知，您真正需要的是一种类型化内存池，其中某些位置可能未已初始化。

你知道boost::可选？

它基本上是一个原始内存区域，可以容纳给定类型（模板参数）的一项，但默认情况下没有任何内容。它具有与指针类似的接口，可让您查询内存是否实际被占用。最后，使用就地工厂< /a> 如果有问题，您可以安全地使用它，而无需复制对象。

好吧，您的用例确实看起来像 std::vector<升压::可选 > 对我来说（或者可能是一个双端队列？）

4。建议

最后，如果您真的想自己做，无论是为了学习还是因为没有 STL 容器真正适合您，我建议您将其包装在一个对象中以避免代码遍布各处。

不要忘记：不要重复自己！

使用对象（模板化），您可以在一个位置捕获设计的精髓，然后在任何地方重复使用它。

当然，为什么不在这样做时利用新的 C++11 设施呢:)？

Answer 7

您应该使用向量。

Answer 8

不管是否教条，这正是所有 STL 容器进行分配和初始化的操作。

他们使用分配器，然后分配未初始化的空间并通过容器构造函数对其进行初始化。

如果这（就像很多人常说的）“不是c++”，标准库怎么能这样实现呢？

如果您只是不想使用 malloc / free，则可以仅使用 new char[] 分配“字节”。

myobjet* pvext = reinterpret_cast<myobject*>(new char[sizeof(myobject)*vectsize]);
for(int i=0; i<vectsize; ++i) new(myobject+i)myobject(params);
...
for(int i=vectsize-1; i!=0u-1; --i) (myobject+i)->~myobject();
delete[] reinterpret_cast<char*>(myobject);

这使您可以利用初始化和分配之间的分离，同时仍然利用新分配异常机制。

请注意，将第一行和最后一行放入 myallocator 类中，将第二行和倒数第二行放入 myvector 类中，我们有...刚刚重新实现了 std::vector; >

Answer 9

您在这里展示的实际上是使用与系统通用分配器不同的内存分配器时的方法 - 在这种情况下，您将使用分配器 (alloc->malloc(sizeof(my_object))) 分配内存，然后使用放置 new 运算符来初始化它。这在高效的内存管理方面有很多优点，并且在标准模板库中很常见。

Answer 10

如果您正在编写一个模仿 std::vector 功能的类或需要控制内存分配/对象创建（在数组中插入/删除等） - 这就是要走的路。在这种情况下，这不是“不调用默认构造函数”的问题。这就变成了一个能够“分配原始内存、memmove旧对象，然后在旧对象的地址创建新对象”的问题，以及能够使用某种形式的realloc<的问题。 /代码>等等。毫无疑问，自定义分配+放置 new 更加灵活......我知道，我有点醉了，但是 std::vector 适合胆小鬼......效率 - 人们可以编写自己的 std::vector 版本，该版本至少与最常用的一样快（并且很可能更小，就 sizeof() 而言） 80%的std::vector 功能可能需要不到 3 小时。

Answer 11

my_object * my_array=new my_object [10];

这将是一个包含对象的数组。

my_object * my_array=(my_object *)malloc(sizeof(my_object)*MY_ARRAY_SIZE);

这将是一个与对象大小相同的数组，但它们可能会“损坏”。例如，如果您的类有虚拟函数，那么您将无法调用它们。请注意，不仅仅是您的成员数据可能不一致，而且整个对象实际上是“损坏的”（缺乏更好的词）

我并不是说执行第二个是错误的，只要您知道这一点。