我可以将某些对象的指针保存在向量中，然后用这些指针调用内联函数吗

Question

假设我有一个 Player 类，它有一些成员函数。其中之一使用 this 关键字返回对象的指针。 Player* getPlayer() { return this;};

class Player
{
public:

    Player(int id, string name, int score = 0) : pId(id), pName(name), pScore(score) { };
    void rollDice();

    int getId() { return pId; }
    int getScore() { return pScore; }
    string getName() { return pName; }
    Player* getPlayer() { return this;};
private:
    int pId;
    std::string pName;
    int pScore;
    unsigned char playerDiceRolled;
    Dice mDice;
};

我还有一个名为 Game 的类，它使用一个函数将任何玩家的信息保存在不同的向量中。其中一个向量保存了对象向量 playerList 的指针；

class Game
{
public:


    void Winer();
    void addPlayer(Player A) ;
    void updateScore();
    vector<Player*> playerList;
    vector<int> idList;
    vector<string> nameList;
    vector<size_t> scoreList;

};

void Game::addPlayer(Player A)
{

    this->playerList.push_back(A.getPlayer());
    this->idList.push_back(A.getId());
    this->nameList.push_back(A.getName());
    this->scoreList.push_back(A.getScore());

}

我的问题是我可以从那个向量中取出指针并用它来调用那个类的函数并返回 wright 值。

我试过了，还是不行

我可以看到 Player 的其他值已正确保存，但是当我使用指针调用函数以获取值时，它返回 null。 例如

int main()
{
    Game Game1;
    Player A(0, "Player1");
    Player B(1, "Player2");
    Game1.addPlayer(A);

    Game1.addPlayer(B);

    cout << "Name is:" << Game1.nameList[1] << "\n";



    cout << "Name is:" << Game1.playerList[1]->getName() << "\n";






    return 0;

}

cout 为 Game1.nameList[1] 提供玩家的赖特名称，但为 NULL 值 Game1.playerList[1]->getName()

Answer 1

那是因为你正在存储一个指向你的对象副本的指针：

void Game::addPlayer(Player A)

你需要使用一个引用并存储它：

void Game::addPlayer(Player& A)

否则你会得到一个未定义的行为。

Answer 2

addPlayer(Player A) 获取 Player 对象的副本。 A 的副本在方法 addPlayer 的末尾被破坏。使用this->playerList.push_back(A.getPlayer());，您可以将指针保存到向量中的临时对象。

您应该从总体上考虑您的代码设计。游戏具有玩家列表，因此游戏拥有这些玩家对象的共享或独占所有权。因此，您不应在此处使用原始指针。

如果您拥有独占所有权，您将使用：

std::vector<std::unique_ptr<Player>> playerList;

或者

std::vector<Player> playerList;

对于您将使用的共享所有权：

std::vector<std::shared_ptr<Player>> playerList;

所以设置可能如下所示：

int main()
{
    Game Game1;

    Game1.addPlayer(std::move(std::make_unique<Player>(0, "Player1"));
    Game1.addPlayer(std::move(std::make_unique<Player>(0, "Player2"));

    cout << "Name is:" << Game1.nameList[1] << "\n";
    cout << "Name is:" << Game1.playerList[1]->getName() << "\n";

    return 0;
}


class Game {
public:
    void Winer();
    void addPlayer(Player A);
    void updateScore();
    vector<std::unique_ptr<Player>> playerList;
    vector<int> idList;
    vector<string> nameList;
    vector<size_t> scoreList;
};

void Game::addPlayer(std::unique_ptr<Player> A)
{
    this->idList.push_back(A->getId());
    this->nameList.push_back(A->getName());
    this->scoreList.push_back(A->getScore());

    // adding A to the vector has to be the last action, because A is moved to the vector
    this->playerList.push_back(std::move(A));
}

原始指针现在一般来说是不好的，但是当你想表达所有权时不要使用它们。因此，如果您将 Player 对象传递给不应获得该对象所有权的函数，那么您会将其作为原始指针传递：

void print_player_info(Player * const p) {
    // only prints the player info so no ownership is taken
    // p is only use within print_player_info  
    cout << "Name is:" << p->getName() << "\n";
} 


int main()
{
    Game Game1;

    Game1.addPlayer(std::move(std::make_unique<Player>(0, "Player1"));
    Game1.addPlayer(std::move(std::make_unique<Player>(0, "Player2"));

    print_player_info(Game1.playerList[1]->get());

    return 0;
}