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.类的实例化

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

⭕访问类的成员

1.调用成员函数：

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

2.访问成员变量：

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

// 类定义
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）的内存对齐规则被用来优化内存访问效率，减少存储碎片和内存访问的开销。结构体的内存对齐规则如下：

1.对齐原则：

1. 结构体的起始地址必须是其最宽基本类型成员大小的倍数。
2. 结构体的每个成员相对于结构体的起始地址的偏移量必须是其自身大小的倍数。

2.默认对齐方式：

1. 结构体成员的默认对齐方式通常是按照其自身大小进行对齐。
2. 基本数据类型的默认对齐方式通常是按照其字节大小进行对齐。

3.强制对齐：

1. 可以使用特定的对齐属性来显式指定结构体成员的对齐方式，通过在成员声明前加上"attribute((aligned(x)))“（GCC编译器）或"alignas(x)”（标准C++11及以后）来实现。
2. 强制对齐可以用来解决特定的对齐需求，比如和硬件相关的数据结构。

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

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指针可以用于区分它们，以明确指示要操作的是成员变量。