访客模式实现遭遇A、B类类型不完整问题咨询

嘿，这个问题我太熟悉了——在C++里实现访问者模式时，不完全类型（incomplete type）的问题简直是高频坑，核心原因就是类的声明和定义顺序没理顺，导致编译器处理Visitor类的时候，还不知道A和B的完整结构。下面给你两个实用的解决方案，一步步帮你搞定：

方案1：前向声明 + 分离声明与实现 #

这是最直接的修复方式，利用前向声明让编译器先知道A和B的存在，再把Visitor的成员函数实现放到A、B完整定义之后。

// 先前向声明A和B，告诉编译器这两个是类类型
class A;
class B;

// 定义Visitor的类声明，此时A和B是不完全类型，但仅声明函数没问题
class Visitor {
public:
    Visitor() {}
    // 只声明visit函数，不在这里实现
    void visit(A *a);
    void visit(B *b);
};

// 定义基类Base
class Base {
public:
    Base() {}
    virtual void accept(Visitor *v) = 0;
};

// 现在可以定义A的完整类了，Visitor已经声明过visit(A*)
class A: public Base {
public:
    A(): Base() {}
    void accept(Visitor *v) override { v->visit(this); }
    // 实现A的doSomething
    void doSomething() {
        // 这里写A的具体逻辑
    }
};

// 同理定义B的完整类
class B: public Base {
public:
    B(): Base() {}
    void accept(Visitor *v) override { v->visit(this); }
    // 实现B的doSomething
    void doSomething() {
        // 这里写B的具体逻辑
    }
};

// 现在A和B都是完整类型了，实现Visitor的visit函数
void Visitor::visit(A *a) {
    a->doSomething(); // 编译器现在能找到doSomething的定义了
}

void Visitor::visit(B *b) {
    b->doSomething();
}

为什么这样可行？
前向声明只是告诉编译器“A是一个类”，足够用来声明函数参数（指针或引用类型）；而把visit的实现放到A、B完整定义之后，编译器就能看到它们的成员函数doSomething的具体定义，不会再报不完全类型的错误。

方案2：抽象Visitor基类 + 具体访问者派生类 #

如果你的场景需要多个不同的访问逻辑，这个方案更符合访问者模式的设计思想，同时也能彻底避免不完全类型问题：

// 前向声明所有需要的类
class Base;
class A;
class B;

// 抽象Visitor基类，只声明纯虚函数
class Visitor {
public:
    virtual ~Visitor() = default; // 基类要加虚析构，避免内存泄漏
    virtual void visit(A *a) = 0;
    virtual void visit(B *b) = 0;
};

// 定义Base类
class Base {
public:
    virtual ~Base() = default;
    virtual void accept(Visitor *v) = 0;
};

// 定义A的完整类
class A: public Base {
public:
    void accept(Visitor *v) override { v->visit(this); }
    void doSomething() {
        // A的逻辑
    }
};

// 定义B的完整类
class B: public Base {
public:
    void accept(Visitor *v) override { v->visit(this); }
    void doSomething() {
        // B的逻辑
    }
};

// 具体的访问者类，在A、B完整定义后实现
class ConcreteVisitor: public Visitor {
public:
    void visit(A *a) override {
        a->doSomething();
    }
    void visit(B *b) override {
        b->doSomething();
    }
};

这个方案的优势：
把具体的访问逻辑放到派生的ConcreteVisitor中，Visitor基类只需要前向声明A和B即可；而ConcreteVisitor因为在A、B之后定义，能直接访问它们的成员函数。后续如果需要新增访问逻辑，只需要派生新的Visitor子类，不用修改原有类，符合开闭原则。

关键注意点 #

• 避免在不完全类型上调用成员函数：编译器只有看到类的完整定义（即类的所有成员声明和定义），才能知道成员函数的存在，所以一定要确保调用doSomething时，A和B已经是完整类型。
• 头文件保护：如果把代码拆分到头文件和源文件，记得用#pragma once或者#ifndef ... #define ... #endif避免重复包含问题。
• 虚析构函数：基类（Base和Visitor）一定要添加虚析构函数，否则通过基类指针删除派生类对象时会导致未定义行为。

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