[C++知识库]【C++初阶】二、类和对象（上）

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

C++是在C语言的基础上增加面向对象的思想
所以C++是基于面向对象的（既有面向过程，也有面向对象，因为C++兼容C语言）

扩展：java是一门纯面向对象的语言

面向过程和面向对象不是一门编程语言，而是一种解决问题的思路

二、类的引入

观察下方代码的区别。

在C语言中：

//C
struct Student 
{
	char name[20];
	int age;
	int id;
};
int main()
{
	struct Student s;
	strcpy(s.name, "小情兽");
	s.age = 18;
	s.id = 11;
}

在C++中：

//C++
struct Student 
{
	//成员变量
	char _name[20];
	int _age;
	int _id;
	//成员函数
	void Init(const char* name, int age, int id) 
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print() 
	{
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};
int main()
{
	Student s1;
	Student s2;    //类名可以直接作类型使用
	s1.Init("张三", 19, 1);
	s1.Print();
	s2.Init("李四", 18, 2);
	s2.Print();
}

从上述代码可以看出，在C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

我们可以看出上面是结构体的定义方式，在C++中更喜欢用class来代替。

三、类的定义

class className
{
	// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{ }中为类的主体，注意类定义结束时后面分号。

类中的元素即变量和函数都称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数

到这我们可以明白，C++定义类可以用两个关键字：class和struct。
原因是C++兼容C里结构体的用法，同时结构体(struct)在C++中也升级成了类，类名可以直接作类型使用。类与结构体不同的地方在于，类中不仅可以定义变量，还可以定义方法或称函数。

那用这两中关键字定义的类有什么区别呢？

用class定义的类和struct定义的类在访问限定权限上稍有不同。在下方进行讲解。

四、类的访问限定符及封装

4.1 访问限定符

C++共有三个访问限定符，分别为公有public，保护protect，私有private。

访问限定符说明：

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. class的默认访问权限为private，struct为public(因为struct要兼容C)

封装的意义就在于规范成员的访问权限，更好的管理类的成员，一般在定义类的时候，建议明确定义访问限定符，不要用class/struct默认限定。

class Student
{
private:
	//成员变量
	char _name[20];
	int _age;
	int _id;

public:
	//成员函数
	void Init(const char* name, int age, int id)
	{
		strcpy(_name, name);
		_age = age;
		_id = id;
	}
	void Print()
	{
		cout << _name << endl;
		cout << _age << endl;
		cout << _id << endl;
	}
};

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。

4.2 封装

面向对象三大特性是封装、继承和多态。

面向对象编程讲究个“封装”二字，封装体现在两方面，一是将数据和方法都放到类中封装起来，二是给成员增加访问权限的限制。

封装定义：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

class Stack
{
public:
	void Init()
	{
		_a = nullptr;
		_top = _capacity = 0;
	}
	void Push(int x)
	{

	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
private:
	//成员变量
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	int top = st.Top();
}

五、类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。

类定义的方式有两种：

1.声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
参考上方的代码，上方代码，成员函数均在类中定义。

2.在类体外定义成员，需要使用 : : 作用域解析符指明成员属于哪个类域。

class Student
{
private:
	//成员变量
	char _name[20];
	int _age;
	int _id;

public:
	//成员函数
	void Print();
};

//在类外定义成员函数时，需要使用域作用限定符::指明该成员归属的类域
void Student::Print()
{
	cout << _name << endl;
	cout << _age << endl;
	cout << _id << endl;
}

这种一般使用在声明和定义分离的情况下：

六、类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

类和对象的关系，就与类型和变量的关系一样，可以理解为图纸和房子的关系。

七、类对象模型

7.1 如何计算类对象的大小

既然类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小呢？

我们学过C语言结构体可以知道，计算结构体大小需要考虑内存对齐，那C++中是如何计算类的大小呢？我们先看下方举例：

class Stack
{
public:
	void StackInit();
	void StackDestroy();
	void StackPush();
	void StackPop();
	int StackSize();
	bool StackEmpty();
private:
	int* _a;
	int _top;
	int _capacity;
};
int main()
{
	Stack s;
	cout << sizeof(Stack) << endl;
	cout << sizeof(s) << endl;
}

上方计算大小是多少呢？我们看运行结果：

我们可以看出此类的大小为12，按照结构体内存对齐规则，我们可以知道，计算类的大小只计算了成员变量的大小总合，所以：

结论：计算类或者类对象大小，只看成员变量，需考虑内存对齐，C++内存对齐规则跟C结构体一致

7.2 类对象的存储方式

我们从上方知道，计算一个类的大小只看成员变量，那么一个类的对象中包含了什么？类对象如何存储？

我们可以思考一下，如果类成员函数也存放在对象中，实例化多个对象时，各个对象的成员变量相互独立，但调用的成员函数都是同一个，相同的代码存储多份浪费空间。

因此，C++对象中仅存储类变量，成员函数存放在公共代码段。

既然了解了类对象的存储方式，接下来看看下面类的大小吧：

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1() {}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};

sizeof(A1) : 4
sizeof(A2) : 1
sizeof(A3) : 1

看到结果我们可能就有些疑惑了，为什么A2和A3是1呢？
因为空类会给1byte，这个1byte不存储有效数据，只是为了占位，表示对象存在。

空类的大小若为0，相当于内存中没有为该类所创对象分配空间，等价于对象不存在，所以是不可能的。

总结：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

7.3 结构体内存对齐规则

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
3. 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
   VS中默认的对齐数为8
4. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
5. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

八、this指针

我们首先来定义一个日期类：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		//year = year;//错误的，就近原则，成员变量没有被初始化
		//1.
		_year = year;
		//2.
		Date::month = month;
		//3.
		this->day = day;
	}
	void Print()
	{
		cout << _year << "-" << month << "-" << day << endl;
	}
private:
	int _year;
	int month;
	int day;
};

我们在定义类的时候，需要注意的是：如果成员变量与形参重名时，则在Init函数中赋值就会采用就近原则，优先使用形参从而导致成员变量没有被初始化，这种问题有三种解决方案，如下：

1. 在成员变量名前加_，以区分成员变量和形参。（C++风格）
2. 使用域作用限定符 : :，指定前面的变量是成员变量。
3. 使用this指针

8.1 this指针的定义

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;
	d1.Init(2022, 1, 15);
	d1.Print();

	Date d2;
	d2.Init(2022, 1, 16);
	d2.Print();
	return 0;
}

我们观察代码，发现定义了两个对象，而在上方我们讲到，类对象中只有成员变量，而成员函数是存放在公共代码区的。

既然如此，那我们定义两个对象，当两个对象分别去调用成员函数时，它是怎么进行区分的呢？比如：当d1调用Print函数时，该函数是如何知道打印d1对象，而不是打印d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的this指针，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成

其实我们在调用成员函数时，编译器会对成员函数进行处理，如下：

如图所示，在传参时隐藏地传入了对象的指针，形参列表中也对应隐藏增加了对象指针，函数体中的成员变量前也隐藏了 this 指针。

8.2 this指针的特性

this是C++的一个关键字，指向当前对象的指针。

1. 调用成员函数时，不可以显式传入 this 指针，成员函数参数列表也不可显示声明 this 指针。
2. 在成员函数内部可以显式使用 this 指针。
3. this指针的类型为classType* const，加const是为了防止 this 指针被改变。（例如：Date* const this）
4. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

那this指针存放在哪呢？

请看下面例题：1和2哪个会出现问题，出什么问题？

class A
{
public:
	void Show()
	{
		cout << "Show()" << endl;
	}
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	//1.
	p->Show();
	//2.
	p->PrintA();
}

分析：
1、p虽然是空指针，但是p调用成员函数不会编译报错，因为空指针不是语法错误，编译器检查不出来。
2、p虽然是空指针，但是p调用成员函数也不会出现空指针访问。因为成员函数没有存在对象里面。
3、两者只是把p作为实参传递给隐形this指针。

由于调用Show()函数没有访问对象中的内容，不存在访问空指针的问题。
调用PrintA()函数时，由于此时this指针为空，在进行输出时，会访问对象中的成员变量_a，此时就对空指针进行了解引用，所以访问空指针程序崩溃。