C++ 类，this指针，封装

在这一章节，我们会学习到的概念：类，封装，对象，this类指针，并且从汇编角度贴近计算机底层来深刻讲解this指针。

1.this指针引入

我们先来写一个这样的简单程序：

#include <stdio.h>

struct Base{
	int a;
	int b;
}; 
int Max(Base in){
	if(in.a>in.b){
		return in.a;
	}
	else{
		return in.b;
	}
}
int main(){
	Base one;
	one.a=1;
	one.b=2;
	int c=Max(one);
	printf("%d",c);
	return 0;
}

程序定义了一个Base结构体，结构体中有两个成员，都为int类型
程序定义了一个函数，需要一个Base类型的参数，函数功能为比较Base结构中的两个成员，并返回其中较大的一个。
我们来到反汇编看一看：

mov         eax,dword ptr [ebp-4]
push        eax
mov         ecx,dword ptr [ebp-8]
push        ecx
call        @ILT+0(Max) (00401005)
add         esp,8
mov         dword ptr [ebp-0Ch],eax

我们来看看程序调用Max函数的过程：
先将参数one中的成员（a,b）压入栈中，然后调用Max函数，在函数完成后，我们发现这是一个外平栈。
然后我们将Max函数（封装的定义我们在后面会讲到）封装到结构体中：

#include <stdio.h>

struct Base{
	int a;
	int b;

	int Max(Base in){
		if(in.a>in.b){
			return in.a;
		}
		else{
			return in.b;
		}
	}
}; 
int main(){
	Base one;
	one.a=1;
	one.b=2;
	int c=Max(one);
	printf("%d",c);
	return 0;
}

这时候我们编译程序的时候发现出错了，错误提示为：error C2065: 'Max' : undeclared identifier
由于我们是将Max函数封装到了Base结构体中，所以我们在调用函数时，应该这样调用：int c= Base.Max(one);
所以我们的程序应该写为：

#include <stdio.h>
struct Base{
	int a;
	int b;

	int Max(Base in){
		if(in.a>in.b){
			return in.a;
		}
		else{
			return in.b;
		}
	}
}; 
int main(){
	Base one;
	one.a=1;
	one.b=2;
	int c=one.Max(one);
	printf("%d",c);
	return 0;
}

我们发现程序能够正常运行，那么我们来思考一个问题：
将函数封装在结构体中后，他会不会占用结构体空间？
我们在源代码后加入这样一串代码来观察封装的函数到底有没有占用结构体空间：
printf( "%d " , sizeof(one) );
在程序运行之后，我们发现 sizeof(one)的值为8，那么就说明封装在结构体中的函数没有占用结构体空间。
我们继续来到反汇编，观察调用函数的过程：

mov         eax,dword ptr [ebp-4]
push        eax
mov         ecx,dword ptr [ebp-8]
push        ecx
lea         ecx,[ebp-8]
call        @ILT+10(Base::Max) (0040100f)
mov         dword ptr [ebp-0Ch],eax

唉？我们发现它往堆栈中压入了三个参数，可是我们的结构体中明明只有两个成员。
**我们来分析一下这段汇编代码：

mov         eax,dword ptr [ebp-4]     //将a传给eax
push        eax                                 //将eax（a）压入堆栈中         
mov         ecx,dword ptr [ebp-8]     //将b传给ecx
push        ecx                                 //将ecx（b）压入堆栈中
lea         ecx,[ebp-8]                       //将ebp-8的地址传进ecx
call        @ILT+10(Base::Max) (0040100f)           //调用函数
mov         dword ptr [ebp-0Ch],eax                      //平衡堆栈

那么为什么将函数封装在结构体内部编译器就会给函数多传一个参数呢？
我们写一个空的结构体将函数封装进去看看它还会不会传参数进去：

#include <stdio.h>
struct Base{
	//int a;
	//int b;
	void Max(){
		/*
		if(in.a>in.b){
			return in.a;
		}
		else{
			return in.b;
		}
	}
	*/
		printf("fjdksalfjdksa\n");
	}
}; 
int main(){
	Base one;
	//one.a=1;
	//one.b=2;
	//int c=
	one.Max();
	//printf("%d",c);
	return 0;
}

我们可以看到这里的Max函数不需要任何参数，也没有任何返回值，Base结构体内也没有变量，现在我们来到反汇编看看：

lea         ecx,[ebp-4]
call        @ILT+15(Base::Max) (00401014)

我们可以看到，即使函数不需要任何参数，编译器也会为封装在结构体内的函数传入参数（一个地址，也就是指针），而且我们可以观察到，这个指针指向了结构体的首地址，那么这个指针，我们叫做this执政。
我们来看看this指针的用法：

#include <stdio.h>
struct Base{
	int a;
	int b;
	int Max(Base* in){
		if(this->a>this->b){
			return this->a;
		}
		else{
			return this->b;
		}
	}
}; 
int main(){
	Base one;
	one.a=1;
	one.b=2;
	int c=one.Max(&one);
	printf("%d",c);
	return 0;
}

我们可以发现，我们在函数内部可以通过this指针来获取结构体内成员的值。
我们来到反汇编查看：

lea         eax,[ebp-8]
push        eax
lea         ecx,[ebp-8]
call        @ILT+25(Base::Max) (0040101e)
mov         dword ptr [ebp-0Ch],eax

我们可以看到，这样调用函数的时候，函数的堆栈就会减少，节省了内存空间。

2.封装

封装是面向对象程序设计思想最重要的特征。封装就是隐藏，它将数据和数据处理过程封装成一个独立性很强的模块，避免外界直接访问对象属性而造成耦合度过高以及过度依赖。
封装是面向对象的核心思想，将对象的属性和行为封装起来，行为对外提供接口，不需要让外界知道具体的实现细节。

3.类

类是对象的抽象，是一种自定义数据类型，这和C语言中的自定义结构体很像， 它用于描述一组对象的共同属性和行为。
类的定义：

class 类名
{
权限控制符；
	成员；
}

关于类定义的具体介绍如下：
（1）.class是定义类的关键字
（2）.类名是类的标识符，其命名遵循标识符的命名规范
（3）.类名后面的大括号，用于包含类的成员，类的所有成员都要在这一对大括号中声明。类中可以定义成员变量（也成为属性）和成员函数（也成为方法），成员变量用于描述对象的属性，成员函数用于描述对象的行为。
（4）.声明类的成员时，通常要使用权限控制符限定成员的访问规则，权限控制符包括public，protected和private，这三种权限控制符的权限依次递减。
（5）.大括号后面的一个分号，用于表示类定义的结束。

权限控制符具体介绍：

public（共有类型）：被public修饰的成员也被成为共有成员。共有成员是类的外部接口，可以被所属类的成员函数，类对象，派生类对象，友元函数，友元类访问。
protected（保护类型）：被protected修饰的成员被称为保护成员，其访问权限介于私有和共有之间，可以被所属类的成员函数，派生类对象，友元类和友元函数访问。
private（私有类型）：被private修饰的成员成为私有成员，只能被所属类的成员函数，友元函数，友元类访问。

4.this指针

this指针是C++实现封装的一种机制，它将对象和对象调用的非静态成员函数联系在一起，从外部看来，每个对象拥有自己的成员函数。当创建一个对象时，编译器会初始化一个this指针，指向创建的对象，this指针并不存储在对象内部（这就是封装在结构体内部的函数不占用结构体内存的原因），而是作为所有非静态成员函数的参数。
实现类的成员函数时，如果形参与类的属性重名，那么this指针能很好地解决这个问题。
如果类的成员返回值为一个对象，那么可以用return *this来直接返回对象本身。