How to make so that a field points to its structure? - c

Question

to sum up i have two structures, item and player, the player structure contains two item structure in its fields.
The item structure have a field that is a pointer to a player structure, this pointer must points to the player that owns this item. When i initialize the player whith new_player() i want to make so that the items points to the player being created inside the function.
To me it doesn't seems possible because the items will points to a structure created on the stack, once the structure is returned its items members points to freed memory. I made a few tests that seems to confirm this theory.
Code:
struct item
{
int power;
struct player* owner;
};
struct item new_item(int power, struct player* owner)
{
struct item an_item;
an_item.power = power;
an_item.owner = owner;
return an_item;
}
struct player
{
int age;
struct item item_1;
struct item item_2;
};
struct player new_player(int age)
{
struct player a_player;
a_player.age = age;
a_player.item_1 = new_item(1, &a_player);
a_player.item_2 = new_item(2, &a_player);
return a_player;
}
A solution to this could be to return a pointer to player with new_player() and to allocate it on the heap:
struct player* new_player(int age)
{
struct player* a_player = malloc(sizeof (struct player));
a_player->age = age;
a_player->item_1 = new_item(1, a_player);
a_player->item_2 = new_item(2, a_player);
return a_player;
}
Tests:
int main()
{
struct player* player_1 = new_player(77);
printf("Age of the player: %d.\n", player_1->age);
printf("Age of the player (from item_1): %d.\n", player_1->item_1.owner->age);
printf("Age of the player (from item_2): %d.\n", player_1->item_2.owner->age);
printf("Age of the player (from item_1 by owner): %d.\n",
player_1->item_1.owner->item_1.owner->age);
printf("Age of the player (from item_2 by owner): %d.\n",
player_1->item_2.owner->item_2.owner->age);
printf("Age of the player (from item_1 by owner to item_2): %d.\n",
player_1->item_1.owner->item_2.owner->age);
printf("Age of the player (from item_2 by owner to item_1): %d.\n",
player_1->item_2.owner->item_1.owner->age);
printf("Power of the first item: %d, power of the second item: %d.\n",
player_1->item_1.power, player_1->item_2.power);
printf("Power of the first item (from item_1): %d, power of the first item (from item_2): %d.\n",
player_1->item_1.owner->item_1.power, player_1->item_2.owner->item_1.power);
printf("Power of the second item (from item_1): %d, power of the second item (from item_2): %d.\n",
player_1->item_1.owner->item_2.power, player_1->item_2.owner->item_2.power);
free(player_1);
return 0;
}
Could some experimented C programmers give me advices on what is the best way to do this (or others ways i haven't thinked about)?

Answer 1

In the player struct you have, the items are parts of the player. So when you allocate the player on the heap, you can just set player pointer inside the items to the newly created player.
You are right that, if you create the player on the stack, this will not work, because after returning, the player object will be copied, including the pointers to the items (which then point to the "previous" location of the player on the stack).
Another solution, that is often used, is to allocate the player outside of the new_player function and pass it in as a pointer:
void new_item(struct item *i, int power, struct player *p) {
i->owner = p;
i->power = power;
}
void new_player(struct player *p, int age) {
p->age = age;
new_item(&p->item_1, 1, p);
new_item(&p->item_2, 2, p);
}
struct player p;
new_player(&p, 10);
This way you can decouple the allocation of your objects from the initialization. You could for example, have a big array of player objects that holds all players and is allocated just once. Then you initialize the player objects by passing in pointers to the objects in the array.
Or you could heap-allocate a player and initialize it with the same function.

Answer 2

Just as reference, a professional program design would involve the following:
Create one class for item and one class for player. Every class is handling the creation and deletion of one object of that class. Typically you would do this with dynamic memory allocation.
Hide the contents of the struct to the caller by implementing opaque type (private encapsulation). All access to struct members has to be done through setter/getter functions
The item constructor function would have an optional parameter "owner". If an item has no owner, then set it to NULL.
Implement const correctness where applicable. For example, an item should not be allowed to modify its owner.
The rare case of "two-directional ownership" requires a few more forward declarations.
You'd end up with something like this:
item.h
#ifndef ITEM_H
#define ITEM_H
#include "player.h"
#include <stdlib.h>
typedef struct item_t item_t;
typedef struct player_t player_t; // forward declaration needed to prevent linker errors
item_t* item_create (int power, const player_t* owner);
void item_delete (item_t* item);
#endif
item.c
#include "item.h"
struct item_t
{
int power;
const player_t* owner;
};
item_t* item_create (int power, const player_t* owner)
{
item_t* new_item = malloc(sizeof(*new_item));
if(new_item != NULL)
{
new_item->power = power;
new_item->owner = owner;
}
return new_item;
}
void item_delete (item_t* item)
{
free(item);
}
player.h
#ifndef PLAYER_H
#define PLAYER_H
#include "item.h"
#include <stdlib.h>
typedef struct player_t player_t;
typedef struct item_t item_t; // forward declaration needed to prevent linker errors
player_t* player_create (int age);
void player_delete (player_t* player);
#endif
player.c
#include "player.h"
struct player_t
{
int age;
struct item_t* item_1;
struct item_t* item_2;
};
player_t* player_create (int age)
{
player_t* new_player = malloc(sizeof(*new_player));
if(new_player != NULL)
{
new_player->age = age;
new_player->item_1 = item_create(1, new_player);
new_player->item_2 = item_create(2, new_player);
}
return new_player;
}
void player_delete (player_t* player)
{
item_delete(player->item_1);
item_delete(player->item_2);
free(player);
}

Answer 3

Apply the same principle to the new_item() function. It have to return a pointer to the struct allocated.
I would like to recommend you to provide another function, that will be responsible for freeing all theses pointers. It could be an destroy_player(struct player *player) that will free both items and the player itself.