编辑“︁C++ 嵌套类”︁

= C++嵌套类 =

'''嵌套类'''（Nested Class）是C++面向对象编程中的一个重要特性，它允许在一个类的内部定义另一个类。嵌套类可以增强代码的封装性和组织性，适用于需要将逻辑相关的类组合在一起的场景。本文将详细介绍嵌套类的语法、特性、使用场景及实际案例。

== 基本概念 ==

嵌套类是指在一个类（称为'''外部类'''）内部定义的类（称为'''内部类'''或'''嵌套类'''）。嵌套类的作用域仅限于外部类，但可以通过访问修饰符（如`public`、`private`或`protected`）控制其可见性。

嵌套类的主要特点包括：
* 嵌套类可以访问外部类的静态成员和类型定义（如`typedef`或`using`）。
* 嵌套类的成员函数不能直接访问外部类的非静态成员，除非通过外部类的对象或指针。
* 嵌套类可以像普通类一样定义成员变量、成员函数和构造函数。

=== 语法格式 ===
嵌套类的定义语法如下：
<syntaxhighlight lang="cpp">
class OuterClass {
public:
    class NestedClass {
        // 嵌套类的成员定义
    };
};
</syntaxhighlight>

== 嵌套类的访问权限 ==

嵌套类的访问权限由外部类的访问修饰符决定：
* 如果嵌套类声明为`public`，则可以在外部类的外部直接使用。
* 如果嵌套类声明为`private`或`protected`，则只能在外部类或其派生类中使用。

=== 示例：公共嵌套类 ===
<syntaxhighlight lang="cpp">
#include <iostream>

class Outer {
public:
    class Inner {
    public:
        void display() {
            std::cout << "Inner class method called." << std::endl;
        }
    };
};

int main() {
    Outer::Inner innerObj;
    innerObj.display(); // 输出: Inner class method called.
    return 0;
}
</syntaxhighlight>

=== 示例：私有嵌套类 ===
私有嵌套类通常用于隐藏实现细节：
<syntaxhighlight lang="cpp">
class Outer {
private:
    class Inner {
    public:
        void secretMethod() {
            std::cout << "This is a private nested class method." << std::endl;
        }
    };

public:
    void useInner() {
        Inner innerObj;
        innerObj.secretMethod(); // 仅在 Outer 类内部可访问
    }
};

int main() {
    Outer outerObj;
    outerObj.useInner(); // 输出: This is a private nested class method.
    return 0;
}
</syntaxhighlight>

== 嵌套类与外部类的关系 ==

嵌套类和外部类的关系可以通过以下Mermaid类图表示：
<mermaid>
classDiagram
    class Outer {
        +Inner inner
    }
    class Inner {
        +display()
    }
    Outer --> Inner : contains
</mermaid>

=== 访问外部类的成员 ===
嵌套类不能直接访问外部类的非静态成员，但可以通过以下方式间接访问：
1. 将外部类的对象或指针传递给嵌套类。
2. 在嵌套类中保存外部类的引用或指针。

示例：
<syntaxhighlight lang="cpp">
class Outer {
private:
    int outerData = 10;

public:
    class Inner {
    private:
        Outer* outerPtr;

    public:
        Inner(Outer* outer) : outerPtr(outer) {}
        void showOuterData() {
            std::cout << "Outer data: " << outerPtr->outerData << std::endl;
        }
    };

    Inner createInner() {
        return Inner(this);
    }
};

int main() {
    Outer outerObj;
    Outer::Inner innerObj = outerObj.createInner();
    innerObj.showOuterData(); // 输出: Outer data: 10
    return 0;
}
</syntaxhighlight>

== 实际应用场景 ==

嵌套类常用于以下场景：
1. '''实现设计模式'''：如工厂模式中的具体产品类。
2. '''隐藏实现细节'''：如STL中`std::list`的迭代器实现。
3. '''逻辑分组'''：将紧密相关的类组织在一起。

=== 案例：链表实现 ===
以下是一个使用嵌套类实现链表的例子：
<syntaxhighlight lang="cpp">
#include <iostream>

class LinkedList {
private:
    class Node {
    public:
        int data;
        Node* next;
        Node(int val) : data(val), next(nullptr) {}
    };

    Node* head;

public:
    LinkedList() : head(nullptr) {}
    void append(int val) {
        Node* newNode = new Node(val);
        if (!head) {
            head = newNode;
            return;
        }
        Node* temp = head;
        while (temp->next) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
    void print() {
        Node* temp = head;
        while (temp) {
            std::cout << temp->data << " ";
            temp = temp->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    LinkedList list;
    list.append(1);
    list.append(2);
    list.append(3);
    list.print(); // 输出: 1 2 3
    return 0;
}
</syntaxhighlight>

== 嵌套类与友元关系 ==

嵌套类可以声明为外部类的友元，从而访问其私有成员：
<syntaxhighlight lang="cpp">
class Outer {
private:
    int secret = 42;

public:
    class Inner {
    public:
        static void revealSecret(Outer& outer) {
            std::cout << "The secret is: " << outer.secret << std::endl;
        }
    };
    friend class Inner; // 声明 Inner 为友元类
};

int main() {
    Outer outerObj;
    Outer::Inner::revealSecret(outerObj); // 输出: The secret is: 42
    return 0;
}
</syntaxhighlight>

== 总结 ==

* 嵌套类增强了代码的封装性和模块化。
* 嵌套类的作用域受外部类控制，可通过访问修饰符限制其可见性。
* 嵌套类常用于实现设计模式或隐藏复杂实现细节。

通过合理使用嵌套类，可以编写出更清晰、更易维护的C++代码。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象基础]]