c++ 嵌套类（Nested Class）、局部类（Local Class）

一、嵌套类（Nested Class）

定义：在一个类的内部定义的类，称为嵌套类。
特点：

1. 嵌套类可以访问外层类的 私有成员，但需要外层类的显式授权（如友元声明）。
2. 外层类不能直接访问嵌套类的私有成员（除非嵌套类授权）。
3. 嵌套类的作用域限于外层类，避免全局命名污染。

典型场景

• 实现细节隐藏：将辅助类（如链表节点）隐藏在外层类内部。
• 迭代器模式：为容器类实现内部迭代器。

示例：链表实现中的嵌套类

class LinkedList {
public:
    LinkedList() : head(nullptr) {}
    
    void add(int value) {
        Node* newNode = new Node(value);
        newNode->next = head;
        head = newNode;
    }

    // 嵌套类定义
    class Iterator {
    public:
        Iterator(Node* ptr) : current(ptr) {}
        int operator*() { return current->data; }
        Iterator& operator++() { 
            current = current->next; 
            return *this;
        }
        bool operator!=(const Iterator& other) { 
            return current != other.current;
        }
    private:
        Node* current;
    };

    Iterator begin() { return Iterator(head); }
    Iterator end() { return Iterator(nullptr); }

private:
    // 嵌套类声明（需在外层类前声明）
    struct Node {
        int data;
        Node* next;
        Node(int d) : data(d), next(nullptr) {}
    };

    Node* head;
};

// 使用示例
LinkedList list;
list.add(10);
list.add(20);
for (auto it = list.begin(); it != list.end(); ++it) {
    std::cout << *it << " "; // 输出: 20 10
}

二、局部类（Local Class）

定义：在函数内部定义的类，称为局部类。
特点：

1. 局部类的作用域仅限于定义它的函数内部。
2. 不能有静态成员变量（但可以有静态常量整型成员）。
3. 只能访问外层函数的 静态变量、枚举和类型别名，不能访问非静态局部变量。
4. 不能定义模板类。

典型场景

• 临时策略实现：在函数内部定义一次性使用的策略类。
• 简化接口：封装函数内部的复杂逻辑。

示例：函数内部的策略类

#include <iostream>

void processData(int x) {
    // 局部类定义
    class Squarer {
    public:
        int operator()(int val) {
            return val * val;
        }
    };

    Squarer sq;
    std::cout << "Square of " << x << " is " << sq(x) << std::endl;
}

int main() {
    processData(5); // 输出: Square of 5 is 25
    return 0;
}

三、关键区别与注意事项

注意事项

1. 嵌套类的前向声明：若嵌套类需要在外层类外部使用，需先在外层类中声明。
2. 局部类的限制：
   • 不能在函数外创建实例。
   • 无法捕获函数的局部变量（除非是静态的）。
3. 谨慎使用：过度使用可能降低代码可读性。

四、总结

• 嵌套类：用于逻辑紧密关联的类设计，隐藏实现细节。
• 局部类：用于函数内部的一次性封装，简化局部逻辑。

合理使用这两种特性可以提升代码的封装性和可维护性，但需避免滥用导致结构混乱。