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后，外面访问函数时却标红了。那我们先来谈封装 ——

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

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

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

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

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

接着来介绍访问限定符。

3.2 访问限定符

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

:strawberry:说明 ——

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

【面试题】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. 类的定义

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

:strawberry:在一个项目里，声明放在.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];
}

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

5. 类的对象大小计算

5.1 计算类对象的大小

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

接续4.代码 ——

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

运行结果 ——

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

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

5.2 类对象的存储方式

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

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

来道题叭 ——

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

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

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

运行结果 ——

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

    A2 a2;    A2 b2;

5.3 结构体内存对齐原则

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

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

结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是

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

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

【面试题】

结构体怎么对齐？为什么要进行内存对齐
如何让结构体按照指定的对齐参数进行对齐
什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

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

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

想说的都在图片里了！

:strawberry: 注：

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

6.2 this指针的特性

【面试题】

this指针存在哪里？

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

可以转到反汇编 ——

思考：选？ 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;
}

有趣的是 ——

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9tUrg9wN-1642375004017)(C:\Users\13136\AppData\Roaming\Typora\typora-user-images\image-20220116221848563.png)]$

p是空指针，但是空指针并不是语法错误，编译器检查不出来p调用成员函数不会编译报错。
p调用成员函数，也不会出现空指针访问，因为成员函数本身也不是存在对象里的，这么写确实会给人错觉，但是我们要看清它的本质。
p作为实参传给隐藏的this指针时，只有解引用空指针时，程序会崩溃。不解引用没事。

本文完@边通书

持续更新 ~

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

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

2. 类的引入

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

3.1 封装

3.2 访问限定符

4. 类的定义

5. 类的对象大小计算

5.1 计算类对象的大小

5.2 类对象的存储方式

5.3 结构体内存对齐原则

6. 类成员函数的this指针

6.1 this指针的引出

6.2 this指针的特性

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

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

2. 类的引入

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

3.1 封装

3.2 访问限定符

4. 类的定义

5. 类的对象大小计算

5.1 计算类对象的大小

5.2 类对象的存储方式

5.3 结构体内存对齐原则

6. 类成员函数的this指针

6.1 this指针的引出

6.2 this指针的特性

热门文章

最新文章

相关课程

相关电子书

相关实验场景