0

如果我有一个指向结构/对象的指针，并且该结构/对象包含其他两个指向其他对象的指针，我想删除“包含两个指针的对象而不破坏它持有的指针” - 我该怎么做？

指向对象 A 的指针（包含指向对象 B 的指针，包含指向对象 C 的指针）。删除对象 A 指向对象 A 的指针被删除，指向对象 B/C 的指针仍然存在。

我需要做些什么来完成这项工作吗？

更新

这是一个游戏项目，我希望这能解释它。现在，即使将两个指向 B、C 的指针放在第一个 Struct (A) 中，我也遇到了一些“问题”

struct Player
{
    char * Name;
    Weapon* PlayerWeapon;
    Armor* PlayerArmor;
};

struct Weapon
{
    char * Name;
    int Damage;
};

struct Armor
{
    char * Name;
    int Resistance;
};

这在某种程度上是行不通的。

Player* CreatePlayer(char * Name, Weapon* weapon, Armor* armor)
{
    Player *pPlayer = new Player;

    pPlayer->Name = name;
    pPlayer->Weapon = weapon;
    pPlayer->Armor = armor;
};

之后当玩家“死亡”时，不应删除设备。

4

5 回答 5

3

包含在指针 (A) 中的指针 (B & C) 不会被删除，除非您通过析构函数明确执行此操作。但是一旦删除指针 A，就不能使用指针 A 访问 B & C。

注意：您的 A 类中应该有一个复制构造函数和 = 重载运算符，以避免浅拷贝。

如果您想为其他玩家使用相同的盔甲和武器，请确保您没有在玩家的析构函数中删除武器和盔甲。然后你可以像这样对另一个玩家使用相同的指针。

Weapon* weapon = CreateWeapon();
Armor* armor   = CreateArmor();

Player* player1 = CreatePlayer("Alpha", weapon, armor);
delete player1;

Player* player2 = CreatePlayer("Beta", weapon, armor);
delete player2;
于 2012-06-22T08:28:56.467 回答
1

指向对象 A 的指针（包含指向对象 B 的指针，包含指向对象 C 的指针）。删除对象 A 指向对象 A 的指针被删除，指向对象 B/C 的指针是否仍然存在？

不，它们处于未定义状态。任何事情都可能发生在他们身上。可能在您的系统中，您注意到它们的存在，但假设这只是一种幻觉，并不能保证每次都如此。

删除A*后，它的所有内容都可用于下一次动态分配。稍后它们可能会被分配给其他对象。某些系统，可能会0删除所有被删除的内容。再次，任何事情都可能发生！

我需要做些什么来完成这项工作吗？

在删除之前存储B*和指向其他指针。然后它完全没问题，因为对象是完整的并且你已经存储了它的地址。C*A*

于 2012-06-22T08:27:50.743 回答
1 
struct Foo
{
   A *a;
   B *b;
}

Foo *foo = new Foo();
delete foo; //foo now points to garbage. you can't use it
foo = nullptr; //don't use foo!

但你可以这样做：

Foo *foo new Foo();
//do some stuff with foo
A *a = foo->a;
B *b = foo->b;
delete foo;
foo = nullptr;
// if Foo does not destroy objects pointed by a,b in destructor you can still
//use them through a,b vars
a->doSomeStuff(); //ok
b->doSomeOtherStuff(); //ok

编辑

在你的情况下，盔甲和武器不会被摧毁。您只是丢失了指向它们的指针（并导致内存泄漏）。我建议你把你所有的盔甲和武器放在一些容器里（比如std::vector）来保存指针

于 2012-06-22T08:25:37.233 回答
0

You should avoid using "naked" pointers. It's better to use a smart pointer class such as shared_ptr or unique_ptr. They take care of new and delete, which are very tricky to get completely right unassisted. These are found in Boost, and shared_ptr is also in the TR1 library (std::tr1::) that probably came with your compiler, or just in plain std:: if your compiler is more recent.

Although you haven't said much about the program, if it's necessary to do something preserve the pointers, it sounds like the object A has the only copy of the pointers to B and C. That is a job for unique_ptr.

In C++11,

struct A_type {
    std::unique_ptr< B_type > B; // Object *owns* B and C
    std::unique_ptr< C_type > C;
};

std::unique_ptr< A_type > A( new A_type );

auto my_B = std::move( A->B ); // Acquire ownership away from object
auto my_C = std::move( A->B );
A.release(); // Delete object and anything it owns (at this point, nothing)

// my_B and my_C are guaranteed to be destroyed at some appropriate time
于 2012-06-22T08:38:48.753 回答
0

如果不先复制 a 和 b，我认为这是不可能的。

于 2012-06-22T08:27:41.520 回答