C++初阶语法——类和对象

前言：C语言中的结构体，在C++有着更高位替代者——类。而类的实例化叫做对象。
本篇文章不定期更新扩展后续内容。

一.面向过程和面向对象初步认识

在学习C语言的时候，我就时常听说过面向过程和面向对象，但是对这两个概念的认知非常模糊，那么这两者有什么区别呢？

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
而C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。我们不需要关注过程是怎么完成的，我们只需要关注对象间的交互。
面向对象有3大特性——封装，继承，多态。

二.类

1.C++中的结构体

C语言中结构体中只能定义变量，而在C++中，结构体中不仅能定义变量，还可以定义函数（struct升级成了类）。

以数据结构——栈为例：
直接在结构体内定义函数。
实例化对象时，无需再写struct，只需写结构体名。

#include<iostream>
using namespace std;
typedef struct Stack {
	int* a;
	int capacity;
	int top;
	void Init()   //定义函数
	{
		a = nullptr;
		capacity = 0;
		top = 0;
	}
}ST;
int main()
{
	Stack s1; // 无struct
	s1.Init();
	return 0;
}

2.类的定义

在C++中，类更喜欢用class而非struct。
这两者在默认访问限定上有些区别，struct默认为public，而class默认为private，更符合面向对象的要求。这也是为什么更喜欢使用class。该点在下文默认访问限定符也会讲解。

class Classname
{
	//类体：成员函数+成员变量

};  //跟结构体一样有分号不要忘

class为定义类的关键字，Classname为类名，{}中为类的主体，类体中的内容称为类的成员，类中的变量称为类的属性或成员变量，类中的函数称为类的方法或成员函数。

类的两种定义方式

一种就是向上面的栈一样将函数声明定义都写在类里面，值得一提的是，这种函数会被编译器当成内联函数。
还有一种就是将类声明放在头文件中，在源文件中定义函数，但是需要注意的是，成员函数名前需要加类名::（域作用限定符），一般第二种用的更多。

//obj.h
#include<iostream>
using namespace std;

typedef struct Stack {
	int* a;
	int capacity;
	int top;
	void Init();
}ST;

//test.cpp
#include"obj.h"
void Stack::Init()  // 类名::
{
	a = nullptr;
	capacity = top = 0;
}

3.类的访问限定符及封装

C++实现封装的方式：用类将对象的属性(成员变量)和方法(成员函数)结合在一起，让对象更加完善，通过访问限定符选择性的将其接口提供给外部的用户使用。

共有3种访问限定符：在诸如php，java等语言中都有。

访问限定符说明

利用好访问限定符，可以有效保护好类中的数据，防止其他人随便访问。
1.public:公有的类成员可以在任何地方被访问。
protect：受保护的类成员则可以被其自身以及其子类和父类访问。
private：私有的类成员则只能被其定义所在的类访问。
（在学继承之前，protect和private使用起来没差）
2.struct默认为public，class默认为private。
3.访问权限作用域从该访问限定符开始到下一个访问限定符出现。
4.如果后面没有访问限定符，作用域到 } 为止。
5.一般情况下，成员变量都设置为private。

以日期类为例：

class Date {
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;  //声明，没有定义，不占空间
	int _month;
	int _day;
};

4.类的实例化

用类创建对象的过程，叫做类的实例化。
1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
2.一个类可以实例化出多个对象。实例化出的对象才占用实际的内存空间，且只存储成员变量，不存储成员函数。

以日期类为例：

class Date {
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;  //声明，没有定义，不占空间
	int _month;
	int _day;
};

int main()
{
	
	Date d1;  // 类的实例化
	Date d2, d3;  // 一个类可以实例化出多个对象
	//下面两行代码可行吗，为什么？
	//Date::_year = 1;  //并没有实例化对象，只是声明没有开空间，更不必说初始化了。
	//d1._year = 1; //实例化了呢？也不行，因为_year是私有成员变量，只能在Date类中更改。
	return 0;
}

对象只存储成员变量，不存储成员函数

上文说过，类的主体有两个：成员变量和成员函数。
但实际上实例化的对象中只存储成员变量，而成员函数存储在公共代码区。

请看下例代码（类的空间大小计算和结构体一样，遵循结构体内存对齐规则）：

class Date {
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;   //声明，没有定义，不占空间
	int _month;
	int _day;
};

int main()
{
	Date s1;
	cout << sizeof(Date) << endl;
	cout << sizeof(s1) << endl;
	return 0;
}

控制台输出如下：

可以发现，12是只计算成员变量得到的结果，因此可以得知对象中并不存储成员函数。

之所以这样是因为成员函数对每个对象都是一样的，其会被存储在公共代码区，这样不必要在每次实例化对象时都存储一次成员函数，大大提高了程序效率。

成员函数存储在公共代码区

请看如下代码，各位觉得能够运行成功吗？

class Example
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
	int _b;
};
int main()
{
	Example* s1 = nullptr;
	s1->Print();  //空指针指向？？？？
	return 0;
}

控制台显示如下：

运行成功了，为什么呢？上面不是空指针解引用问题吗，程序应该崩溃呀？
答：上面说过成员函数存储在公共代码区，直接向公共代码区call该函数的地址，不需要向对象s1中找东西，因此不会发生空指针解引用操作。

5.this指针

类的成员函数中都隐藏了一个this指针参数。
this在实参和形参位置不能显示写，但是可以在类里面显示的用。
this指针不可被更改.
this指针可以为空（就是上面成员函数存在公共代码区的例子）。
this指针存在栈帧里面。（不要误以为this存在对象中，this就是一个形参，跟普通形参一样存在栈帧里面）。

仍以日期类为例：

class Date {
public:
	//this在实参和形参中不能显示地写
	//在类中可以显示地用(没什么价值)
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	/*void Init(Date* const this ,int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}*/
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(2023, 8, 11); //d1.Init(&d1,2023,8,11);
	return 0;
}

三.六大默认成员函数

C++中有六个默认成员函数，我们不写的话，它们会自动生成。

1.构造函数

构造函数最便捷的地方就是自动调用，可以在我们忘了初始化的时候发挥作用。

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
其特征如下：
1.函数名和类名相同。
2.无返回值（不需要写void）。
3.对象实例化时编译器自动调用对应的构造函数。
4.构造函数可以重载。（可以写多个构造函数，提供多种初始化方式）

class Date {
public:
	//构造函数，函数名和类名相同。
	Date(int year = 1, int month = 1, int day = 1) //全缺省参数
	{
		cout << "Date()" << endl;  // 借此观察构造函数是否被调用
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023,8,11); // 对象实例化时自动调用构造函数，一定记住！！！ 实参可以任意更改
	//在对象d1后面接实参是构造函数的特殊的初始化规则。 
	//Date d2(); //不可以在对象后加括号而不给实参，因为编译器分不清你是在创建对象还是调用函数。
	return 0;
}

控制台输出如下：可以看到，我们并没有调用Date函数，Date函数在对象实例化时自动调用了。

构造函数特点

构造函数，是默认成员函数之一，我们不写，编译器也会自动生成。
编译生成的默认构造函数的特点：
1.我们写了就不会自动生成了，我们不写编译器会自动生成一个无参的默认构造函数。
2.内置类型不会处理（C++11，支持声明时给缺省值，但是有了缺省值就会处理）
3.自定义类型的成员才会处理，会去调用这个成员的默认构造函数。（注意是默认构造函数，而非是构造函数）

（内置类型就是诸如int，double这种语言提供的类型，而自定义类型就是我们自己定义的类型，比如上文的Date。
需要注意的是：int* 是内置类型，Date* 也是内置类型。只要是指针就是内置类型）

默认构造函数

ps：这个地方刚开始学的时候理解起来挺难的，我被绕的晕头转向的。还是要多学多看代码啊。

切不可认为只有编译器自动生成的才是默认构造函数。 无参的构造函数和全缺省的构造函数（此两者都是我们自己写的）都被称为默认构造函数，并且默认构造函数只能有一个。
共有3种默认构造函数：
1.无参的构造函数
2.全缺省的构造函数
3.我们没写编译器自动生成的构造函数。
总结：这3种默认构造函数有一个共同点，就是不传参就可以调用。
多个默认构造函数同时存在会有歧义。

如下图所示，编译器就会显示无默认构造函数。

而将Date写成全缺省就可以正常运行（对应上文的全缺省的构造函数是默认构造函数）

·总结：一般情况下都需要我们自己写构造函数，决定初始化方式。而成员变量全是自定义类型时，可以考虑不写构造函数。

初始化列表（超链接）

2.析构函数

析构函数：与构造函数的作用相反，析构函数不是完成对对象本身的销毁，局部对象的销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作（malloc，realloc出来的空间等）。
析构函数的特性：
1.析构函数名是在类名前加上字符~
2.无参数无返回值
3.一个类只能有一个析构函数。若未显示定义（我们没写），系统会自动生成默认的析构函数。注意：析构函数不能重载。
4.对象声明周期结束时，C++编译系统自动给调用析构函数。
5.后定义的对象先析构（栈帧）。

析构函数特点

跟构造函数类似，析构函数具有以下特点：
1.我们写了就不会自动生成了，我们不写编译器会自动生成一个析构函数。
2.内置类型成员不会处理。
3.自定义类型成员会调用这个成员的析构函数。

以如下代码为例：在日期类中创建了一个自定义类型A的成员变量

class A {
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};
class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		cout << "Date()" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	A _aa;
};
int main()
{
	Date d1;
	return 0;
}

控制台显示如下：可以看到我们创建了一个Date的实例化对象，程序先调用了A的构造函数，之后调用Date的构造函数，生命周期结束后，先调用了Date的析构函数，最后调用了A的析构函数。
因为A是自定义类型，而自定义类型成员会去调用这个成员的构造和析构函数。

三 .拷贝构造函数

下面将用一个问题来引出为什么需要拷贝构造。

浅拷贝问题——指向同一块空间

仍以上面的日期类为例：使用C语言常用的传值调用

//日期类代码跟上面相同，这里省略。
void Func(Date d)  //传值调用
{
} 
int main() { 	
	Date d1; 
	Func(d1); 
	return 0;
 }

控制台输入如下：

可以看到，析构函数调用了两次，这是因为首先在main栈帧中创建了d1，调用了构造函数，之后d1拷贝赋值给d。待到d生命周期结束，Func栈帧销毁，调用一次析构函数回收d的资源。然后d1生命周期结束，栈帧销毁回收d1的资源，调用第二次析构函数。

但是，上面的日期类实际上并无诸如malloc，realloc开出来的空间可清理，实际拷贝时我们并不能这样传值传参，下面再以栈举个反例：

class Stack {
public:
	Stack(size_t n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		_capacity = n;
		_top = 0;
	}
	~Stack()
	{
		free(_a);
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
void Func(Stack s)
{
}
int main()
{
	Stack s1;
	Func(s1);
	return 0;
}

相似的代码，但是运行后程序直接崩溃了：

原因跟上面的日期类例子类似：Func先调用析构函数，栈帧销毁，释放_a指向的空间，而main结束再调用析构函数，释放_a指向的空间，但是刚刚这个空间已经被释放过了，_a已经是野指针，因此程序崩溃。

那么对此有什么解决办法吗？实际上只需要将Func传值传参改成传指针传参或者传引用传参即可。这样的话从始至终都只有一个对象s1（一个对象只会析构一次）。

但是，这里又提出了一个问题，怎么才能在不改变s1的情况下改变s呢？这种时候就要用到拷贝构造函数。

拷贝构造

用当前类型的对象去初始化另一个同类型对象。
C++规定自定义类型传值传参要调用拷贝构造。
拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用，在用已存在的类类型对象创建新对象时由编译器自动调用。
其特征如下：
1.拷贝构造函数是构造函数的一个重载形式。
2.拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

注意特征的第二点，不能使用传值方式，可使用传引用方式。
因为使用传值方式的话，传值过去实例化出一个对象d，对象d又会去调用自己的拷贝构造函数，再实例化出一个对象…如此往复，无穷递归调用下去：

class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		cout << "Date()" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
		//Date(Date d)  //拷贝构造函数——传值方式——程序崩溃
	//{
	//	cout << "Date(Date d)" << endl;
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}
	Date(Date& d)  //拷贝构造函数——传引用方式——正确
	{
		cout << "Date(Date d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2(d1);  // 拷贝构造
	Date d3 = d1; //跟上一行代码是等价的
	return 0;
}

深拷贝

刚刚类Stack发生了浅拷贝，对同一块空间释放了两次。我们可以通过拷贝构造函数避免发生这种情况。
传值传参实例化出对象s，会自动调用拷贝构造函数，将s1的数据拷贝给s，并且没有改变s1.

class Stack {
public:
	Stack(int n = 4)
	{
		cout << "Stack()" << endl;
		_a = (int*)malloc(sizeof(int) * n);
		_capacity = n;
		_top = 0;
	}
	Stack(Stack& s)   // 拷贝构造函数
	{
		_a = (int*)malloc(sizeof(int) * s._capacity);
		_top = s._top;
		_capacity = s._capacity;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
	}
private:
	int* _a;
	int _top;
	int _capacity;
};
void Func(Stack s)  //自定义类型传值传参
{
}
int main()
{
	Stack s1;
	Func(s1);
	return 0;
}

拷贝构造特点：

我们不写，编译器默认生成的拷贝构造跟之前的构造函数，析构函数特点不一样。
1.自定义类型，会去调用它的拷贝构造
2. 内置类型，会对它进行值拷贝

总结：像日期类这种，我们可以不写拷贝构造默认生成的就够用了。但是像栈这种的，我们需要实现深拷贝的拷贝构造。

四.赋值重载

在学习赋值重载之前，需要了解什么是运算符重载。有了运算符重载，C++的类使用起来更为便捷，变得更有魅力。

内置类型可以直接使用运算符，自定义类型需要自己定义运算符重载。

以内置类型int和日期类为例：

int s1,s2 = 10; 
s1 = s2; //将s2的值赋给s1
Date d1(2023,8,12);
Date d2;  
// d2 = d1???

若是我们想将自定义类型d2的值赋给d1，可以自己定义赋值运算符重载：

class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)  //拷贝构造函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	Date& operator=(const Date& d) {
		if (this != &d) {
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 8, 12);
	Date d2;
	d2 = d1;
	d1.Print();
	d2.Print();
	return 0;
}

控制台输出如下：

五.取地址运算符&重载

六.const取地址运算符&重载

取地址运算符&重载和const取地址运算符&重载放在一起介绍，在日常使用过程中，这两个默认成员函数一般不用我们写，编译器自动生成的就够用了，故不多做介绍。

&也是一个运算符，对于自定义类型，我们需要自己定义取地址运算符重载。

class Date {
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date& d)  //拷贝构造函数
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	Date* operator&() // 取地址运算符重载
	{
		return this;
	}
	const Date* operator&() const  //const取地址运算符重载，函数后的const修饰的是this指针
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	int day = 10;
	Date d1(2023, 8, 12);
	const Date d2(2023, 8, 12);
	cout << &day << endl; //内置类型取地址
	cout << &d1 << endl;  // 取地址运算符重载
	cout << &d2 << endl;  //const取地址运算符重载
	return 0;
}

文末BB：对哪里有问题的朋友，尽管在评论区留言，若哪里写的有问题，也欢迎朋友们在评论区指出，博主看到后会第一时间确定修改。最后，制作不易，如果对朋友们有帮助的话,希望能给博主点点赞和关注.