3

所以说我有

foo* fooObject1 = new foo[10];
// here would go code for initializing fooObject1[0] to fooObject1[9] with a foo object for each.
foo* fooObject2 = new foo[30];

for(int = 0; i < 10; i++)
fooObject2[i] = fooObject1[i];

if(fooObject1 != NULL)
delete[] fooObject1; //this "destroys" the array, BUT ALSO calls the destructors of all the foo objects inside fooObject1, causing fooObject2 elements to be anything but what it was before.

fooObject1 = fooObject2;

foo我使用其各自的方法创建的特定对象在哪里。

然而，我的问题是我想破坏 fooObject1 指向的数组，而不是数组的元素，有没有办法在 C++ 中完成？我知道解决这个问题的另一种方法是重载 = (equals) 运算符，但是在我需要它的程序中，编写这将包括为许多其他类重载许多其他 = 运算符，这使得它成为一个乏味而漫长的过程. 我希望以某种方式可以将对象保留在 fooObject2 中，但摆脱 fooObject1 指向的数组。那么这可以做到吗？如何？如果不是，那么有没有网站可以重定向我阅读它？

4

4 回答 4

2

指向 fooObject1 的数组包含对象。您实际上是在要求木匠破坏书柜，但将书架留在书架上。（如果你能做到的话，这是一个很好的技巧。）

在您的 for 循环中，然后将对象从 fooObject1 复制到 fooObject2。所以 fooObject2 里面有不同的对象。

如果您希望对象独立于它们的容器，您应该使用指针。

于 2012-09-29T04:44:07.147 回答
2

这些是独立的。您的 fooObject2 数组已像 fooObject1 一样被分配，并且在此过程中为每个数组触发了赋值运算符。您实际上在 fooObject2 中拥有来自 fooObject1 的每个对象的副本。

你不能放弃 fooObject1。您需要删除 [] 它，否则您会泄漏内存。正如所写的，fooObject2 是独立的，除非您在 fooObject 类中有内部指针并且执行了浅拷贝，因为您没有遵循三规则。

在您清理 fooObject1 并删除其先前的内存分配之后，此设置的最后一行将 fooObject1（指针）指向与 fooObject2 相同的对象，仅供参考，但在进行该引用后不要同时删除它们；只删除一个。

于 2012-09-29T04:47:35.247 回答
1

在 C++ 中，数组不是对象。您拥有的是两个指针，因为您调用new[]了 ，它们恰好指向 n 个连续分配对象的开头。您不能删除数组，也不能删除对象。数组“是”对象所在的连续内存。

但是，您可以清除指针，但这样做意味着您不再知道对象的位置。这就是所谓的内存泄漏。该内存是为这些对象分配的，您不能再释放它，因为您不知道它在哪里。

您确实将 10 个对象的值从 复制fooObject1到fooObject2。删除fooObject1不会更改对象，fooObject2因为它们是不同的对象 -fooObject2指向具有不同对象集的不同内存位置中的不同数组。您fooObject1通过将这些对象的值分配给fooObject2.

于 2012-09-29T04:48:20.903 回答
1

您可能想要使用现代 C++技术和容器，例如std::vector（而不是原始异常、不安全、容易泄漏 new[]和delete[]原始指针）。

如果您想要指向对象的指针数组foo，并且希望这些foo对象在这些数组之间共享，您可以考虑使用vector<shared_ptr<foo>>.

shared_ptr是一个智能指针模板类，它使用引用计数，并且只有在对象的最后一个引用被释放时才销毁指向的对象。

您可以使用make_shared分配器来实例化 的新实例foo，并使用 将它们放入（动态）数组中vector::push_back()。

例如

#include <vector> // std::vector
#include <memory> // std::shared_ptr, std::make_shared

using namespace std;

// Smart pointer to foo
typedef shared_ptr<foo> foo_ptr;

// Dynamic arrays of smart pointers
typedef vector<foo_ptr> foo_array;

// Define an array of smart pointers to foo
foo_array v1;

// Populate the array
v1.push_back( make_shared<foo>( /* some constructor init params */ ) );
v1.push_back( make_shared<foo>( /* ... */ ) );

// Create another array of smart pointers to foo's
// and reference the foo's created in v1
foo_array v2 = v1;

// Empty the array of smart pointers 'v1'.
// However, the 'foo' objects previously created are still "alive",
// because of the references stored in 'v2'.
v1.clear();

请注意，使用现代C++ 技术：没有明确 delete的; 由于 STL 容器、智能指针和 C++ 析构函数的强大功能，资源可以自动管理；代码无泄漏且异常安全，更易于阅读和维护。

于 2012-09-29T10:21:14.000 回答