一、类和对象的历史由来

二、面向过程和面向对象的初步认识

三、类

1.引子

2.类的定义

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

⭕访问限定符

🚩访问限定符解释说明

🚩struct 与 class 的区别

1. 默认访问级别：

2. 继承权限（默认的继承方式）：

3. 成员函数访问权限：

⭕封装

🚩封装的概念

🚩封装的优点

⭕面向对象的三大特性（封装、继承、多态）

1. 封装（Encapsulation）

2. 继承（Inheritance）

3. 多态（Polymorphism）

4.类的作用域

5.类的实例化

⭕访问类的成员

6.类对象模型

🥝类对象的存储方式

🥝计算类对象大小

🥝结构体内存对齐规则

7. this 指针

⭕概念

⭕this指针的特点

前言

前面我们讲了C语言的基础知识，也了解了一些数据结构，并且讲了有关C++的命名空间的一些知识点以及关于C++的缺省参数、函数重载，引用和内联函数。也相信大家都掌握的不错，接下来博主将会带领大家继续学习有关C+＋比较重要的知识点——类和对象。下面话不多说坐稳扶好咱们要开车了。

一、类和对象的历史由来

C++中类和对象的历史由来可以追溯到C++的前身——C语言C语言是一种面向过程的编程语言，它强调程序的过程和函数的调用。然而，随着软件开发的复杂性增加，人们意识到需要更高级的编程模型来处理更大规模的项目。

在1970年代，面向对象编程 (object-OrientedProgramming，简称OOP)开始引起人们的关注。AlanKay被认为是面向对象的先驱之一，他在1970年代初提出了Smalltalk语言，这是世界上第一种完全面向对象的编程语言。

C++的设计师Bjarne Stroustrup受到Smalltalk的影响，在1980年代早期开始着手开发一个面向对象的扩展C语言。他在C语言的基础上添加了类 (class)和对象(object)的概念，使得程序员可以使用高级的面向对象编程方法进行开发。

Stroustrup的工作最终在1983年的C++发布了第一个版本C++从C语言继承了大部分语法和特性，并在其基础上添加了面向对象编程的支持。

在C++中，类是面向对象编程的核心概念。一个类定义了-组数据和操作这些数据的方法。类可以看作是对象的蓝图或模板，描述了对象应该具有的属性和行为。

对象是类的实例化。当使用类时，我们可以创建一个或多个对象，每个对象都有自己的状态和行为。对象可以将具体的数据存储在类的数据成员中，并通过类的成员函数来操作这些数据。

通过引入类和对象的概念，C++提供了一种更高级的编程模型，使程序员能够更好地组织和管理代码。面向对象编程的主要优势在于它提供了封装、继承和多态等特性，可以提高代码的可重用性、可维护性和扩展性。

二、面向过程和面向对象的初步认识

面向过程(Procedural Programming)和面向对象 (Object-Oriented Programming)是两种不同的编程思想和方法。

面向过程是一种基于任务的编程范式，它将程序视为一系列顺序执行的步骤或过程，并通过合适的数据结构来处理数据。在面向过程编程中，程序的主要逻辑是由一系列函数或过程定义的，这些函数或过程接受输入数据并产生输出结果。它将问题分解为若干个模块，每个模块按照特定的顺序执行，最后得到问题的解决方案。面向过程编程通常关注解决问题的步骤和过程。

面向对象是一种基于对象的编程范式，它将程序视为一组相互作用的对象集合。在面向对象编程中，问题的解决方案由对象之间的交互和消息传递来实现。每个对象都有自己的状态和行为，对象之间通过方法调用相互交互，共同解决问题。面向对象编程强调程序的组织结构和模块化，以及封装、继承和多态等概念

面向过程和面向对象都有各自的优势和适用场景。面向过程适合于一些简单的问题和算法，它通常比较直观和高效。而面向对象更适合于大型、复杂的系统开发，它能够提高代码的可维护性和可重用性，并且能够更好地模拟现实世界的问题。

总的来说，面向过程关注步骤和过程，面向对象关注对象和交互根据具体的需求和问题，选择合适的编程思想和方法可以更好地解决相应的问题。

三、类

1.引子

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈（详细介绍），结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数这就是C++中的“类”

typedef int DataType;
struct Stack
{
    void Init(size_t capacity)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (nullptr == _array)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(const DataType& data)
    {
        // 扩容
        _array[_size] = data;
        ++_size;
    }
    DataType Top()
    {
        return _array[_size - 1];
    }
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
    DataType* _array;
    size_t _capacity;
    size_t _size;
};
int main()
{
    Stack s;
    s.Init(10);
    s.Push(1);
    s.Push(2);
    s.Push(3);
    cout << s.Top() << endl;
    s.Destroy();
    return 0;
}

上面结构体的定义（C++模式下定义），在C++中更喜欢用class（类）来代替。

2.类的定义

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

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

🔴类中的函数称为类的方法或者成员函数。

class className   // class为定义类的关键字，ClassName为类的名字
{

    // 类体：由成员函数和成员变量组成

}; // 一定要注意后面的分号

类的两种定义方式：

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

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

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

⭕访问限定符

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

🚩访问限定符解释说明

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

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

🚩struct 与 class 的区别

在C++中，struct和class的主要区别可以总结三点，具体如下：

1. 默认访问级别：

- struct的成员默认是公共的（public），可以在外部访问。
- class的成员默认是私有的（private），只能在类内部访问。

2. 继承权限（默认的继承方式）：

- struct默认是公共继承（public inheritance），基类中的公共、受保护和私有成员在派生类中访问权限保持不变。
- class默认是私有继承（private inheritance），基类中的公共和受保护成员在派生类中变为私有成员。

3. 成员函数访问权限：

- struct的成员函数默认是公共的，可以在外部访问。
- class的成员函数默认是私有的，只能在类内部访问。

除了上述的区别，struct和class在其他方面是相似的，比如它们都可以拥有构造函数、析构函数、静态成员、友元等。此外，从语法角度来看，在定义成员变量和成员函数时，struct和class使用的语法是一样的。

需要注意的是，这些默认行为可以通过指定访问修饰符来改变，因此可以在struct中使用私有成员，也可以在class中使用公共成员。然而，使用struct和class时的惯例和编程风格不同，通常struct更常用于表示纯粹的数据结构，而class则更常用于面向对象的编程，并且强调封装和数据隐藏的概念。

⭕封装

🚩封装的概念

在C++中，封装（Encapsulation）是一种面向对象编程的重要概念，它用于将数据和操作数据的函数（即成员函数）组合在一起，形成一个类（class）。封装在编程中的主要目标是隐藏类的内部实现细节，只暴露必要的接口给外部使用，以提高代码的可维护性、可重用性和安全性。

封装通过将数据成员声明为私有（private）或受保护（protected），并将成员函数声明为公共（public）或受保护（protected）来实现。私有成员只能在类的内部访问，外部无法直接访问；公共成员可以在类的外部访问。

🚩封装的优点

⭕数据隐藏：私有成员对外部是不可见的，防止了直接访问或修改类的数据，确保了数据的安全性。
⭕接口统一性：公共成员函数提供了类的统一接口，外部只需通过这些接口操作类的数据，不必知晓具体实现细节。
⭕代码隔离：类的内部实现细节可以独立于外部代码进行修改，不会影响外部代码的正确性。
⭕代码复用：封装可促进模块化设计，将类的实现细节隐藏起来，可以方便地复用类的接口而不必关心内部实现。

通过良好的封装，可以实现代码的模块化和抽象，隐藏类的内部细节，降低了代码的耦合性和维护成本，同时提高了代码的可读性和安全性。

⭕面向对象的三大特性（封装、继承、多态）

1. 封装（Encapsulation）

封装是将数据和操作数据的函数（即成员函数）封装在一个类中，通过将数据成员声明为私有（private）或受保护（protected），并将成员函数声明为公共（public）或受保护（protected），来实现对成员的访问控制。封装隐藏了类的内部实现细节，只暴露必要的接口给外部使用，提高了代码的可维护性、可重用性和安全性。

2. 继承（Inheritance）

继承是一种机制，它允许我们创建新的类（称为派生类或子类），从一个已有的类（称为基类或父类）继承属性和行为。派生类可以通过继承来获得基类的数据成员和成员函数，并且还可以添加自己的额外成员或重新定义基类的成员。继承实现了代码的重用和层次化的类组织，提高了代码的灵活性和可扩展性。

3. 多态（Polymorphism）

多态是指同一个操作可以在不同的对象上产生不同的行为。多态通过继承和虚函数（Virtual Function）来实现。当基类的指针或引用指向派生类的对象时，通过虚函数的动态绑定机制，可以在运行时决定调用哪个类的成员函数，实现了动态多态性。多态提高了代码的灵活性和可扩展性，使得代码更具有可读性和可维护性。

✅这三大特性共同构成了面向对象编程的基石，使得代码更易理解、维护和扩展。同时，它们也提供了更好的代码重用性和可组合性，使得面向对象编程成为一种强大而广泛应用的程序设计范式。

4.类的作用域

在C++中，类的作用域（Scope）指的是类声明所定义的标识符的可见性和访问性范围。类的作用域可以分为两个方面：

1. 类的成员作用域：类的成员作用域指的是在类定义内部声明的成员的可见性和访问范围。成员包括数据成员（变量）和成员函数。在类内部声明的成员默认是私有的（private），只能在类内部访问。可以使用访问修饰符（public、protected、private）来控制成员的访问权限。例如：

class MyClass {
public:
    int publicMember;    // 公共成员，在类外部可访问
protected:
    int protectedMember; // 保护成员，在派生类内和类内部可访问，类外部不可访问
private:
    int privateMember;   // 私有成员，仅在类内部可访问，类外部不可访问
};

2. 对象的作用域：对象的作用域指的是创建的类对象对标识符的可见性和访问范围。在创建类对象时，对象名在局部作用域中定义，并且只在该作用域内有效。例如：

void myFunction() {
    MyClass obj;
    obj.publicMember = 10;   // 可以访问公共成员
    // obj.privateMember = 20; // 错误，无法访问私有成员
}

在作用域结束时，对象和对象的成员都会被销毁。需要注意的是，类的静态成员具有特殊的作用域规则。静态成员不与特定的对象关联，而是与类本身相关联。静态成员在类的作用域中可见，可以通过类名和作用域解析运算符（::）来访问。例如：

class MyClass {
public:
    static int staticMember;  // 静态成员
};

int MyClass::staticMember = 0;  // 静态成员定义和初始化

void myFunction() {
    MyClass::staticMember = 10;   // 通过类名访问静态成员
}

总的来说，C++中类的作用域决定了在不同的上下文中如何访问类的成员。在类内部，可以直接访问所有成员；在对象作用域下，可以通过对象名访问公共成员；在类作用域下，可以通过类名访问静态成员。

5.类的实例化

用类类型创建对象的过程，称为类的实例化，类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

⭕访问类的成员

调用成员函数：
通过对象名（或指针/引用）和成员访问运算符".“（或”->"）来调用类的成员函数。可以使用类定义的公共成员函数对对象进行操作。
访问成员变量：
通过对象名（或指针/引用）和成员访问运算符".“（或”->"）来访问类的成员变量。可以使用类定义的公共成员变量获取或修改对象的状态。

// 类定义
class MyClass {
public:
    int myInt;  // 成员变量

    void myFunction() {
        cout << "Hello from MyClass!" << endl;
    }  // 成员函数
};

int main() {
    // 声明并创建对象
    MyClass obj;
    
    // 使用对象调用成员函数和访问成员变量
    obj.myInt = 42;
    obj.myFunction();
    
    return 0;
}

在上述示例中，通过"MyClass"类定义了一个类，包括一个整型的成员变量"myInt"和一个成员函数"myFunction"。在main函数中，声明一个名为"obj"的对象，通过对象名"obj"访问成员变量和调用成员函数。

6.类对象模型

🥝类对象的存储方式

类的成员变量和成员函数的存储方式有所不同。

1. 类成员变量的存储方式：
⭕类的成员变量通常存储在类的对象中。
⭕对象中的成员变量在类的实例化时被创建，并与对象的实例一起分配内存。
⭕每个对象都有自己的成员变量副本，它们存储在对象的内存空间中。

2. 类成员函数的存储方式：
⭕类的成员函数通常不会存储在类的对象中，而是存储在类的代码段中。
⭕成员函数是类的公共接口的一部分，它们被所有类的实例共享。因此，所有对象在共享的代码段中使用相同的成员函数实现。
⭕不同对象间共享相同的成员函数，节省了内存空间。

示例代码：

#include <iostream>

using namespace std;

class MyClass {
public:
    int myInt;  // 成员变量

    void myFunction() {
        cout << "Hello from MyClass!" << endl;
    }  // 成员函数
};

int main() {
    MyClass obj1;  // 创建两个对象
    MyClass obj2;

    obj1.myInt = 42;  // 对象1设置成员变量
    obj2.myInt = 10;  // 对象2设置成员变量

    obj1.myFunction();  // 调用成员函数
    obj2.myFunction();

    return 0;
}

在上述示例中，每个对象（`obj1`和`obj2`）都包含一个独立的成员变量`myInt`，它们分别存储在各自对象的内存空间中。然而，`myFunction`成员函数只存在一份实现，被所有对象共享。

需要注意的是，成员函数在调用时会自动传递一个隐式参数，即指向调用对象的指针（`this`指针），使得成员函数能够访问对象的成员变量和其他成员函数。这个`this`指针指向调用该成员函数的对象的内存地址（在本文章后面会提及‘this’指针）

总的来看：类的成员变量存储在类的对象中，而类的成员函数存储在类的代码段中，被所有对象共享。

🥝计算类对象大小

在C++中，可以使用`sizeof`运算符来计算类对象的大小，以下是一个示例，展示了如何计算类对象的大小：

#include <iostream>

using namespace std;

class MyClass {
public:
    int myInt;
    double myDouble;
    char myChar;
};

int main() {
    MyClass obj;

    size_t size = sizeof(obj);
    cout << "Size of MyClass object: " << size << " bytes" << endl;

    return 0;
}

需要注意的是，类对象的大小可能会受到编译器、编译选项和对齐规则的影响，因此不同的环境下可能会得到不同的结果。此外，成员变量的顺序和对齐方式等因素也可能影响类对象的大小。

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
🚨注意：空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

🥝结构体内存对齐规则

在C++中，结构体（struct）的内存对齐规则被用来优化内存访问效率，减少存储碎片和内存访问的开销。结构体的内存对齐规则如下：

对齐原则：
- 结构体的起始地址必须是其最宽基本类型成员大小的倍数。
- 结构体的每个成员相对于结构体的起始地址的偏移量必须是其自身大小的倍数。
默认对齐方式：
- 结构体成员的默认对齐方式通常是按照其自身大小进行对齐。
- 基本数据类型的默认对齐方式通常是按照其字节大小进行对齐。
强制对齐：
- 可以使用特定的对齐属性来显式指定结构体成员的对齐方式，通过在成员声明前加上"attribute((aligned(x)))“（GCC编译器）或"alignas(x)”（标准C++11及以后）来实现。
- 强制对齐可以用来解决特定的对齐需求，比如和硬件相关的数据结构。

需要注意的是，不同的编译器可能会对结构体的对齐规则有所差异，尤其是在不同的编译器选项或编译器版本中。可以使用编译器提供的对齐指令或预处理器的宏来控制结构体的对齐方式。

7. this 指针

⭕概念

this指针是一个隐式的指针，它指向当前对象的地址。它只能在非静态成员函数中使用，用于访问对象的成员变量和成员函数。当你在一个成员函数中使用成员变量或调用成员函数时，编译器会自动将this指针作为一个隐式参数传递给该函数。这样，你就可以使用this指针来访问当前对象的成员。简单说就是：当使用C++编写类的成员函数时，隐含地提供了一个指向当前对象的指针，即this指针。它是指向当前对象的常量指针。

⭕this指针的特点

🔴 this指针是一个隐式的指针，无需显式声明。它在每个非静态成员函数内部都是可用的。

🔴 this指针被自动传递给类的非静态成员函数。这意味着在调用成员函数时，编译器会自动在参数列表中添加一个额外的隐式参数，不需要用户传递。

🔴 this指针是一个常量指针，不能修改它所指向的对象。这是因为它指向了当前对象本身，它的值在对象的生命周期内不会改变。

🔴 当使用this指针访问成员变量或调用成员函数时，可以使用箭头运算符（ - >）来替代点运算符（ . ）。

下面是一个使用this指针的代码：

class MyClass {
public:
    void setX(int x) {
        this->x = x;  // 使用this指针访问成员变量
    }

    int getX() {
        return this->x;  // 使用this指针返回成员变量的值
    }

    void printAddress() {
        cout << "The address of this object is: " << this << endl;  // 使用this指针打印对象的地址
    }

private:
    int x;
};

int main() {
    MyClass obj;
    obj.setX(10);
    cout << "The value of x is: " << obj.getX() << endl;
    obj.printAddress();
    return 0;
}

在上面的代码中，`setX`函数使用this指针来访问成员变量' x ' ，' getX '函数使用this指针返回成员变量的值，' printAddress ' 函数使用this指针打印对象的地址。在main函数中，我们创建了一个MyClass对象obj ，并调用了这些成员函数。

🚨需要注意的是，当成员变量和参数或局部变量同名时，this指针可以用于区分它们，以明确指示要操作的是成员变量。