目录
（一）封装
1.1 封装的意义：
意义一：在设计类的时候，属性和行为写在一起，表现事物
意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制
1.2 struct和class区别
1.3 成员属性设置为私有
（二）对象的初始化和清理
2.1 构造函数和析构函数
2.2 构造函数的分类及调用
两种分类方式
三种调用方式
匿名对象：
2.3 拷贝构造函数调用时机
2.4 构造函数调用规则
2.5 深拷贝与浅拷贝
2.6 初始化列表
2.7 类对象作为类成员
2.8 静态成员
C++面向对象的三大特性为：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
例如：
人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…
车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类
（一）封装
1.1 封装的意义：
- 将属性和行为作为一个整体，表现生活中的事物
- 将属性和行为加以权限控制
意义一：在设计类的时候，属性和行为写在一起，表现事物
语法： class 类名{ 访问权限： 属性 / 行为 };
class 类名称
{
public:
公有成员（外部接口）
private:
私有成员
protected:
保护型成员
}；
示例：定义了一个表示圆的类 Circle，并计算其周长。
类 Circle：
属性：m_r 表示圆的半径。（变量）
行为：calculateZC() 方法计算并返回圆的周长，公式为 2×π×r（函数）
#include <iostream>
using namespace std;
//圆周率
const double PI = 3.14; // 定义常量 PI，值为 3.14，用于后续计算圆的周长
//封装一个圆类，求圆的周长
class Circle // 定义一个名为 Circle 的类
{
public: // 访问权限，以下成员可以被外部访问
//属性
int m_r; // 圆的半径属性
//行为
double calculateZC() // 定义计算周长的方法
{
return 2 * PI * m_r; // 计算并返回圆的周长
}
};
int main() {
//通过圆类，创建圆的对象
Circle c1; // 创建 Circle 类的对象 c1
c1.m_r = 10; // 给圆对象 c1 的半径赋值为 10
cout << "圆的周长为： " << c1.calculateZC() << endl; // 调用 calculateZC() 方法输出圆的周长
system("pause");
return 0;
}
实例化：通过一个类，创建一个对象的过程
示例2：设计一个学生类，属性有学号姓名，可以给姓名学号赋值，显示姓名学号
#include <iostream>
#include <string>
using namespace std;
// 学生类
class Student
{
private:
int studentID; // 学号
string studentName; // 姓名
public:
// 设置学号和姓名
void setDetails(int id, const string& name) {
studentID = id;
studentName = name;
}
// 显示
void displayDetails() const {
cout << "学号: " << studentID << ", 姓名: " << studentName << endl;
}
};
int main() {
Student s1; // 创建 Student 类的对象 s1
s1.setDetails(1001, "张三"); // 设置学号和姓名
s1.displayDetails(); // 显示学号和姓名
system("pause");
return 0;
}
类中的属性和行为——成员
属性——成员属性、成员变量
行为——成员函数、成员方法
意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
- public 公共权限（ 【同一类的成员】类内可以访问 类外可以访问）
- protected 保护权限（ 类内可以访问 类外不可以访问）
- private 私有权限（类内可以访问 类外不可以访问）
保护权限VS私有权限
- 保护权限 适用于需要在继承中共享的成员，允许子类访问
- 私有权限 则用于完全封闭的访问，确保即使是子类也无法直接访问这些属性
#include <iostream>
#include <string>
using namespace std;
class Person
{
public:
string m_Name; // 姓名，公共权限
protected:
string m_Car; // 汽车，保护权限
private:
int m_Password; // 银行卡密码，私有权限
public:
// 类内可以访问
void func()
{
m_Name = "张三"; // 可以访问和修改公共属性
m_Car = "拖拉机"; // 可以访问保护属性
m_Password = 123456; // 可以访问私有属性
}
};
int main()
{
Person p;
p.m_Name = "李四"; // 可以访问和修改公共属性
//类外不可以访问
// p.m_Car = "奔驰"; // 无法访问，保护属性
// p.m_Password = 123; // 无法访问，私有属性
system("pause");
return 0;
}
1.2 struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
区别：
-
struct 默认权限为公共public
通常用于表示简单的数据结构，主要包含数据而很少包含行为。适用于需要公开访问的数据。
-
class 默认权限为私有private
更常用于面向对象编程，通常包含数据和方法，强调封装、继承和多态等特性
#include <iostream>
using namespace std;
// 定义一个类 C1
class C1
{
// m_A 默认是私有权限
int m_A; // 只能在 C1 的成员函数内访问
public:
// 公共方法
void setA(int value)
{
m_A = value; // 可以访问私有属性
}
// 公共方法
int getA() const
{
return m_A; // 可以访问私有属性
}
};
// 定义一个结构体 C2
struct C2
{
// m_A 默认是公共权限
int m_A; // 可以直接在外部访问
};
int main()
{
// 创建 C1 的对象 c1
C1 c1;
c1.setA(10); // 通过公共方法设置 m_A
cout << "C1 的 m_A: " << c1.getA() << endl; // 输出 m_A
// 创建 C2 的对象 c2
C2 c2;
c2.m_A = 20; // 直接访问公共属性 m_A
cout << "C2 的 m_A: " << c2.m_A << endl;
system("pause");
return 0;
}
1.3 成员属性设置为私有
优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性
#include <iostream>
#include <string>
using namespace std;
// 定义 Person 类
class Person {
public:
// 姓名设置可读可写
void setName(string name) {
m_Name = name; // 设置姓名
}
string getName() {
return m_Name; // 获取姓名
}
// 获取年龄
int getAge() {
return m_Age; // 只读年龄
}
// 设置年龄
void setAge(int age) {
// 检查年龄是否合法
if (age < 0 || age > 150) {
cout << "无效的年龄" << endl; // 提示无效的年龄
return;
}
m_Age = age; // 设置年龄
}
// 设置偶像为只写
void setIdol(string idol) {
m_Idol = idol; // 设置偶像
}
private:
string m_Name; // 姓名，可读可写
int m_Age = 18; // 年龄，默认值为 18
string m_Idol; // 只写偶像
};
int main() {
Person p; // 创建 Person 对象 p
// 姓名设置
p.setName("张三");
cout << "姓名： " << p.getName() << endl; // 输出姓名
// 年龄设置
p.setAge(50);
cout << "年龄： " << p.getAge() << endl; // 输出年龄
// 设置偶像
p.setIdol("小米");
// cout << "偶像： " << p.getIdol() << endl; // 无法读取偶像，只能设置
system("pause");
return 0;
}（二）对象的初始化和清理
生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置
2.1 构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题： 一个对象或者变量没有初始状态，对其使用后果是未知；同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
编译器提供的构造函数和析构函数是空实现（里面没有代码）。
-
构造函数【初始化】：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
-
析构函数【清理】：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
构造函数： 类名(){}
-
没有返回值也不写void
-
函数名称与类名相同
-
重载：可以有参数，因此可以发生重载
-
自动调用：程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
析构函数： ~类名(){}
没有返回值也不写void
-
函数名称与类名相同,在名称前加上符号 ~
-
不可以有参数，因此不可以发生重载
-
程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
#include <iostream>
using namespace std;
class Person
{
public:
// 构造函数
Person()
{
cout << "Person的构造函数调用" << endl; // 当对象创建时调用
}
// 析构函数
~Person()
{
cout << "Person的析构函数调用" << endl; // 当对象销毁时调用
}
};
// 测试函数
void test01()
{
Person p; // 创建 Person 对象 p【局部变量，栈上数据】，自动调用构造函数
}
int main()
{
test01(); // 调用测试函数
//当 test01 函数执行完毕后，局部变量 p 的作用域结束，析构函数会被自动调用
system("pause");
return 0;
}
运行结果
若在 main 函数中直接创建对象
int main() {
Person p; // 在 main 函数中创建 Person 对象 p
// 析构函数将在 main 函数结束时调用
system("pause");
return 0;
}
Person 对象 p 是在 main 函数的栈上创建的。当 main 函数执行结束时，析构函数被自动调用。
2.2 构造函数的分类及调用
两种分类方式
按参数分为： 有参构造和无参构造
无参又称为默认构造函数
//无参（默认）构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a)
{
age = a;
cout << "有参构造函数!" << endl;
}按类型分为： 普通构造和拷贝构造
上面的代码都是普通的构造函数
//拷贝构造函数
Person(const Person& p)
{
age = p.age;
cout << "拷贝构造函数!" << endl;
}参数 const Person& p 是对Person 对象的引用，使用 const 修饰符表示不希望修改该对象
age = p.age; 将被拷贝对象的年龄属性复制到新对象中
三种调用方式
括号法； 显示法； 隐式转换法
括号法：直接使用函数名后跟括号，并在括号内传入参数。
显示法：直接通过对象调用其方法
隐式转换法：在函数调用中，编译器或解释器会自动将某种类型的数据转换为另一种类型以匹配函数的参数
#include <iostream>
using namespace std;
class Person {
public:
int age; // 年龄
Person() {// 无参（默认）构造函数
cout << "无参构造函数!" << endl;
}
Person(int a) {// 有参构造函数
age = a; // 初始化年龄
cout << "有参构造函数!" << endl;
}
// 拷贝构造函数
Person(const Person& p) {
age = p.age; // 复制年龄
cout << "拷贝构造函数!" << endl;
}
// 析构函数
~Person() {
cout << "析构函数!" << endl;
}
};
void test01()
{
Person p; // 创建对象 p，调用无参构造函数，不能加括号Person p2(); 被视为函数声明，而不是对象创建
}
// 调用有参构造函数和拷贝构造函数
void test02()
{
//括号法，常用
Person p0(10); // 调用有参构造函数，创建年龄为 10 的对象
Person p1(p0);// 调用拷贝构造函数，复制 p0 的年龄
// 显式法
Person p2 = Person(10); // 使用匿名对象创建 p2
Person p3 = Person(p2); // 调用拷贝构造函数，复制 p2 的年龄
// 隐式转换法
Person p4 = 10; // 隐式调用有参构造函数，创建 p4
Person p5 = p4; // 调用拷贝构造函数，复制 p4 的年龄
}
int main() {
test01(); // 测试无参构造函数
test02(); // 测试有参和拷贝构造函数
system("pause");
return 0;
}
运行结果
括号法：调用无参构造函数不能加括号
当调用无参构造函数时，直接写类名后跟变量名即可不能加上括号，否则编译器会将其解释为一个函数声明，而不是对象的创建。
// 正确的对象创建方式 Person p; // 创建对象 p，调用无参构造函数 // 错误的方式，会被视为函数声明 // Person p2(); // 这将被视为声明一个返回类型为 Person 的函数 p2，而不是创建对象
匿名对象：
指在创建时没有指定变量名的对象
如果将 Person(10) 单独写在一行中而不赋值给任何变量，它会创建一个匿名对象。这个对象在行结束后立即被析构。
#include <iostream>
using namespace std;
class Person {
public:
int age;
Person(int a) {
age = a;
cout << "有参构造函数, 年龄: " << age << endl;
}
~Person() {
cout << "析构函数!" << endl;
}
};
int main() {
// 创建匿名对象
Person(10); // 创建年龄为 10 的匿名对象，随后立即析构
cout << "aaa!" << endl;
return 0;
}
函数还没有运行完，匿名对象在行结束后会立即被析构，因为没有变量名来引用它
不能利用拷贝构造函数初始化匿名对象
使用拷贝构造函数来初始化匿名对象，编译器会将其解析为一个对象声明
编译器会认为
Person(p3) 等价 Person p3
2.3 拷贝构造函数调用时机
C++中拷贝构造函数调用时机通常有三种情况
-
使用一个已经创建完毕的对象来初始化一个新对象
//使用已存在的对象来初始化一个新对象
Person p1(10); // 创建对象 p1
Person p2(p1); // 调用拷贝构造函数，复制 p1
-
值传递的方式给函数参数传值
//当对象作为参数传递给函数，并且该参数是按值传递时，拷贝构造函数会被调用
void func(Person p) { } // 参数 p 将调用拷贝构造函数
func(p); // 传递 p，创建拷贝，两个p不是同一个p
-
以值方式返回局部对象
//当一个函数返回一个对象，并且返回类型是对象本身时，拷贝构造函数会被调用（
Person func() {
Person p; // 创建 p
return p; // 返回时调用拷贝构造函数
}
//现代 C++ 常常使用返回值优化（RVO）来避免这个过程值传递：函数参数以值的方式传递，会生成参数的副本，涉及拷贝构造
#include <iostream>
using namespace std;
class Person {
public:
// 无参构造函数
Person() {
cout << "无参构造函数!" << endl; // 创建对象时调用
mAge = 0;
}
// 有参构造函数
Person(int age) {
cout << "有参构造函数!" << endl;
mAge = age;
}
// 拷贝构造函数
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
mAge = p.mAge; // 复制年龄属性
}
// 析构函数
~Person() {
cout << "析构函数!" << endl; // 对象销毁前调用
}
public:
int mAge; // 年龄属性
};
// 1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person man(100); // 创建对象man，调用有参构造函数
Person newman(man); // 使用man初始化newman，调用拷贝构造函数
Person newman2 = man; // 另一种拷贝构造方式
// Person newman3; // 取消注释将演示无参构造
// newman3 = man; // 赋值操作，不调用拷贝构造函数，而是调用赋值运算符
}
// 2. 值传递的方式给函数参数传值
void doWork(Person p1) {} // p1是通过拷贝构造函数初始化的副本
void test02() {
Person p; // 创建对象p，调用无参构造函数
doWork(p); // 传递p，调用拷贝构造函数
}
// 3. 以值方式返回局部对象
Person doWork2() {
Person p1; // 创建局部对象p1，调用无参构造函数
cout << (int *)&p1 << endl;
return p1; // 返回局部对象，触发返回值的拷贝构造
}
void test03() {
Person p = doWork2(); // 复制返回的对象，调用拷贝构造函数
cout << (int *)&p << endl;
}
int main() {
// test01();
// test02();
test03();
system("pause");
return 0;
}
现代C++编译器会优化这个过程（返回值优化，RVO），直接构造返回值在目标对象的内存中，避免额外的拷贝，从而提高性能。
2.4 构造函数调用规则
默认情况下，c++编译器至少给一个类添加3个函数
1．默认构造函数(无参，函数体为空)
2．默认析构函数(无参，函数体为空)
3．默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
-
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
-
如果用户定义拷贝构造函数，c++不会再提供其他构造函数
#include <iostream>
using namespace std;
class Person
{
public:
// 无参（默认）构造函数
Person()
{
cout << "无参构造函数!" << endl; // 创建对象时调用
}
// 有参构造函数
Person(int a)
{
age = a; // 初始化年龄
cout << "有参构造函数!" << endl; // 创建对象时调用
}
// 拷贝构造函数
Person(const Person& p)
{
age = p.age; // 复制年龄
cout << "拷贝构造函数!" << endl; // 使用现有对象初始化新对象时调用
}
// 析构函数
~Person() {
cout << "析构函数!" << endl; // 对象销毁前调用
}
public:
int age; // 年龄属性
};
void test01()
{
Person p1(18); // 创建p1，调用有参构造函数
Person p2(p1); // 使用p1初始化p2，调用拷贝构造函数
cout << "p2的年龄为： " << p2.age << endl;
}
void test02()
{
// 如果用户提供有参构造，编译器不会提供默认构造，会提供拷贝构造
Person p1; // 创建p1，调用无参构造函数
Person p2(10); // 创建p2，调用有参构造函数
Person p3(p2); // 使用p2初始化p3，调用拷贝构造函数
// 如果用户提供拷贝构造，编译器不会提供其他构造函数
Person p4; // 创建p4，调用无参构造函数
Person p5(10); // 创建p5，调用有参构造函数
Person p6(p5); // 使用p5初始化p6，调用拷贝构造函数
}
int main()
{
test01();
// test02();
system("pause");
return 0;
}
2.5 深拷贝与浅拷贝
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
浅拷贝只复制对象的成员变量值（包括指针），但不为指针指向的动态内存创建新的副本。因此，两个对象会共享相同的动态内存，修改其中一个对象会影响另一个。
深拷贝不仅复制对象的成员变量值，还为指针指向的动态内存创建独立的副本。因此，两个对象完全独立，修改一个对象不会影响另一个。
#include <iostream>
using namespace std;
class Person {
public:
// 无参（默认）构造函数：当对象没有初始参数时调用
Person() {
cout << "无参构造函数!" << endl;
}
// 有参构造函数：用于对象的初始化（传入年龄和身高）
Person(int age, int height) {
cout << "有参构造函数!" << endl;
m_age = age;
// 在堆区动态分配内存来存储身高
m_height = new int(height);
}
// 拷贝构造函数：当用一个对象去初始化另一个对象时调用（如 `Person p2(p1);`）
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
// 如果使用浅拷贝，只会复制指针的地址，这可能导致多个对象指向同一块堆内存
// 这里使用深拷贝，重新在堆区分配内存，避免重复释放同一块内存
m_age = p.m_age;
m_height = new int(*p.m_height); // 深拷贝，复制内容而不是地址
}
// 析构函数：当对象生命周期结束时（如函数执行完毕）调用，释放动态分配的内存
~Person() {
cout << "析构函数!" << endl;
// 如果指针非空，释放堆区内存，防止内存泄漏
if (m_height != NULL) {
delete m_height;
}
}
public:
int m_age; // 年龄，普通成员变量
int* m_height; // 身高，指针，指向堆区动态分配的内存
};
// 测试函数
void test01() {
// 创建对象 p1，调用有参构造函数
Person p1(18, 180);
// 用 p1 初始化 p2，调用拷贝构造函数
Person p2(p1);
cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
2.6 初始化列表
C++提供了初始化列表语法，用来初始化属性。初始化列表是一种用于在构造函数中对类成员进行初始化的语法。它允许在对象的构造过程中直接对成员变量进行初始化，而不是在构造函数的主体中赋值。初始化列表通常在构造函数参数列表的后面，通过冒号 : 引入
语法：构造函数()：属性1(值1),属性2（值2）... {}
#include <iostream>
using namespace std;
class Person {
public:
// 传统方式初始化成员变量
/*
Person(int a, int b, int c) {
m_A = a; // 构造函数分配内存，赋值
m_B = b;
m_C = c;
}
*/
// 初始化列表方式初始化成员变量
Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c) {}
void PrintPerson() {
cout << "mA: " << m_A << endl;
cout << "mB: " << m_B << endl;
cout << "mC: " << m_C << endl;
}
private:
// 类的私有成员变量
int m_A;
int m_B;
int m_C;
};
int main() {
// 使用初始化列表方式构造对象 p
Person p(1, 2, 3);
// 对象 p 的成员变量
p.PrintPerson();
system("pause");
return 0;
}
2.7 类对象作为类成员
C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员
class A {}; // 定义一个空类 A
class B {
A a; // 在类 B 中定义 A 类型的成员变量 a
};
B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
#include <iostream>
#include <string>
using namespace std;
// 手机
class Phone
{
public:
// 构造函数，接受一个 string 类型的参数，用于初始化手机的名称
Phone(string name)
{
m_PhoneName = name;
cout << "Phone构造" << endl;
}
// 析构函数，在对象销毁时被调用
~Phone()
{
cout << "Phone析构" << endl;
}
// 手机的名称（成员变量）
string m_PhoneName;
};
// 人，包含一个 Phone 对象
class Person
{
public:
// 构造函数，使用初始化列表来初始化成员变量 m_Name 和 m_Phone
Person(string name, string pName) : m_Name(name), m_Phone(pName)
{
cout << "Person构造" << endl;
}
// 析构函数，在对象销毁时被调用
~Person()
{
cout << "Person析构" << endl;
}
// 成员函数，打印玩家的手机信息
void playGame()
{
cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
}
// 成员变量：玩家名字
string m_Name;
// 成员对象：Phone
Phone m_Phone;
};
void test01()
{
// 先调用 Phone 构造函数，再调用 Person 构造函数
Person p("张三", "苹果X");
p.playGame();
}
int main() {
test01();
system("pause");
return 0;
}
运行结果
先构造
Phone，再构造Person；析构时顺序相反当
Person对象被创建时，首先构造成员对象Phone，然后再构造Person本身。因为在 C++ 中，成员对象会在它们的外部类对象构造之前初始化（初始化列表中的m_Phone），保证成员在构造函数执行时已经被初始化
当类 B 中包含 A 类型的对象成员时，
构造顺序：
成员对象的构造顺序先于类本身的构造
在创建 B 对象时，B 的成员变量（也就是 A 类型的对象 a）会首先被构造，然后才会执行 B 的构造函数。
析构顺序：
类本身的析构先于成员对象的析构。
当 B 对象被销毁时，B 的析构函数会先被调用，然后再析构它的成员变量 a。
总结：
构造顺序：先构造成员
A，再构造B。析构顺序：先析构
B，再析构成员A。
2.8 静态成员
静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。静态成员（是属于类本身的，而不是属于类的某个特定对象。
静态成员分为：
静态成员变量
-
所有对象共享同一份数据
-
在编译阶段分配内存(全局区）
-
类内声明，类外初始化
#include <iostream>
using namespace std;
class Person
{
public:
// 静态成员变量声明（公有）
static int m_A;
private:
// 静态成员变量声明（私有）
static int m_B; // 静态成员变量可以有访问权限控制，m_B 为私有成员变量
};
// 静态成员变量在类外定义和初始化
int Person::m_A = 10;
int Person::m_B = 10;
void test01()
{
// 静态成员变量的两种访问方式
// 1. 通过对象访问静态成员变量
Person p1;
p1.m_A = 100; // 通过对象 p1 修改静态成员变量 m_A 的值
cout << "p1.m_A = " << p1.m_A << endl;
Person p2;
p2.m_A = 200; // 通过对象 p2 修改静态成员变量 m_A 的值
cout << "p1.m_A = " << p1.m_A << endl;
cout << "p2.m_A = " << p2.m_A << endl;
// 由于静态成员变量是所有对象共享的，因此修改一次会影响所有对象
// 2. 通过类名访问静态成员变量
cout << "通过类名访问 m_A = " << Person::m_A << endl;
// 访问私有静态成员变量 m_B 会报错，无法直接在类外访问
// cout << "m_B = " << Person::m_B << endl; // 私有静态成员变量 m_B 不能直接访问
}
int main() {
test01();
system("pause");
return 0;
}
对象
p1和p2共享静态成员变量m_A：当通过
p1将m_A设置为 100 后，修改了静态成员变量然后通过
p2将m_A设置为 200，结果p1的m_A也变成了 200，证明静态成员变量在所有对象中共享通过类名访问静态成员变量
m_A：通过
Person::m_A访问m_A时，发现值为 200，说明静态成员变量确实是全局唯一的
静态成员函数
-
所有对象共享同一个函数
-
静态成员函数只能访问静态成员变量
#include <iostream>
using namespace std;
class Person
{
public:
static void func() // 静态成员函数声明和定义
{
cout << "func调用" << endl;
m_A = 100; // 静态成员函数可以访问静态成员变量 m_A
// m_B = 100; // 错误：静态成员函数不能访问非静态成员变量 m_B
}
static int m_A; // 静态成员变量声明
int m_B; // 非静态成员变量声明
private:
// 静态成员函数也可以有访问权限控制，这里是私有的静态成员函数
static void func2() // 私有静态成员函数声明和定义
{
cout << "func2调用" << endl;
}
};
// 静态成员变量在类外定义和初始化
int Person::m_A = 10; // m_A 初始化为 10
void test01()
{
// 静态成员函数两种访问方式
// 1. 通过对象调用静态成员函数
Person p1;
p1.func(); // 通过对象 p1 调用静态成员函数 func
// 2. 通过类名调用静态成员函数
Person::func();
// 访问私有静态成员函数会报错，无法在类外访问
// Person::func2(); // 错误：私有静态成员函数不能在类外调用
}
int main() {
test01();
system("pause");
return 0;
}
p1.func()调用了静态成员函数func()，输出 "func调用"。Person::func()通过类名调用静态成员函数，再次输出 "func调用"私有静态成员函数未被调用：
func2()是一个静态成员函数，但由于它是私有的，不能在类外调用，因此没有输出 "func2调用"【访问权限】
