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指针