文章目录

• 前言
• • 1.面向过程和面向对象初步认识
  • 2.类的引入
  • 3.类的定义
  • 4.类的访问限定符及封装
  • • 4.1 访问限定符
    • 4.2 封装
  • 5.类的作用域
  • 6.类的实例化
  • 7.类的对象大小的计算
  • • 试着推导一下
    • • 假设一
      • 假设二
      • 假设三
  • 8.类成员函数的this指针
  • • 8.1 this指针的引出
    • 8.2 this指针的特性
    • 8.3. C语言和C++实现Stack的对比
    • • 1. C语言实现
      • 2. C++实现

前言

本文将讲述c++类和对象的初步认识，包括“类的访问限定符及封装”“类的作用域""类的实例化”“类的对象大小的计算”“类成员函数的this指针”等等。

🕺作者： 迷茫的启明星

😘欢迎关注：👍点赞🙌收藏✍️留言

🏇家人们，码字不易，你的👍点赞🙌收藏❤️关注对我真的很重要，有问题可在评论区提出，感谢阅读！！！

持续更新中~

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

比如说：洗衣服，使用面向过程的思想来分析就是，拿个盆子—>放水—>放衣服—>放洗衣服—>手搓—>换水—>放洗衣粉—>手搓—>拧干—>晾衣服

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完

成。

使用面向对象的思想来分析就是：

总共有三个对象：人、衣服、洗衣粉、洗衣机

整个洗衣服的过程：人将衣服放进洗衣粉，倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干

整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的。

2.类的引入

C语言结构体中只能定义变量，而在C语言的升级版，C++中，结构体内不仅可以定义变量，也可以定义函数。

比如说：

在使用C语言实现的顺序表，结构体中只能定义变量；

现在以C++的方式实现，会发现struct中也可以定义函数。

#include <iostream>using namespace std;typedef int SLDateType;struct SeqLList{void SeqListInit(){_a=nullptr;_size=0;_capacity=0;}void SeqListPushBack(const SLDateType& x){if (_size ==_capacity){int newCapacity =_capacity == 0 ? 4 : _capacity * 2;auto* tmp=(SLDateType*)realloc(_a,newCapacity*sizeof(SLDateType));if (tmp == nullptr){printf("realloc fail\n");return;}_a = tmp;_capacity = newCapacity;}_a[_size]=x;(_size)++;}void SeqListPrint(){for (int i = 0; i < _size; ++i) {printf("%d",_a[i]);}}void SeqListDestroy(){_capacity=0;_size=0;free(_a);}SLDateType* _a;int _size;int _capacity;};int main(){SeqLList s{};s.SeqListInit();s.SeqListPushBack(1);s.SeqListPushBack(2);s.SeqListPushBack(3);s.SeqListPrint();s.SeqListDestroy();return 0;}

在C++中，更喜欢用class来代替struct，毕竟C++已经是一门新的语言，但是也能使用struct定义类，这是因为C++兼容C。

3.类的定义

那么类是怎么定义的呢？

和C语言的结构体非常相似，是这样的

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

class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面分
号不能省略。
类体中内容称为类的成员；

类中的变量称为类的属性或成员变量;

类中的函数称为类的方法或者成员函数。
类的两种定义方式：

声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理，也就是说给编译器一个建议。

class Person{public:void showinfo(){cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;}public:char*_name;char*_sex;int _age;};

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

//声明放在类的头文件person.h中class Person{public:void showinfo();public:char*_name;char*_sex;int _age;}; //定义放在类的实现文件person.cpp中#include"person.h"void Person::showinfo(){cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;}

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

成员变量命名规则的建议：

// 我们看看这个函数，是不是很僵硬？class Date{public:void Init(int year){// 这里的year到底是成员变量，还是函数形参？答案是形参year = year;}private:int 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;};

一般都是加个前缀或者后缀标识区分就行了

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

4.1 访问限定符

C++实现封装的方式：

• 用类将对象的属性与方法结合在一块，让对象更加完善，
• 通过访问权限选择性的将其接口提供给外部的用户使用
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ph8effS-1680413354358)(D:\自学内容\blog\博客图片\类和对象图片\1_1.png)]

【访问限定符说明】

• public,很好理解对吧，中文意思“公共的”，见词知意，public修饰的成员在类外可以直接被访问。
• protected和private，中文意思分别是“受保护的”“私有的”，它们修饰的成员在类外不能直接被访问，这里的protected和private是类似的。
• 访问权限的作用符的作用域是哪到哪呢？
  • 显而易见，从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
  • 如果后面没有访问限定符，作用域就到 } 即类结束。
• 既然C++兼容C语言的话，那么我们使用struct既可以定义结构体，也能定义类，同时也能使用C++特有的class来定义类，它们分别定义的类的区别是什么呢？
  • class的默认访问权限为private，struct为public(因为struct要兼容C)
  • 这是什么意思呢？举个例子
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXxVVrd0-1680413354359)(D:\自学内容\blog\博客图片\类和对象图片\1_2.png)]
  • 使用class默认的访问权限是private，不支持外部访问，如果使用struct呢？
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wqrMvJgi-1680413354360)(D:\自学内容\blog\博客图片\类和对象图片\1_3.png)]
  • 完全正常，这就是struct和class在访问权限上的区别，也让我们看到public和private的区别

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

4.2 封装

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

但是在类和对象阶段，主要是研究类的封装特性，

那什么是封装呢？

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

举个例子：

对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、

通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，

完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MR2917PD-1680413354360)(D:\自学内容\blog\博客图片\类和对象图片\1_4.png)]

但对于计算机使用者而言，不用关心内部核心部件，

比如主板上线路是如何布局的，CPU内部是如何设计的等，

用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。

因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，

仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ctNog7fV-1680413354360)(D:\自学内容\blog\博客图片\类和对象图片\1_5.png)]

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

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

5.类的作用域

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

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

就像这样

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

6.类的实例化

什么是类的实例化？

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

这是什么意思？

类是对对象进行描述的，是一个模型一样的东西，

限定了类有哪些成员，定义出一个类并没有分配实际

的内存空间来存储它；

比如：入学时填写的学生信息表，

表格就可以看成是一个类，来描述具体学生信息。

也可以这样理解

类实例化出对象就像现实中使用建筑设计图建造出房子，

类就像是设计图，只设计出需要什么东西，

但是并没有实体的建筑存在，同样类也只是一个设计，

实例化出的对象就是建出来的房子，所以对象才能实际存储数据，占用物理空间

所以这样理解的话，一个类可以实例化出多个对象，

实例化出的对象占用实际的物理空间，存储类成员变量

7.类的对象大小的计算

前面说实例化出的对象占用实际的物理空间，存储类成员变量，

类中既可以有成员变量，又可以有成员函数，

那么它是怎么存储的？我们应该怎么计算呢？

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

试着推导一下

假设一

假设对象中包含类的各个成员

我们会发现，如果对象包含了类所有的成员变量和函数，会造成空间的浪费，因为每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？这就引出假设二。

假设二

假设代码只保存一份，在对象中保存存放代码的地址

诶，好像有点意思，等会儿测试一下，这里还有一种可能

假设三

只保存成员变量，成员函数存放在公共的代码段

假设有了，现在我们来验证一下

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

对上面代码，我们分别使用sizeof计算一下它的大小，

但是在此之前，我们先试着推导一下，类之前就是结构体的升级版嘛

所以按照结构体内存对齐规则计算一下，

这里我们简单复习一下它是什么

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

其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8

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

如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

按照这样说的话，函数一般是以地址的形式存储的，也就是4字节，我们先猜它是这样。

那么A1就是8，A2就是4，A3就是0

验证一下

哦豁，怎么和我们猜的不一样？我们把A1、A2的函数去掉看一下

不变

现在就可以总结一下了，

• 类中既有成员变量，又有成员函数，它的实际大小就是成员变量之和，当然也要注意内存对齐
• 类中仅有成员函数或者类中什么都没有（空类），会比较特殊，编译器给了空类一个字节来唯一标识这个类的对象

懂了吧

8.类成员函数的this指针

8.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;} class Date{public:void Init(int year, int month, int day){Date::year = year;//和上面代码效果一样，也可以这样理解_month = month;_day = day;}private:int year;int _month;int _day;};int main(){Date d1;d1.Init(2022, 1, 15);return 0;}

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

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

8.2 this指针的特性

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

只能在“成员函数”的内部使用

this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

真实情况就像这样

this指针是“成员函数”第一个隐含的指针形参，一般情况是在栈中（形参），有些编译器会通过ecx寄存器自动传递，不需要用户传递

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5E4ZhEiu-1680413354365)(D:\自学内容\blog\博客图片\类和对象图片\1_14.png)]

根据上述结论，我们看看下面两段代码

// 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正常运行，2运行崩溃

为什么呢？

这与this->a 对空指针的解引用有关

第一段代码中的p虽然是空指针，但是p调用成员函数不会编译报错，

因为空指针不是语法错误，编译器检查不出来，

而且也不会出现空指针访问，因为成员函数里面没有调用对象，

所以它不会报错，而第二段代码却报错了，

对了这里p会作为实参传递给隐藏的this指针哦

8.3. C语言和C++实现Stack的对比

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相关操作函数有以下共性：

• 每个函数的第一个参数都是Stack*
• 函数中必须要对第一个参数检测，因为该参数可能会为NULL
• 函数中都是通过Stack*参数操作栈的
• 调用时必须传递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语言中需用用户自己维护。

respect !

下篇见！