C++状态机实现：如何在类内定义方法并解决前向声明问题？

要在StateA、StateB的类内直接实现next()方法，同时解决全局对象/指针的前向引用问题，有几种可行方案：

方案一：用静态成员变量替代全局对象 #

把原本的全局实例改成对应状态类的静态成员，类内声明静态成员后，就能直接在next()方法里通过类名访问另一个状态的静态实例，无需复杂的前向声明。

示例代码：

class State {
public:
    virtual State* next() = 0;
};

class StateB; // 仅需前向声明StateB类

class StateA : public State {
public:
    static StateA instance; // 声明静态实例
    State* next() override {
        return &StateB::instance; // 类内直接引用StateB的静态实例
    }
};

class StateB : public State {
public:
    static StateB instance;
    State* next() override {
        return &StateA::instance; // 类内直接引用StateA的静态实例
    }
};

// 必须在类外完成静态成员的初始化
StateA StateA::instance;
StateB StateB::instance;

这个方案无需手动管理内存，静态成员的生命周期和程序一致，可读性也符合要求。

方案二：用函数返回静态局部实例 #

通过命名空间封装状态类，提前声明获取实例的函数，类内next()方法调用这些函数获取实例，彻底避开全局对象的前向引用问题。

示例代码：

namespace StateMachine {
    class State {
    public:
        virtual State* next() = 0;
    };

    // 提前声明获取实例的函数
    class StateA;
    class StateB;
    StateA& getStateA();
    StateB& getStateB();

    class StateA : public State {
    public:
        State* next() override {
            return &getStateB(); // 类内直接调用函数获取实例
        }
    };

    class StateB : public State {
    public:
        State* next() override {
            return &getStateA(); // 类内直接调用函数获取实例
        }
    };

    // 定义获取实例的函数，静态局部变量保证唯一实例
    StateA& getStateA() {
        static StateA instance;
        return instance;
    }

    StateB& getStateB() {
        static StateB instance;
        return instance;
    }
}

这种方式的优势是实例的初始化是懒加载的，只有第一次调用get函数时才会创建实例，避免了全局对象的初始化顺序问题。

方案三：修正全局指针的前向声明用法 #

如果坚持要用全局指针，需要先前向声明状态类，再声明全局指针，类内next()方法使用指针，最后在类外完成指针的初始化。

示例代码：

#include <memory>

// 前向声明状态类
class StateA;
class StateB;

// 声明全局智能指针（避免内存泄漏）
extern std::unique_ptr<StateA> stateA;
extern std::unique_ptr<StateB> stateB;

class State {
public:
    virtual State* next() = 0;
};

class StateA : public State {
public:
    State* next() override {
        return stateB.get(); // 类内使用指针
    }
};

class StateB : public State {
public:
    State* next() override {
        return stateA.get(); // 类内使用指针
    }
};

// 类外初始化全局指针
std::unique_ptr<StateA> stateA = std::make_unique<StateA>();
std::unique_ptr<StateB> stateB = std::make_unique<StateB>();

注意如果用裸指针，要记得在程序结束时手动释放，否则会造成内存泄漏，推荐使用智能指针自动管理。

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