C++类与对象：静态成员、友元及内部类核心机制详解

唐可

发布时间：2026-10-16| 6人浏览过

原创

在C++面向对象编程中，合理运用静态成员、友元及内部类能够优化数据共享与控制访问权限。本文将深入解析这三者的语法规范、访问限制及具体代码实现，帮助开发者掌握更精细的类设计技巧。

静态成员的共享与访问机制

静态成员（Static Members）包括静态成员变量和静态成员函数。其核心特征在于属于整个类而非某个特定对象，所有实例共享同一份内存空间。相比全局变量，静态成员具有更好的封装性和命名空间管理能力。

第1步：理解静态成员变量的定义与初始化

目的：掌握如何在类外正确初始化静态变量，避免编译错误。

声明位置：在类内使用 static 关键字声明。
初始化位置：必须在类外进行定义和初始化，且定义时不加 static 关键字。
内存分配：在编译阶段分配内存，生命周期贯穿程序运行始终。

class Person {
public:
	static int m_A; // 类内声明
private:
	static int m_B; // 私有静态成员同样需类外初始化
};

// 类外初始化
int Person::m_A = 10;
int Person::m_B = 10;

第2步：掌握两种访问方式

目的：学会通过对象或类名直接访问静态成员。

通过对象访问：obj.static_member。适用于需要显式指定实例的场景，但需注意修改的是共享数据。
通过类名访问：ClassName::static_member。这是更推荐的写法，强调该成员属于类本身。

void testAccess() {
	Person p1;
	// 方式1：通过对象
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl; 

	// 方式2：通过类名
	cout << "m_A = " << Person::m_A << endl;
}

第3步：静态成员函数的限制

目的：理解为何静态函数无法访问非静态成员。

无 this 指针：静态成员函数不与任何具体对象绑定，因此不存在隐含的 this 指针。
访问范围：只能访问类中的静态成员变量，不能访问非静态成员变量或非静态成员函数。
访问权限：静态成员函数也有 public/private/protected 权限控制。

class Person {
public:
	static void func() {
		cout << "func调用" << endl;
		m_A = 100; // OK，访问静态成员
		// m_B = 100; // Error，不可访问非静态成员
	}
	static int m_A;
	int m_B; 
};

void testFunc() {
	Person p1;
	p1.func();       // 通过对象调用
	Person::func();  // 通过类名调用
}

第4步：C++11 内的初始化新玩法

在 C++11 标准中，允许在类内为非静态成员变量提供默认初始值（除静态成员外），使代码更简洁。注意静态成员仍需类外初始化。

class A {
public:
	void Print() {
		cout << a << endl;
		cout << b._b << endl;
	}
private:
	int a = 10;         // C++11 类内初始化
	B b = 20;           // 支持隐式转换
	static int n;       // 静态成员仍需类外定义
};
int A::n = 0;

实战示例：统计类对象创建数量

利用静态成员变量可跨构造拷贝过程保持计数的特性，实现统计功能：

class A {
public:
	A() { ++_count1; }                     // 默认构造计数
	A(const A& aa) { ++_count2; }          // 拷贝构造计数
	
	static int GetCount1() { return _count1; }
	static int GetCount2() { return _count2; }

private:
	static int _count1;
	static int _count2;
};
int A::_count1 = 0;
int A::_count2 = 0;

// 使用场景
int main() {
	A a1;
	A a2(a1); // 触发拷贝构造
	cout << A::GetCount1() << endl; // 输出：1
	cout << A::GetCount2() << endl; // 输出：1
	return 0;
}

友元机制：突破访问限制的桥梁

当需要让类外的特定函数或类访问私有（private）成员时，友元（Friend）是标准解决方案。关键在于使用 friend 关键字声明。

第1步：全局函数作友元

将普通全局函数声明为类的友元，使其能访问该类的私有成员。

class Building {
	friend void goodGay(Building* building);
public:
	Building() {
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

void goodGay(Building* building) {
	cout << building->m_BedRoom << endl; // 成功访问私有成员
}

第2步：类作友元

一个类的所有成员函数都可以成为另一个类的友元。需注意友元关系的特点：

单向性：A是B的友元不代表B是A的友元。
非传递性：若B是A的友元，C是B的友元，C不一定是A的友元。

class Building; // 前置声明
class goodGay {
public:
	goodGay();
	void visit();
private:
	Building* building;
};

class Building {
	friend class goodGay; // 声明goodGay类为友元
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

void goodGay::visit() {
	cout << building->m_BedRoom << endl; // 可访问私有成员
}

第3步：成员函数作友元

仅将某个类的特定成员函数设为友元，实现更细粒度的权限控制。

class Building;
class goodGay {
public:
	void visit();   // 希望成为友元的函数
	void visit2();  // 非友元函数
};

class Building {
	friend void goodGay::visit(); // 仅visit成为友元
public:
	string m_SittingRoom;
private:
	string m_BedRoom;
};

void goodGay::visit() {
	cout << m_BedRoom << endl; // OK
}
void goodGay::visit2() {
	// cout << m_BedRoom << endl; // Error，无权访问
}

内部类：独立的嵌套实体

定义在另一个类内部的类称为内部类。它不同于静态成员或友元，是一个完全独立的类实体。

核心特性与访问规则

独立性：内部类不属于外部类，不能通过外部类的对象去调用内部类，需单独实例化如 A::B bb;。
天然友元：内部类自动拥有访问外部类所有成员（含 private/protected）的权限，反之不成立。
定义位置：可定义在外部类的 public、protected 或 private 区域，但这不影响其作为友元的本质。
Sizeof 计算：sizeof(ExternalClass) 不包含内部类的大小，两者内存布局独立。

class A {
private:
	static int k;
	int h;
public:
	class B { // 内部类
	public:
		void foo(const A& a) {
			cout << k << endl;   // OK，访问静态成员
			cout << a.h << endl; // OK，访问私有成员
		}
	};
};

int A::k = 1;

int main() {
	A aa;
	A::B bb; // 正确实例化内部类
	// bb.foo(aa);
	return 0;
}

以上就是C++类与对象中静态成员、友元及内部类核心机制的详细内容，更多关于C++高级类设计的资料请关注本站其它相关文章！