Function that creates pointers to classes
If you really want to use raw pointers for your players, you can modify your createPointer
function to return what it has created:
player* createPointer()
{
player* createdPlayer = new player("George");
// Do whatever you need for initialization!
return createdPlayer;
}
Then, in the code that wants to use such players, do something like:
//...
player* player1 = createPointer();
player* player2 = createPointer();
//...
Then, when you've done with the players, you can just delete
each one...
delete player1;
delete player2;
A better solution (IMHO) would be to put whatever code you (eventually) have in createPointer
into the constructor definition for the player
class; then you can just use code like player *p1 = new player("Harold");
rather than calling a function each time you make a new player.
But, as mentioned in the comments, you would be better off using either std::vector
or std::shared_ptr
objects.
You probably need a container of player
instances. The default container is std::vector
.
Something like
std::vector<player> players;
players.emplace_back("George"); // Create the first player
players.emplace_back("Fred"); // Create the next player
// etc.
You can refer to players by their (0 based) position in players
players[0].do_stuff(); // George does stuff
You can loop over all the players
for (auto & player : players) {
player.take_turn(); // each player in turn does something
}
When players
is destroyed, it automatically cleans up the player
objects
If i understand you correctly,maybe there are two solutions to solve your problem. Here the codes.
#include <string>
#include <iostream>
using namespace std;
class Player
{
public:
Player(string name) :m_name(name) {
cout << "player " << m_name << " is created\n";
}
~Player()
{
cout << "pluaer " << m_name << " is destoryed\n";
}
private:
string m_name;
};
//The first solution : return a pointer
Player* creatPlayer_1(const string& name)
{
return new Player(name);
}
//The second solution : pass a reference of the pointer as the argument
void createPlayer_2(Player*& pPlayer, const string& name)
{
pPlayer = new Player(name);
}
int main()
{
Player* pPlayer_one = creatPlayer_1("one");
Player* pPlayer_two = nullptr;
createPlayer_2(pPlayer_two, "two");
delete pPlayer_one;
delete pPlayer_two;
}