【C++】类和对象（上）—— this指针

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。体现到代码层面就是方法/函数。

C++是基于面向对象的（面向过程和面向对象混编 —— 因为C++兼容C），关注的是类对象以及对象间的关系，将一件事情拆分成不同的对象，靠对象之间的交互完成。体现到代码层面就是类的设计及类的关系。

2. 类的引入

C++兼容了C中结构体的用法，同时struct在C++中也升级成了类。

C++类和结构体不同的是，除了可以定义变量，还可以定义方法/函数。

写一个学生的类 ——

#include<string.h>
#include<iostream>
using namespace std;

struct Student
{
	//成员变量，加_是为了区分
	char _name[20];
	int _age;

	//成员函数/方法
	void Init(const char* name, int age)
	{
		strcpy(_name, name);
		_age = age;
	}

	void Print()
	{
		cout << _name << " " << _age << endl;
	}
};

int main()
{
	struct Student s1;//C++兼容C
	Student s2;//可以这样写，Student是类名，也是类型

	//c++
	s1.Init("小边", 19);
	s1.Print();

	s2.Init("王巨龙", 19);
	s2.Print();
	return 0;
}

还记得我们在C中都是这样访问的 ——

	s1.age = 19;
	strcpy(s1.name, "小边");

	s2.age = 19;
	strcpy(s2.name, "王巨龙");

对于上面结构体的定义，C++中更喜欢用class来代替。

类的定义 ——

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

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

类中的元素称为类的成员：类中的数据称为类的属性或者成员变量；类中的函数称为类的方法或者成员函数。(完了，我不认识“类”这个字儿了)

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

3.1 封装

然而就在我信誓旦旦的把struct替换为class后，外面访问函数时却标红了。那我们先来谈封装 ——

众所周知，【面向对象的三大特性】：封装、继承、多态。

在类和对象阶段，我们只研究类的封装特性，什么是封装？

🍓 封装本质上是一种更好的严格管理；不封装是自由的管理。它 ——

1. 把数据和方法都放到一起，类里面（把你圈起来）
2. 访问限定符 —— 可以给你访问的定义成公有，不想给你访问的定义成私有/保护。

比如回想C语言实现栈，我们把数据和方法分离，那我压栈，理论上我会调用StackPush，但我也完全可以直接手动操纵结构成员，这样就给错误的发生有利条件。

接着来介绍访问限定符。

3.2 访问限定符

C++实现封装的方式，用类将对象的属性和方法结合在一起，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

🍓说明 ——

1. public修饰的成员在类外可以直接访问
2. protected和private修饰的成员在类外不能直接访问。（在此处protected和private是类似的）
3. class的默认访问权限为private，struct的为public（因为struct要兼容C） —— 一般定义类的时候，建议明确访问修饰限定符，不要指着class/struct默认限定符
4. 访问权限的作用域从这个访问限定符出现的位置开始，到下一个访问限定符出现为止。

【面试题】C++中struct和class的区别是什么？

我们标题3.最开始的问题也有了答案 like this ——

class Stack
{
public:
	void StackInit()
	{
		_a = nullptr;
		_top = _capacity = 0;
	}

	void StackPush(int x)
	{}

	int StackTop()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

private:
    int* _a;
    int _top;
    int _capacity;
};

int main()
{
	Stack st;
	st.StackInit();
	st.StackPush(1);
	st.StackPush(2);
	return 0;
}

4. 类的定义

类定义了一个新的作用域。类的所有成员都在类的作用域中；在类外定义成员，需要::作用解析符指明成员属于哪个类域。

🍓在一个项目里，声明放在.h文件中，定义放在.cpp文件中 —— like this

Stack.h

class Stack
{
public:
	void StackInit();
	void StackPush(int x);
	int StackTop();

private:
	int* _a;
	int _top;
	int _capacity;
};

Stack.cpp

#include"Stack.h"

void Stack::StackInit()
{
	_a = nullptr;
	_top = _capacity = 0;
}

void Stack::StackPush(int x)
{}

int Stack::StackTop()
{
	assert(_top > 0);
	return _a[_top - 1];
}

🍓类的定义还可以 —— 声明和定义全部放在类体中，注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理（说可能是因为内联只是一种建议）

5. 类的对象大小计算

5.1 计算类对象的大小

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

接续4.代码 ——

	cout << sizeof(Stack) << endl;
	cout << sizeof(st) << endl;

运行结果 ——

🍓事实证明，计算类的对象的大小 —— 只看成员变量。且要考虑内存对齐，C++内存对齐规则和C一样。

那么类实例化出的对象中，只存成员变量，不存成员函数吗？我们接着看。

5.2 类对象的存储方式

如果对象中包含类的各个成员，每个对象都有独立的成员变量，但是不同对象调用成员函数，调用同一份函数。当一个类创建多个对象时，每一个对象都会保存相同一份代码，那就有些浪费空间了。于是 ——

🍓 类对象的存储：只保存成员变量，成员函数放在公共的代码段。

来道题叭 ——

// 类中既有成员变量，又有成员函数
class A1 
{
public:
 	void f1(){}
private:
 	int _a;
};

// 类中仅有成员函数
class A2 
{
public:
 	void f2() {}
};

// 类中什么都没有---空类
class A3
{};

运行结果 ——

注意，空类比较特殊，编译器给了空类一个字节来标识这个类。不存储有效数据，只是为了空间占位，标识对象存在。不然像这样的也没法区分对吧 ——

	A2 a2;	A2 b2;

5.3 结构体内存对齐原则

1. 第一个成员在与结构体偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。（VS中默认的对齐数为8）

3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是

所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

细节忘得差不多了，我也顺便复习一下。深度剖析结构体

【面试题】

1. 结构体怎么对齐？ 为什么要进行内存对齐

2. 如何让结构体按照指定的对齐参数进行对齐

3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

6. 类成员函数的this指针

6.1 this指针的引出

我们先来定义一个日期类 ——

class Date{
public:	
    void InitDate(int year,int month,int day)	
    {		
        _year = year;		
        _month = month;		
        _day = day;	
    }	
    void PrintDate()	
    {		
        cout << _year << "-" << _month << "-" << _day << endl;	
    }
private:	
    int _year;	
    int _month;	
    int _day;
};
int main()
{	
    Date d1;	
    Date d2;	
    d1.InitDate(2002, 3, 7);	
    d2.InitDate(2002, 2, 19);//是谁的生日我不说	
    d1.PrintDate();	
    d2.PrintDate();	
    return 0;
}

Date类中有InitDate与PrintDate两个成员函数，函数体中没有关于不同对象的区分，那当s1调用InitDate函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

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

因此，我们所看到的，实际上都是这样的 ——

想说的都在图片里了！

🍓 注：

1. 调用成员函数时，不能显式的传参this
2. 定义成员函数时，也不能显式声明this
3. 但是在成员函数内部，我们可以显式的使用this（有需要）

6.2 this指针的特性

【面试题】

1. this指针存在哪里？

一般情况下是在栈（形参），vs2013把它放到了寄存器eax中。

可以转到反汇编 ——

2. 思考：选？ A.编译报错 B.运行崩溃 C.正常运行

//1.
class A
{
public:
	void Show()
	{
		cout << "Show()" << endl;
	}

private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Show();
	return 0;
}

and ——

//2.
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}

private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

有趣的是 ——

1. p是空指针，但是空指针并不是语法错误，编译器检查不出来p调用成员函数不会编译报错。

2. p调用成员函数，也不会出现空指针访问，因为成员函数本身也不是存在对象里的，这么写确实会给人错觉，但是我们要看清它的本质。

3. p作为实参传给隐藏的this指针时，只有解引用空指针时，程序会崩溃。不解引用没事。

本文完@边通书

持续更新 ~