C++类_嵌套类

C++嵌套类定义

在 C++11 中，嵌套类是在一个类（外围类）内部定义的另一个类。其语法和普通类定义类似，但作用域被限制在外围类内部。示例如下：

class Outer {class Inner {// Inner 类的成员和方法};
};

应用场景

封装实现细节

当一个类的实现依赖一些辅助类，且这些辅助类不应该被外部直接访问时，可将它们定义为嵌套类。例如，在实现一个链表类时，可将链表节点类定义为嵌套类，把节点的实现细节封装起来。

class LinkedList {
private:class Node {public:int data;Node* next;Node(int value) : data(value), next(nullptr) {}};Node* head;// 链表操作方法
};

逻辑分组

如果某些类在逻辑上紧密相关，将它们组织成嵌套类能使代码结构更清晰，便于理解和维护。例如，一个图形绘制类可能需要不同类型的图形元素类，将这些图形元素类定义为该图形绘制类的嵌套类。

实现策略模式

在策略模式中，可将不同的策略类定义为一个上下文类的嵌套类，把策略类的实现与上下文类紧密关联，同时对外隐藏策略类的具体实现。

注意事项

作用域

嵌套类的作用域被限制在外围类内部，创建嵌套类的对象时，需使用完整的作用域限定符。例如：

Outer::Inner innerObj;

访问权限

嵌套类和外围类的成员访问权限遵循 C++ 的访问控制规则，具体如下：

• 嵌套类访问外围类成员：
  • 静态成员：嵌套类可以直接访问外围类的静态成员（静态变量和静态函数），因为静态成员属于类本身，不依赖于对象实例。示例代码如下：

#include <iostream>class Outer {
private:static int staticVar;
public:class Inner {public:void accessStatic() {std::cout << "Outer's static variable: " << staticVar << std::endl;}};
};int Outer::staticVar = 20;int main() {Outer::Inner inner;inner.accessStatic();return 0;
}

• 非静态成员：嵌套类不能直接访问外围类的非静态成员，若要访问，需通过外围类的对象指针或引用。示例代码如下：

#include <iostream>class Outer {
private:int nonStaticVar = 10;
public:class Inner {public:void accessNonStatic(Outer& outer) {std::cout << "Outer's non - static variable: " << outer.nonStaticVar << std::endl;}};
};int main() {Outer outer;Outer::Inner inner;inner.accessNonStatic(outer);return 0;
}

• 外围类访问嵌套类成员：
  • 外围类对嵌套类成员的访问遵循嵌套类自身的访问控制规则（public、protected、private）。如果嵌套类成员是 public 的，外围类可以直接访问；若为 protected 或 private，则需要满足相应的访问条件（如友元关系）。示例代码如下：

#include <iostream>class Outer {class Inner {public:int publicVar = 30;private:int privateVar = 40;};Inner inner;
public:void accessInnerPublic() {std::cout << "Inner's public variable: " << inner.publicVar << std::endl;// 无法直接访问 Inner 的 private 成员// std::cout << "Inner's private variable: " << inner.privateVar << std::endl; }
};int main() {Outer outer;outer.accessInnerPublic();return 0;
}

内存管理

嵌套类对象的生命周期和内存管理与普通类对象一样，要确保正确地创建和销毁对象，避免内存泄漏。如果在堆上创建嵌套类对象，需要使用 delete 手动释放内存。

举例

以下是一个使用嵌套类实现简单栈的完整示例：

使用嵌套类实现栈的 C++ 代码
 

#include <iostream>class Stack {
private:class Node {public:int data;Node* next;Node(int value) : data(value), next(nullptr) {}};Node* top;public:Stack() : top(nullptr) {}// 入栈操作void push(int value) {Node* newNode = new Node(value);newNode->next = top;top = newNode;}// 出栈操作void pop() {if (top != nullptr) {Node* temp = top;top = top->next;delete temp;}}// 获取栈顶元素int peek() {if (top != nullptr) {return top->data;}return -1; // 假设栈为空时返回 -1}// 判断栈是否为空bool isEmpty() {return top == nullptr;}// 析构函数，释放栈内存~Stack() {while (top != nullptr) {pop();}}
};int main() {Stack stack;stack.push(10);stack.push(20);std::cout << "Top element: " << stack.peek() << std::endl;stack.pop();std::cout << "Top element after pop: " << stack.peek() << std::endl;return 0;
}    

在这个示例中，Node 类作为 Stack 类的嵌套类，用于表示栈中的节点。Stack 类通过操作 Node 对象来实现栈的基本操作，如入栈、出栈、获取栈顶元素等。同时，在 Stack 类的析构函数中，会正确释放栈占用的内存，避免内存泄漏。