0

If I have a pointer to a struct/object, and that struct/object contains two other pointers to other objects and I want to delete the "object that contains the two pointers without destroying the pointers it holds" - how do I do that?

Pointer to Object A (Contains Pointer to Object B, Contains Pointer to Object C). Delete Object A Pointer to Object A is deleted, Pointer to Object B / C does still exists.

Is there something that I have to do to make this work?

UPDATE

It's for a game project, I hope this explains it. Right now, I have some "problems" even putting the two pointers to B, C inside the first Struct (A)

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

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

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

And this somehow doesn't work.

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

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

And later when a player "dies", the equipment should not be deleted.

Improve this question
5
  • We need more details. Are members destroyed in struct's destructor? Commented Jun 22, 2012 at 8:28
  • 1
    Have you actually tried to do this and come across some problems? Because deleting a struct will not call delete on any pointers it contains. Commented Jun 22, 2012 at 8:28
  • 1
    Who owns B and C? What decides when they should be deleted? Commented Jun 22, 2012 at 8:29
  • Game Project, a player/enemy holds equipment until they get "destroyed", although that doesn't say that the equipment gets destroyed. Commented Jun 22, 2012 at 8:38
  • Btw, all the code you show, does what you want as far as it goes. Deleting a player does not delete their weapon. If your program "doesn't work", you'll need to ask another question about whatever it is that goes wrong. Commented Jun 22, 2012 at 9:30

5 Answers 5

Reset to default
4

The pointers (B & C) contained inside the pointer (A) will not be deleted unless you explicitly do it through your destructor. But you cant use the pointer A to access B & C once you delete the pointer A.

Note: You should be having a copy constructor and = overloaed operator in your class A to avoid shallow copying.

If you want to use the same armor and the weapon for someother player make sure you are not deleting the weapon and armor in your players destructor. Then you can use the same pointers for another player like this.

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

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

Player* player2 = CreatePlayer("Beta", weapon, armor);
delete player2;
Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

If the struct doesn't own the objects pointed to, perhaps you want shallow copying. Or no copying at all.
Updated my post, please see my example.
@Deukalion: Not sure how you are saying the weapon is deleted when the player is deleted? are you releasing the memory of the weapon in the destructor of the player?
I am not saying anything, I'm asking what to do. If I have an object "Enemy" instead of "Player" and the enemy dies in the game, he also carries a weapon and an armour those should not be deleted when the game calls Destroy(Player* player) or Destroy(Enemy* enemy); Those items, should lie on the ground after an enemy is slain and therefor the pointers to those items should not be deleted. But the Enemy should be deleted.
@Deukalion: Don't delete the Weapon in the destructor of Player. Then it remains alive. But you cant access it with the player object.
1

Pointer to Object A (Contains Pointer to Object B, Contains Pointer to Object C). Delete Object A Pointer to Object A is deleted, Pointer to Object B / C does still exists?

No, they are in undefined state. Anything can happen to them. May be in your system, you notice that they are existent, but assume it's just an illusion, which is not guaranteed every time.

As soon as, you delete A*, all it's content are available for next dynamic allocation. Possibly they might get allocated to some other object later on. Some system, may 0 out everything which is deleted. Again, anything can happen!

Is there something that I have to do to make this work?

Store B* and C* to other pointers before deleting A*.Then it's perfectly ok, because objects are intact and you have its addresses stored.

Improve this answer

1 Comment

Just to emphasize: the objects B and C still exist, but the pointers to them that are part of the body of A, do not exist. Other pointers to the same object do still exist, which is why the thing to do is to copy the pointer before deleting A.
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!

But you can do so:

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

EDIT

In your case armor and weapon are not destroyed. You just lose pointers to them (and get the memeory leak). I suggest you to hold all your armor and weapons in some containers (like std::vector) to keep the pointers

Improve this answer

1 Comment

Updated my post, please see my example.
0

I don't think this is possible without making a copy of a and b first.

Improve this answer

Comments

-1

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
Improve this answer

9 Comments

Presumably, if he doesn't want to delete the pointers, it is because they are used for navigation, and not ownership. (In my experience, this is usually the case.) Using shared_ptr for this will result in cycles, and using unique_ptr simply doesn't work.
@James: aha! "navigation and not ownership", good phrase. When I have this argument, I talk about how raw pointers can be used to define "structure", which is less clear than "navigation". The next phase of the argument seems to be "well, then use weak_ptr, because clearly the fix for too many smart pointers is to add more smart pointers" ;-)
@JamesKanze But in that case, he wouldn't have arrived at the concern about preserving them before the object gets destroyed, because some other navigation path would exist. That was the first thing I thought of before writing the answer. For a random graph, shared_ptr with weak_ptr to break cycles is the generic recommendation. Anyway, the question (as written when I answered) was very vague.
@Potatoswatter If you need weak_ptr, then you shouldn't be using shared_ptr. Determining which pointers have to be weak is more difficult than managing the memory completely by hand. (Also, a lot of navigation involves pointers in vectors or maps. Using weak_ptr doesn't remove the entry in the vector or the map, which ultimately leads to memory leaks.)
@JamesKanze Well, it depends. The last program I wrote with a complicated graph stored it as a list of cycles, but there were no smart pointers. Anyway, as I said, the original question somewhat indicated the task wasn't "navigation". Now the updated question seems to show a fundamental misunderstanding of what pointers are — he's expecting unique_ptr behavior despite having a naked pointer.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.