不使用extern关键字如何在多个C++文件中访问main.cpp的Player类对象

下面提供3种常用的实现思路，可根据项目实际情况选择：

方案1：单例模式（最常用，改动量小） #

将Player类设计为单例，全局唯一实例的获取逻辑封装在类内部，不需要extern声明，也不需要显式定义全局变量，所有需要访问实例的文件只要引入player.h即可。

代码示例 #

player.h文件修改如下：

#ifndef PLAYER_H
#define PLAYER_H

class Player {
public:
    // 禁用拷贝、移动构造，避免生成额外实例
    Player(const Player&) = delete;
    Player& operator=(const Player&) = delete;
    Player(Player&&) = delete;
    Player& operator=(Player&&) = delete;

    // 全局唯一实例访问入口
    static Player& getInstance() {
        static Player instance; // C++11及以上版本保证静态局部变量初始化线程安全
        return instance;
    }

    void update();
    // 其他原有类成员声明...

private:
    // 构造函数私有化，禁止外部直接创建实例
    Player() = default;
};
#endif

修改后的main.cpp：

#include "player.h"

int main() {
  // 直接通过类静态方法访问实例
  Player::getInstance().update();
}

其他文件访问Player实例时，只要引入player.h，调用Player::getInstance()即可拿到唯一对象。

方案2：依赖注入（耦合度最低，可测试性最好） #

如果不想引入单例模式，可通过依赖注入的方式，把Player实例的引用/指针传递给所有需要访问它的模块，完全不需要任何全局变量，也不需要extern。

代码示例 #

假设存在需要访问Player的模块GameScene：

// gamescene.h
#include "player.h"

class GameScene {
public:
    // 构造函数传入Player实例引用
    explicit GameScene(Player& player) : m_playerRef(player) {}
    
    void processLogic() {
        m_playerRef.update(); // 直接使用持有引用
    }
private:
    Player& m_playerRef;
};

main.cpp逻辑：

#include "player.h"
#include "gamescene.h"

int main() {
    Player player;
    GameScene scene(player); // 实例化模块时注入Player实例

    player.update();
    scene.processLogic();
}

该方案完全消除了全局依赖，模块间的依赖关系清晰可见，更方便后续单元测试，适合大型项目使用。

方案3：实例访问接口封装（无需改动原有Player类） #

如果不想修改原有Player类的结构，可以单独封装实例访问接口，替代extern声明：

代码示例 #

新增头文件player_accessor.h：

#ifndef PLAYER_ACCESSOR_H
#define PLAYER_ACCESSOR_H
#include "player.h"

// 声明实例获取接口
Player& getPlayerInstance();

#endif

main.cpp实现接口：

#include "player.h"
#include "player_accessor.h"

Player player;

// 实现实例获取接口
Player& getPlayerInstance() {
    return player;
}

int main() {
  //
  player.update();
}

其他需要访问Player的文件只要引入player_accessor.h，调用getPlayerInstance()即可拿到实例，不需要写extern声明。

内容的提问来源于stack exchange，提问作者user13351174