C++类和对象（上）

• 1.类的定义
• • 1.1类定义的格式
  • 1.2访问限定符
  • 1.3类域
• 2.实例化
• • 2.1实例化概念
• 3.this指针
• 4.类的默认成员函数
• 5.构造函数

1.类的定义

1.1类定义的格式

• class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者成员函数。
• 为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加_或者m开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。
• C++中struct也可以定义类，C++兼容C中struct的用法，同时struct升级成了类，明显的变化是struct中可以定义函数，⼀般情况下我们还是推荐用class定义类。
• 定义在类里面的成员函数默认为inline。

演示如下：

#include #include using namespace std; class Stack { public: 	// 成员函数 	void Init(int n = 4) 	{ 		array = (int*)malloc(sizeof(int) * n); 		if (nullptr == array) 		{ 			perror("malloc申请空间失败"); 			return; 		} 		capacity = n; 		top = 0; 	} 	void Push(int x) 	{ 		// ...扩容 		array[top++] = x; 	} 	int Top()//取栈顶元素 	{ 		assert(top > 0); 		return array[top - 1]; 	} 	void Destroy() 	{ 		free(array); 		array = nullptr; 		top = capacity = 0; 	} private: 	// 成员变量 	int* array; 	size_t capacity; 	size_t top;  }; // 分号不能省略  int main() { 	Stack st; 	st.Init(); 	st.Push(1); 	st.Push(2); 	cout << st.Top() << endl; 	st.Destroy(); 	return 0; }  

#include using namespace std; //这是在C语言中的写法 typedef struct ListNodeC { 	struct ListNodeC* next; 	int val; }LTNode; // 这是在C++中的写法，和C的区别是不再需要typedef，ListNodeCPP就可以代表类型 struct ListNodeCPP { 	void Init(int x) 	{ 		next = nullptr; 		val = x; 	} 	ListNodeCPP* next; 	int val; }; int main() { 	return 0; } 

1.2访问限定符

• C++⼀种实现封装的方式，用类将对象的属性与方法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的，以后继承章节才能体现出他们的区别。
• 访问权限作用域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为止，如果后面没有访问限定符，作⽤域就到大括号（}）即类结束。
• class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
• ⼀般成员变量都会被限制为private/protected，需要给别人使用的成员函数会放为public。

1.3类域

• 类定义了⼀个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 ：：作用域操作符指明成员属于哪个类域，不然编译器找不到函数，这也是前面[namespace]使用==：：==的原因。(https://blog.csdn.net/2301_81324046/article/details/140331094?spm=1001.2014.3001.5501)
• 类域影响的是编译的查找规则，下面程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪里，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

#include using namespace std; class Stack { public: 	// 成员函数 	void Init(int n = 4); private: 	// 成员变量 	int* array; 	size_t capacity; 	size_t top; }; // 声明和定义分离，需要指定类域 void Stack::Init(int n) { 	array = (int*)malloc(sizeof(int) * n); 	if (nullptr == array) 	{ 		perror("malloc申请空间失败"); 		return; 	} 	capacity = n; 	top = 0; } int main() { 	Stack st; 	st.Init(); 	return 0; }  

2.实例化

2.1实例化概念

• 用类类型在物理内存中创建对象的过程，称为类实例化出对象。
• 类是对象进行⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间。
• ⼀个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。打个比方：类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，设计图规划了有多少个房间，房间大小功能等，但是并没有实体的建筑存在，也不能住人，用设计图修建出房子，房子才能住人。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。

 #include using namespace std; class Date { public: 	void Init(int year, int month, int day) 	{ 		_year = year; 		_month = month; 		_day = day; 	} 	void Print() 	{ 		cout << _year << "/" << _month << "/" << _day << endl; 	} private: 	// 这⾥只是声明，没有开空间 	int _year; 	int _month; 	int _day; }; int main() { 	// Date类实例化出对象d1和d2 	Date d1; 	Date d2; 	d1.Init(2024, 3, 31); 	d1.Print(); 	d2.Init(2024, 7, 5); 	d2.Print(); 	return 0; } 

3.this指针

• Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这里就要看到C++给了⼀个隐含的this指针解决这里的问题。
• 编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)
• 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year;
• C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显示使用this指针。

#include using namespace std; class Date { public: 	// 这个和下面的等价void Init(Date* const this, int year, int month, int day) 	void Init(int year, int month, int day) 	{ 		// 编译报错：error C2106: “=”: 左操作数必须为左值，因为这里的this是一个指向当前对象的常量指针，不能被修改。 		 //this = nullptr; 		 //this->_year = year; 		_year = year; 		this->_month = month; 		this->_day = day; 	} 	void Print() 		 { 		cout << _year << "/" << _month << "/" << _day << endl; 	} private: 	// 这⾥只是声明，没有开空间 	int _year; 	int _month; 	int _day; }; int main() { 	// Date类实例化出对象d1和d2 	Date d1; 	Date d2; 	// d1.Init(&d1, 2024, 3, 31); 	d1.Init(2024, 3, 31); 	d1.Print(); 	d2.Init(2024, 7, 5); 	d2.Print(); 	return 0; } 

下面这个代码的运行结果是啥？
A.编译报错 B.运行崩溃 C.正常运行

#include using namespace std; class A { public: 	void Print() 	{ 		cout << "A::Print()" << endl; 	} private: 	int _a; }; int main() { 	A* p = nullptr; 	p->Print(); 	return 0; } 

答案是：正常运行
虽然 在这个里p 是一个指向类 A 的指针，并且被初始化为 nullptr，但是仍然调用了 p->Print()，很多人可能会觉得这里的p被初始化为nullptr了，所以这里的代码运行会报错，如果你是这样想那你就跳进这个大坑了，这里我虽然将p初始化为nullptr了，但是我并没有对p进行解引用操作，所以并没有什么大碍。程序照样能跑。

4.类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。

5.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。
简单来说构造函数就是对数据的初始化。

构造函数的特点：

1. 函数名与类名相同。
2. 无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
3. 对象实例化时系统会自动调用对应的构造函数。
4. 构造函数可以重载。
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数，⼀旦用户显式定义编译器将不再生成。
6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。
7. 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始
   化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。
   说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语言提供的原生数据类型，
   如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

#include using namespace std; class Date { public: 	// 1.⽆参构造函数 	Date() 	{ 		_year = 1; 		_month = 1; 		_day = 1; 	} 	// 2.带参构造函数 	Date(int year, int month, int day) 	{ 		_year = year; 		_month = month; 		_day = day; 	} 	// 3.全缺省构造函数 	Date(int year = 1, int month = 1, int day = 1) 	{ 	_year = year; 	_month = month; 	_day = day; 	} 	void Print() 	{ 		cout << _year << "/" << _month << "/" << _day << endl; 	 	} private: 	int _year; 	int _month; 	int _day; }; int main() { 	// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法区分这⾥是函数声明还是实例化对象 	Date d1; // 调⽤默认构造函数 	Date d2(2025, 1, 1); // 调⽤带参的构造函数 	 	Date d3(); 	d1.Print(); 	d2.Print(); 	return 0; }