c++嵌套类和局部类详细介绍

1️⃣ 嵌套类（Nested Class）

概念

嵌套类 是在一个类的内部定义的类，定义它的那个类称为 外部类（Enclosing Class）。嵌套类在逻辑上是外部类的成员，但它有自己独立的作用域和访问控制。

---

语法形式

cpp

运行

class OuterClass {
public:
    // 嵌套类
    class InnerClass {
    public:
        void display();
    };
};

---

特点

1. 作用域 ：
   • 嵌套类的名字只在外部类作用域内可见。
   • 在外部使用时需要加外部类名限定：OuterClass::InnerClass。
2. 访问权限 ：
   • 外部类和嵌套类之间默认互相不能访问对方的私有成员（除非显式声明友元）。
   • 嵌套类可以直接访问外部类的 static 成员（如果权限允许）。
3. 生命周期 ：
   • 嵌套类对象的生命周期独立于外部类对象。

---

案例代码

cpp

运行

#include <iostream>
using namespace std;

class OuterClass {
private:
    int outerData = 100;
public:
    static int staticOuterData;

    // 嵌套类
    class InnerClass {
    private:
        int innerData = 200;
    public:
        void showOuterStatic() {
            // 可以直接访问外部类的静态成员
            cout << "Outer static data: " << staticOuterData << endl;
        }

        void showInner() {
            cout << "Inner data: " << innerData << endl;
        }
    };
};

// 初始化外部类静态成员
int OuterClass::staticOuterData = 50;

int main() {
    // 创建嵌套类对象（需要外部类名限定）
    OuterClass::InnerClass innerObj;

    innerObj.showOuterStatic(); // 访问外部类静态成员
    innerObj.showInner();       // 访问嵌套类自己的成员

    return 0;
}

运行结果：

plaintext

Outer static data: 50
Inner data: 200

---

2️⃣ 局部类（Local Class）

概念

局部类 是在函数体内定义的类，它的作用域仅限于该函数内部。

---

语法形式

cpp

运行

void someFunction() {
    class LocalClass {
    public:
        void doSomething();
    };
}

---

特点

1. 作用域 ：
   • 仅在定义它的函数内可见，出了函数作用域就不能使用。
2. 成员函数 ：
   • 必须在类体内定义（不能在类外定义）。
3. 静态成员 ：
   • 不能有静态成员变量（因为静态成员需要类外定义，而局部类作用域不允许）。
4. 访问外部变量 ：
   • 可以访问外部作用域的静态变量 和枚举常量。
   • 不能访问函数的非静态局部变量（除非是 C++11 捕获的 lambda，而局部类本身不支持捕获）。

---

案例代码

cpp

运行

#include <iostream>
using namespace std;

void testLocalClass() {
    static int staticVar = 10; // 静态局部变量
    int normalVar = 20;        // 普通局部变量

    // 局部类
    class LocalClass {
    public:
        void print() {
            cout << "Static var: " << staticVar << endl; // ✅ 可以访问静态变量
            // cout << normalVar << endl; // ❌ 不能访问非静态局部变量
        }
    };

    LocalClass obj;
    obj.print();
}

int main() {
    testLocalClass();

    // LocalClass obj2; // ❌ 错误：局部类在函数外部不可见
    return 0;
}

运行结果：

plaintext

Static var: 10

---

3️⃣ 对比总结

对比维度	嵌套类（Nested Class）	局部类（Local Class）
定义位置	类的内部	函数的内部
作用域	外部类作用域内	仅函数作用域内
访问外部成员	可访问外部类的 static 成员（需权限）	可访问函数的 static 变量和枚举
成员函数定义	可在类内或类外定义（类外需限定）	必须在类体内定义
静态成员变量	允许	不允许
使用场景	逻辑上属于外部类的辅助类，如迭代器	函数内临时使用的类，不暴露给外部

---

4️⃣ 记忆口诀

• 嵌套类：住在别人家里的类，只能通过 "门牌号（外部类名）" 找到它。
• 局部类：住在房间里的临时小纸条，出门就扔了，别人看不到。

📊 嵌套类作用域图

plaintext

全局作用域
┌─────────────────────────────────────────────────────────────┐
│ class OuterClass {                                         │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  public:                                           │    │
│  │      class InnerClass {                            │    │
│  │      public:                                       │    │
│  │          void display();                          │    │
│  │      };                                            │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                             │
│  // 外部类成员                                             │
│  void useInner() { InnerClass obj; }                       │
└─────────────────────────────────────────────────────────────┘

可见范围（嵌套类）：
- 在 OuterClass 内部：可以直接用 InnerClass
- 在外部类外部：必须用 OuterClass::InnerClass

箭头示意：

plaintext

main() 中:
    OuterClass::InnerClass obj;  ← 可以（需限定作用域）
    InnerClass obj2;             ← ❌ 错误（找不到名字）

---

📊 局部类作用域图

plaintext

全局作用域
┌─────────────────────────────────────────────────────────────┐
│ void someFunction() {                                      │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  class LocalClass {                                 │    │
│  │  public:                                            │    │
│  │      void doSomething();                            │    │
│  │  };                                                 │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                             │
│  LocalClass obj; // ✅ 可以使用                              │
└─────────────────────────────────────────────────────────────┘

可见范围（局部类）：
- 仅在 someFunction() 内部可见
- 函数外完全不可见

箭头示意：

plaintext

main() 中:
    LocalClass obj;  ← ❌ 错误（局部类作用域仅限函数内）

程序源码如下：

#include "head.h"
#include "function.h"

/*
	嵌套类
*/
class OuterClass {
	
//成员变量
private:
	int outerDate = 100;
public:
	static int staticOuterDate;

	//嵌套类
	class InnerClass {
	private:
		int innerPrivateData = 200;
	public:
		int innerPublicDate = 100;
	public:
		void showOuterStatic() {
			//可以直接访问外部类的静态成员
			cout << "Outer static data:" << staticOuterDate << endl;
		
			//不能访问外部类的非静态成员
			//cout << "Outer data:" << outerDate << endl;
		}
		
		void showInner() {
			cout << "Inner data:" << innerPrivateData << endl;
		}
	};

	//成员方法
public:
	void printInfo() {
		cout << this->outerDate << endl
			<< this->staticOuterDate << endl;
		
	}
};

//初始化外部类的静态成员
int OuterClass::staticOuterDate = 50;

/*
	局部类
*/
void testLocalClass() {

	static int staticVar = 10;	//静态局部变量
	int normalVar = 20;	//普通局部变量

	//局部类
	class LocalClass {
	public:
		void print() {
			//可以访问静态变量
			cout << "static var:" << staticVar << endl;

			//不能访问非静态局部变量
			//cout << normalVar << endl;
		}
	};

	//实例化局部类
	LocalClass obj;
	obj.print();
}

/*
	测试函数方法
*/
//外部类测试函数
void testOuterClass() {
	//外部类的使用
	OuterClass oc;
	oc.printInfo();
	cout << "oc.staticOuterDate:" << oc.staticOuterDate << endl;
	
	//创建嵌套类对象（需要外部类名限定）
	OuterClass::InnerClass innerObj;
	
	innerObj.showOuterStatic();	//访问外部类静态成员
	innerObj.showInner();	//访问嵌套类自己的成员
}

//局部类测试方法


int main() {

	//testOuterClass();

	testLocalClass();

	//错误：局部类在函数外部不可见
	//LocalClass obj2;

	return 0;
}