前言

本章将正式开始C++系列的讲解，本文会初步认识类与对象

一.由面向过程到面向对象

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

举个例子: 要完成洗衣服这项工作

C语言:

C++:

1. 四个对象: 人, 衣服, 洗衣粉, 洗衣机
2. 洗衣服的过程: 人将衣服放入洗衣机, 倒入洗衣粉, 启动洗衣机, 洗衣机会洗衣服并甩干
3. 整个过程是人, 衣服, 洗衣粉, 洗衣机四个对象之间交互完成的, 人不需要关心洗衣机具体是如何洗衣服的, 是如何甩干的.
   

二.类的引入

C语言中，结构体内只能定义变量，在C++中，结构体内不仅可以定义变量，还可以定义函数。

以前用C语言实现数据结构——栈时，我们这样定义：

//C语言
typedef int dataOfStackType;typedef struct stack
{dataOfStackType* a;int top;int capacity;
}stack;void StackInit(stack* ps);void StackPush(stack* ps, dataOfStackType data);void StackPop(stack* ps);//...

而在C++中，我们可以这样定义：

//C++
typedef int dataOfStackType;typedef struct stack
{void StackInit(stack* ps);void StackPush(stack* ps, dataOfStackType data);void StackPop(stack* ps);
//...dataOfStackType* a;int top;int capacity;
}stack;

像上面的定义方式，C++中更喜欢用一个新的名字——class来代替struct:

class stack
{void StackInit(stack* ps);void StackPush(stack* ps, dataOfStackType data);void StackPop(stack* ps);
//...dataOfStackType* a;int top;int capacity;
};

三.类的定义

1.什么是类

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

如上所示，类的定义与结构体的定义非常相似:

1. class ：定义类的关键字
2. class Name：类的名字
3. 类的主体：{}中为类的主体，由成员变量和成员函数组成
4. 成员变量：又称类的属性，指在类中定义的变量
5. 成员函数：又称类的方法，指在类中定义的函数

2.类的定义方式

类的定义方式一般有两种：

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

//日期类
class Date
{void Init(int year, int month, int day){_year = year;_month = month;_day = day;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}int _year;int _month;int _day;
};

2. 类的声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名:: 。

//Date.h文件中声明类
//日期类
class Date
{
public:void Init(int year, int month, int day);void Print();int _year;int _month;int _day;
};

//Date.c文件中定义成员函数
#include"Date.h"void Date::Init(int year, int month, int day)
{_year = year;_month = month;_day = day;
}
void Date::Print()
{cout << _year << "-" << _month << "-" << _day << endl;
}

一般情况下，更期望采用第二种方式。

3.成员变量名命规则建议

我们来看下面这个类:

class Date
{
public:void Init(int year){//这里的year到底是成员变量，还是函数形参？year = year;}
private:int year;
};

上面Init函数中的year变量是不是很别扭, 到底是成员变量还是函数形参呢?
为了避免混淆, 我们建议如下名命成员变量:

class Date
{
public:void Init(int year){_year = year;}
private:int _year;
};// 或者这样
class Date
{
public:void Init(int year){mYear = year;}
private:int mYear;
};

其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行

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

1.访问限定符

我们在类中定义了各种成员函数与成员变量，有时候，我们不想让别人随便访问类中的某些成员，比如成员变量，但其它的成员对外开放，比如成员函数，那么我们就需要用到访问限定符来修饰这些成员。

访问限定符有三个：public、protected、private

访问限定符说明:

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

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

那么问题来了: c++中struct和class的区别是什么呢?

答: C++需要兼容C语言，所以C++中struct不仅可以当成结构体使用, C++中struct还可以用来定义类, 和class定义类是一样的. 区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

2.封装

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

在当前阶段，我们只学习封装的特性。那什么是封装呢?

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

封装本质上是一种管理，让用户更方便使用类:

• 比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
• 对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
• 在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

五.类的作用域

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

class Person
{
public:void PrintPersonInfo();
private:char _name[20];char _gender[3];int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{cout << _name << " "<< _gender << " " << _age << endl;
}

六.类的实例化

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

//类的声明
class Date
{
public://...int _year;int _month;int _day;
};
int main()
{//类的实例化对象Date d1;Date d2;Date d3;return 0;
}

类实例化对象就像现实中使用使用设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，而实例化出的对象才是真正盖好的房子，能实际存储数据，占用物理空间。
像设计图一样，并不是一幅设计图只能盖一个房子，一个类也可以实例化出多个对象。

七.类对象模型

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

上文提到，C++中，类与结构体本质是相同的。为了兼容C语言，C++会遵循结构体大小的计算规则，而类与结构体相同，那么类也是继续运用与结构体相同的计算规则。

注意：成员函数在公共代码段，因此成员函数不占用空间。所以，一个类的大小，实际就是该类中成员变量的大小，遵循内存对齐的规则。

下面来验证一下：

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

运行结果：

如上图所示，结果与结论相符：类的大小只计算类中成员变量的大小，且遵循内存对齐规则。

• 那为什么空类的大小是1呢？
  这是因为空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

补充：结构体内存对齐规则：

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

八.this指针

1.认识this指针

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

//日期类
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, d2;d1.Init(2022, 1, 11);d2.Init(2022, 1, 12);d1.Print();d2.Print();return 0;
}

对于上述操作，有这样一个疑问：

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

C++中通过引入this指针解决该问题：

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

2.this指针的特性

this指针有以下特性：

1. this指针的类型：类型* const，即在成员函数中，不能给this指针赋值

void Init(int year, int month, int day)
{//错误示例this=nullptr;
}

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

有了this指针，我们上面实现的日期类还可以这样实现：

//日期类
class Date
{
public:void Init(int year, int month, int day){this->_year = year;this->_month = month;this->_day = day;}void Print(){cout <<this-> _year << "-" <<this-> _month << "-" <<this-> _day << endl;}
private:int _year;int _month;int _day;
};

但是在实际写代码的过程中没有必要这样写，因为编译器已经帮我们做了，我们就不要干吃力不讨好的事情。

【面试题】

• this指针存在哪里？
  答：this指针是成员函数的形参，因此存在栈区。
• this指针可以为空吗？
  先看下面两段代码：

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:void Print(){cout << "Print()" << endl;}
private:int _a;
};int main()
{A* p = nullptr;p->Print();return 0;
}// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{ 
public:void PrintA() {cout<<_a<<endl;}
private:int _a;
};
int main()
{A* p = nullptr;p->PrintA();return 0;
}

第1道选C，第2道选B，这是因为：

• P调用Print，不会解引用，因为Print的地址不在对象中，P作为实参传递给this指针
• 第1个程序：this指针是空的，但是函数没有对this指针解引用
• 第2个程序：this指针是空的，但是函数内访问_a，本质是this->_a，也就是解引用空指针，会发生运行错误。

九.C语言和C++实现栈的对比

1.C语言实现

typedef int DataType;
typedef struct Stack
{DataType* array;int capacity;int size;
}Stack;void StackInit(Stack* ps)
{assert(ps);ps->array = (DataType*)malloc(sizeof(DataType) * 3);if (NULL == ps->array){assert(0);return;}ps->capacity = 3;ps->size = 0;
}void StackDestroy(Stack* ps)
{assert(ps);if (ps->array){free(ps->array);ps->array = NULL;ps->capacity = 0;ps->size = 0;}
}void CheckCapacity(Stack* ps)
{if (ps->size == ps->capacity){int newcapacity = ps->capacity * 2;DataType* temp = (DataType*)realloc(ps->array,newcapacity * sizeof(DataType));if (temp == NULL){perror("realloc申请空间失败!!!");return;}ps->array = temp;ps->capacity = newcapacity;}
}void StackPush(Stack* ps, DataType data)
{assert(ps);CheckCapacity(ps);ps->array[ps->size] = data;ps->size++;
}int StackEmpty(Stack* ps)
{assert(ps);return 0 == ps->size;
}void StackPop(Stack* ps)
{if (StackEmpty(ps))return;ps->size--;
}DataType StackTop(Stack* ps)
{assert(!StackEmpty(ps));return ps->array[ps->size - 1];
}int StackSize(Stack* ps)
{assert(ps);return ps->size;
}int main()
{Stack s;StackInit(&s);StackPush(&s, 1);StackPush(&s, 2);StackPush(&s, 3);StackPush(&s, 4);printf("%d\\n", StackTop(&s));printf("%d\\n", StackSize(&s));StackPop(&s);StackPop(&s);printf("%d\\n", StackTop(&s));printf("%d\\n", StackSize(&s));StackDestroy(&s);return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

1. 每个函数的第一个参数都是Stack*
2. 函数中必须要对第一个参数检测，因为该参数可能会为NULL
3. 函数中都是通过Stack*参数操作栈的
4. 调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

2.C++实现

typedef int DataType;
class Stack
{
public:void Init(){_array = (DataType*)malloc(sizeof(DataType) * 3);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = 3;_size = 0;}void Push(DataType data){CheckCapacity();_array[_size] = data;_size++;}void Pop(){if (Empty())return;_size--;}DataType Top() { return _array[_size - 1]; }int Empty() { return 0 == _size; }int Size() { return _size; }void Destroy(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}
private:void CheckCapacity(){if (_size == _capacity){int newcapacity = _capacity * 2;DataType* temp = (DataType*)realloc(_array, newcapacity *sizeof(DataType));if (temp == NULL){perror("realloc申请空间失败!!!");return;}_array = temp;_capacity = newcapacity;}}
private:DataType* _array;int _capacity;int _size;
};
int main()
{Stack s;s.Init();s.Push(1);s.Push(2);s.Push(3);s.Push(4);printf("%d\\n", s.Top());printf("%d\\n", s.Size());s.Pop();s.Pop();printf("%d\\n", s.Top());printf("%d\\n", s.Size());s.Destroy();return 0;
}

C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *参数是编译器维护的，C语言中需用用户自己维护。

本篇到此结束，码文不易，还请多多支持哦！