C++ 如何删除指向（结构/对象）的指针而不破坏（结构/对象）内部的指针？

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

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

我要做些什么才能让这一切顺利进行

更新

这是一个游戏项目，我希望这能解释它。现在，我有一些“问题”，甚至把指向B，C的两个指针放在第一个结构（A）中

但不知怎么的，这是行不通的

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

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

当玩家“死亡”后，该装备不应被删除

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

）来保存指针

但你可以这样做：

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

）来保存指针如果不先复制a和b，我认为这是不可能的。

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

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

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

一旦删除

A*

，它的所有内容都可用于下一次动态分配。可能以后它们会被分配到其他对象。某些系统可能会

0

删除所有已删除的内容。再说一次，任何事情都有可能发生

我要做些什么才能让这一切顺利进行

在删除

A*

之前，将

B*

和

C*

存储到其他指针。这样就完全可以了，因为对象是完整的，并且存储了它的地址

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

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

一旦删除

A*

，它的所有内容都可用于下一次动态分配。可能以后它们会被分配到其他对象。某些系统可能会

0

删除所有已删除的内容。再说一次，任何事情都有可能发生

我要做些什么才能让这一切顺利进行

在删除

A*

之前，将

B*

和

C*

存储到其他指针。这样就完全可以了，因为对象是完整的，并且存储了它的地址。

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

注意：在类a中应该有一个复制构造函数和=overloaded操作符，以避免浅复制

如果你想为其他玩家使用相同的盔甲和武器，请确保你没有删除玩家毁灭者中的武器和盔甲。然后你可以用同样的指针指向另一个这样的玩家

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

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

Player* player2 = CreatePlayer("Beta", weapon, armor);
delete player2;

除非通过析构函数显式删除指针（A）中包含的指针（B&C）。但是一旦删除指针A，就不能使用指针A访问B&C

注意：在类a中应该有一个复制构造函数和=overloaded操作符，以避免浅复制

如果你想为其他玩家使用相同的盔甲和武器，请确保你没有删除玩家毁灭者中的武器和盔甲。然后你可以用同样的指针指向另一个这样的玩家

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

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

Player* player2 = CreatePlayer("Beta", weapon, armor);
delete player2;

您应该避免使用“裸”指针。最好使用智能指针类，如

shared\u ptr

或

unique\u ptr

。他们负责

新建

和

删除

，这是非常棘手的，要想在无人帮助的情况下完全正确。它们可以在Boost中找到，而且

shared\u ptr

也可以在您的编译器可能附带的TR1库（

std:：TR1:：

）中找到，或者如果您的编译器是较新的，也可以在普通的

std:

中找到

虽然您对该程序的介绍不多，但如果有必要做一些事情来保留指针，听起来对象

A

有指向B和C的指针的唯一副本。这是

unique\u ptr

的工作

在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

结构类型{ std:：unique_ptrB；//对象*拥有*B和C 标准：：独特的ptrC； }; std：：唯一的A_ptrA（新的A_type）； 自动我的B=std:：移动（A->B）；//从对象获得所有权 自动我的C=std:：移动（A->B）； A.释放（）；//删除对象及其拥有的任何内容（此时，无任何内容） //我的B和C一定会在适当的时候被销毁 您应该避免使用“裸”指针。最好使用智能指针类，如

shared\u ptr

或

unique\u ptr

。他们负责

新建

和

删除

，这两项功能非常重要