C++ 嵌套类详解：概念、作用与实现细节

来看个具体的例子，注意注释里的编译错误提示：

class Outer {
private:
    class PrivateInner {
    public:
        void privateFunc() {
            std::cout << "Private Inner\n";
        }
    };

protected:
    class ProtectedInner {
    public:
        void protectedFunc() {
            std::cout << "Protected Inner\n";
        }
    };

public:
    class PublicInner {
    public:
        void publicFunc() {
            std::cout << "Public Inner\n";
        }
    };
};

int main() {
    // 合法，PublicInner 是公开的
    Outer::PublicInner obj;
    obj.publicFunc();

    // 编译错误：PrivateInner 是私有嵌套类
    // Outer::PrivateInner obj2;

    // 编译错误：ProtectedInner 是保护嵌套类
    // Outer::ProtectedInner obj3;

    return 0;
}

2. 模板嵌套类

如果外围类是模板类，嵌套类可以继承外围类的模板参数，也可以独立定义自己的模板参数。

继承外围类模板参数

这是最常见的情况，嵌套类直接使用外围类的 T。

template <typename T>
class Container {
public:
    class Iterator {
    private:
        T* ptr; // 指向 T 类型的指针
    public:
        Iterator(T* p) : ptr(p) {}
        T& operator*() { return *ptr; }
    };

private:
    T data[10];
};

当 Container<T> 实例化为 Container<int> 时，嵌套类 Iterator 内部的 T 也会自动替换为 int，变成 Container<int>::Iterator。

独立模板参数

有时候嵌套类需要自己的泛型，这时候可以定义独立的模板参数。

template <typename T>
class OuterTemplate {
public:
    template <typename U> // 嵌套类是独立模板，有自己的参数 U
    class NestedTemplate {
    private:
        T outerData; // 使用外围类的模板参数 T
        U nestedData; // 使用自己的模板参数 U
    public:
        NestedTemplate(T t, U u) : outerData(t), nestedData(u) {}
        void print() {
            std::cout << "Outer: " << outerData 
                      << ", Nested: " << nestedData << "\n";
        }
    };
};

// 使用示例
int main() {
    // 外围类实例化为 OuterTemplate<double>
    // 嵌套类实例化为 NestedTemplate<std::string>
    OuterTemplate<double>::NestedTemplate<std::string> obj(3.14, "Hello");
    obj.print(); // 输出：Outer: 3.14, Nested: Hello
    return 0;
}

3. 成员函数的定义方式

嵌套类的成员函数可以在类内部直接定义，也可以在外围类外部定义。对于较短的逻辑，直接在类内写没问题；但如果逻辑复杂或者需要分离声明与实现，建议用作用域限定符在外面写。

内部定义

class Outer {
public:
    class Inner {
    public:
        void func() {
            // 直接在嵌套类内部定义函数
            std::cout << "Inner function\n";
        }
    };
};

外部定义

如果成员函数较长，可以在外围类外部定义，记得加上 Outer::Inner 的前缀：

class Outer {
public:
    class Inner {
    public:
        void func(); // 声明
    };
};

// 外部定义
void Outer::Inner::func() {
    std::cout << "Inner function defined outside\n";
}

这样处理的好处是头文件更干净，实现细节移到 .cpp 文件中，符合大型项目的规范。