C++嵌套类[编辑 | 编辑源代码]

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

基本概念[编辑 | 编辑源代码]

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

嵌套类的主要特点包括：

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

语法格式[编辑 | 编辑源代码]

嵌套类的定义语法如下：

class OuterClass {
public:
    class NestedClass {
        // 嵌套类的成员定义
    };
};

嵌套类的访问权限[编辑 | 编辑源代码]

嵌套类的访问权限由外部类的访问修饰符决定：

如果嵌套类声明为`public`，则可以在外部类的外部直接使用。
如果嵌套类声明为`private`或`protected`，则只能在外部类或其派生类中使用。

示例：公共嵌套类[编辑 | 编辑源代码]

#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;
}

示例：私有嵌套类[编辑 | 编辑源代码]

私有嵌套类通常用于隐藏实现细节：

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;
}

嵌套类与外部类的关系[编辑 | 编辑源代码]

嵌套类和外部类的关系可以通过以下Mermaid类图表示：

访问外部类的成员[编辑 | 编辑源代码]

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

示例：

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;
}

实际应用场景[编辑 | 编辑源代码]

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

案例：链表实现[编辑 | 编辑源代码]

以下是一个使用嵌套类实现链表的例子：

#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;
}

嵌套类与友元关系[编辑 | 编辑源代码]

嵌套类可以声明为外部类的友元，从而访问其私有成员：

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;
}

总结[编辑 | 编辑源代码]

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

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