前言

C++在C语言的基础上增加了面向对象的特性，有了类的概念，使其解决问题的焦点从解决过程转变为解决对象，对于C++来说任何事物皆为对象，从这里开始我们正式进入面向对象的大门！

正文

在C语言编程中，我们更加注重解决问题的过程，每一步的解决方法！

而在C++语言编程中，我们更加注重解决问题的对象，解决问题需要哪些对象参与！

面向过程与面向对象

为了更加深入的介绍面向过程和面向对象的区别，我们举一个洗衣服的例子！

面向过程的解决方法

面向对象的解决方法

可以看出来，面向对象的解决方法侧重于建立对象模型，然后针对对象建立方法，构建出对象之间的关系，然后解决问题，所以面向对象更关注问题的本身！

面向对象的优势

面向对象具有三大特性：封装，继承和多态！

面向对象的优点：易维护，易复用，易扩展！

综合而言，面向过程的思想无法满足大型项目问题的解决，面向对象才是解决大型项目问题的最佳选择！

本篇文章主要介绍面向对象的三大特性之一：封装

类的引入

在C++中，对象非常重要，而对象的创建就需要类！

早期C++类的实现

在C++中，每个对象都是一个类。早期C++的类可以由结构体来写，C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。
//C语言结构体
struct stu
{
	int num; //只能定义变量
    char ch;
};
//C++结构体
struct stu
{
	int Add(int a, int b); //声明函数

	void swap(int* left, int* right) //定义函数
	{
		int tmp = *left;
		*left = *right;
		*right = *left;
	}

	int num; //定义变量
};
但是struct的成员项默认是public(公开)权限，C++为了兼容C不能修改结构体的性质，但是公开的访问权限这不太符合封装的要求！于是C++重新定义一个关键字class来定义类！

class定义类

class定义规则

在C++中新增class关键字来定义类，class定义的类中，可以写函数声明，函数定义以及变量，但是其访问限权默认为private(私有)。
//格式
class 类名
{
    //类成员函数声明(使用头文件声明与定义分离时声明函数);
    int Print();

    //成员函数定义(实现)
    int Add(int a,int b)
    {
        return a+b;
    }

    //成员变量
    int num;

}; //与结构体一样需要带一个分号
class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类成员的两种定义方式

函数定义在类中

声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内
联函数处理，在实例化时会在调用处直接展开！

函数声明与定义分离

当类声明放在.h文件中，成员函数定义放在.cpp文件中时，由于类定义了新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域，既成员函数名前需要加类名::

一般情况下，更期望采用第二种方式。因为在工作中经常声明与定义分离！

类的访问限定符及封装

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

访问限定符
class Test
{
public://从该行开始内容公开，限制区域直到碰到下一个访问限定符
    // 函数/函数声明以及允许用户调用的接口
    // ......
        

private://从该行开始内容私有
    // 变量/数据-不允许用户接触的函数接口和数据，一般类成员变量都是该限定符
    //......
};
在 class 中有三种访问限定修饰符

public 公有，可以在类外直接访问其成员
protected 保护，能在类中被访问，也能在其派生类中被访问
private 私有，被修饰成员只能在类中访问

说明

protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的在类继承时有区别)。
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止如果后面没有访问限定符，作用域就到 } 即类结束。
class的默认访问权限为private，struct为public(因为struct要兼容C且C++中的struct也可以使用访问限定符)。
访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。

struct和class的区别

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍！

封装

前面我们提到过，面向对象的三大特性是：封装、继承、多态，在类和对象阶段，主要是研究类的封装特性。



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



封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。


在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

类成员

类中的变量和函数位置可以颠倒，编译器会在类中进行查找！

成员变量

在class中定义内置类型变量和自定义类型变量称为成员变量，为了安全一般使用private修饰！

由于每个实例化出来的对象都有属于自己的成员变量，在类相互联系调用时，难免会发生调用的函数参数名与变量名相同的情况，为了更好的辨别，一般在变量名前加上下划线 _ 以示区分！
//日期类
class Date
{
public:
    void Input(size_t& year,size_t& month,size_t& day)//函数参数与变量名相似
    {
        cout << "请依次输入年月日" << endl;
        cin>>year;
        cin>>month;
        cin>>day;
    }

private:
    size_t _year; //变量名前加_
    size_t _month;
    size_t _day; 
    //size_t是无符号整型
};
成员函数

在C++中类最显著的特性就是可以封装函数，在类中的函数称为成员函数或方法。

对于同类型的类对象，其方法是相互共享的，并不是每个对象都有独立的函数代码，因为成员函数虽然定义在类中，但实际上这些成员函数的代码处于代码段，每个对象需要调用时通过地址去调用函数。
//日期类
class Date
{
public:

    Date()//构造函数
        :_year(1970)
        , _month(1)
        , _day(1)
    {}

    void Print()//简单打印日期
    {
        cout << _year << endl;
        cout << _month << endl;
        cout << _day << endl;
    }

private:
    size_t _year;
    size_t _month;
    size_t _day;
    //size_t是无符号整型
};

int main()
{
    Date d1; //实例化Date类
    d1.Print();
}
所以每个对象的方法是共享的，数据是相互独立的！

类的实例化

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

实例化概念

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没
有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，这个表格先在电脑上设计出来，此时表格就可以看成是一个类，打印出来学生填写后就可以描述具体学生信息。

一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

所以类是不能直接使用的，必须实例化出对象才能使用；因为类就相当于一张造房子的图纸，我们想得到房子必需按照图纸进行建造，而不是直接住进图纸里！

类的实例化方法

类的实例化与结构体相似，只不过类使用类名定义变量即可，不需要typedef重定义类型！
//创建对象
class Test {} //举例类

int main()
{
    Test t;//实例化类为对象t
    return 0;
}

类对象大小

变量与方法的空间

类可以产生多个对象，这些对象共用代码段中的所属类方法，好比小区中有很多套房子(房子就是对象)，房子中住着很多居民(居民就是数据)，小区的保安，超市和健身器材等都是公共的(这些公共资源就是方法)，每个居民可以根据自己所需进行资源的使用，这样就避免了资源浪费，毕竟小区如果每个人都安排独立的超市那么是非常不合理的！

类的大小

在上面我们提到过类的字节大小不包括函数方法，只包括变量数据，所以类的大小计算是以每个成员变量的大小进行内存对齐相加就是类的大小，与C语言结构体大小计算相同！
class Test
{
public:
	Test() :_str("Test num:"), _num(10)
	{}

	void Print()
	{
		cout << _str << _num << endl;
	}

private:
	char _str[15]; //15字节
	int _num; //4字节
};


int main()
{
	Test t;
	cout << "Test:" << sizeof(Test) << endl;
	cout << "t:" << sizeof(t) << endl;
	t.Print();
	return 0;
}
运行结果

0-14字节是_str的空间，15不是4的倍数，_num从16字节开始占用4个字节即16-19，以最大对齐数4整数倍对齐总大小，即20字节。

内存对齐说明

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

注意：空类(不含任何成员变量)的大小为1字节，这1个字节并不用来存储数据，只是用来唯一标识这个类的对象，表示类对象实例化后的存在！

this指针

this指针的引入

类实例化的对象，每个对象都有自己独立的变量成员，不同的对象调用同一个函数时，为了区分便加入了this指针，方便访问该对象的成员变量！

类的成员函数中，编译器会在编译时为每个函数的参数中添加了this指针，当我们使用某个实例化对象调用类成员函数时，在这个函数内this指针指向调用该函数对象(存储的是该对象的地址)，这样成员函数就可以直接访问该对象的变量成员而不需要定义额外的参数！
//示例-this指针调用原理
class Test
{
public:
    void Print(Test* const this) //实际上编译器会在函数参数中会隐式定义this指针
    {
        cout << this->_num << endl;
    }
private:
    int _num;
};

int main()
{
    Test t1,t2;
    t1.Print(&t1); //对象调用函数时会将自己的地址隐式传递给函数
    t2.Print(&t2);
    return 0;
}
由于这种行为是编译器自动执行的，我们无法去干预(例如自己显示定义)！
//证明this指针
class Test
{
public:
    Test(int num = 0) :_num(num)
    {}

    void PrintA() //可以隐式调用成员变量
    {
        cout << "_num = " << _num << endl; //与this->_num效果相同
    }
    void PrintB() //也可以显示使用this指针调用成员变量
    {
        cout << "_num = " << this->_num << endl;
    }
private:
    int _num;
};

int main()
{
    Test t(1);
    t.PrintA();
    t.PrintB();
    return 0;
}
代码运行结果

代码的运行结果说明了两点，首先this指针是真实存在的可以调用对象的成员变量，而且我们在使用成员变量是可以使用this指针指明要使用成员变量(显示使用this指针)，也可以直接使用成员变量(编译器隐式使用this指针)。

C++中通过引入this指针解决了同一个函数中区分不同对象的问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成this指针主要是为了区分一个函数中的不同对象。
//示例-this指针所解决的问题
class Test
{
public:
    void subtract(const Test& pt) //求两个对象某值的差
    {
        cout << _num - pt._num << endl; //更好的区分对象
    }
private:
    int _num;
};

int main()
{
    Test t1,t2;
    t1.subtract(t2);
    return 0;
}
this指针特性

this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
只能在“成员函数”的内部使用。
this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

this空指针

如果我们定义一个类指针指向空是否可以调用类函数？
//示例代码
class Test
{
public:
    Test(int num = 0) :_num(num)
    {}

    void Fun1() //正常调用
    {
        cout << "Fun1被调用！" << endl;
    }
    void Fun2() //崩溃！this空指针访问
    {
        cout << "Fun2被调用！" << " _num = " << _num << endl;
    }
    
private:
    int _num;
};

int main()
{
    Test* t = nullptr;
    t->Fun1();
    t->Fun2();
    return 0;
}
代码调试结果

这说明，如果对象指针是空指针，是可以正常调用函数的，因为类的成员函数不是存在对象中；如果函数中不涉及this指针的访问则程序可以正常运行，否则此函数会崩溃！