类与面向对象编程

第 11 章笔记

结构体与对象聚合

将多个对象放置聚合在一起，视作整体
结构体的定义：需要接分号结束（C语言的原因，需要一个分号来确定是结构体的定义）
结构体的声明：incomplete type

// 不可以声明结构体
Str1 myStr1; //error
// 但可以声明结构体的指针
Str1* myStr1;

一处定义原则：类和结构体都处于单元级别。每个单元都只能有一个结构体定义，但程序可能拥有多个结构体定义。编译的时候结构体必须对翻译单元可见。

数据成员的初始化

不能使用 auto 定义数据成员：

// 结构体定义
struct Str
{
     // 类中初始化
    int x = 3;
    decltype{3} y; // C++11：使用 decltype 定义变量
    // 不能使用 auto
    auto z; // error
    // 可以使用 const，引用，限定
    const int g = 3;
   
};

// 隐式定义了结构体的内部成员
// 定义发生在这里，而不是在结构体中
Str m_str; 

// 类中元素会进行默认初始化
// 默认初始化跟结构体中的变量排序和数量有关
Str m_str2 = {3}; // x = 3, y = 0, g = 3

//C++20，聚合初始化的指派
Str m_str3 = {.x=3, .y = 4, .g = 5};

mutable 限定符

当结构体对象为 const 时，无法改变结构体内部的值
这时可以将需要修改的变量修饰为 mutable，即可对其修改

struct Str1
{
   mutable int x = 0;
};
// 修改常量对象中的变量
const Str1 myStr1;
myStr1.x = 1;

静态数据成员

多个对象共享的类数据成员
一般静态成员在类外定义，const 静态成员可以在类内初始化

struct Str
{
    // 声明
    static int x;
    int y;
};

// 类外定义(c++98)
// Str::表明 x 属于 Str 域内
// 为了共享，专门引入一个文件用于定义
// 编译器处理顺序 header->发现静态成员->寻找其他翻译单元内的定义，引入定义编译结构体
int Str::x;

int main(int argc, char const *argv[])
{
    Str str1;
    Str str2;

    str2.x = 100;
    // 两个 x 都为100
    std::cout << str1.x << " "<< str2.x << std::endl;

    return 0;
}

c++98 中提供了在类中可以定义静态成员的功能。这是因为某些静态成员需要作为类型的一部分进行初始化。比如使用静态成员作为数组的长度，此时该静态成员是常量。如果使用该静态成员定义数组，如果不允许在类中初始化静态成员，那么对应的数组将无法定义。因此 C++ 98 中规定可以在类中这么用： const static int array_size = 100; 实际上，编译器会将 array_size 替换为 100。

其限制在于，不能使用其地址对其访问（undefined reference）。因为值替换是编译期行为，不会构造存储空间给 array_size。但是通过地址访问时运行期行为。此时，只有使用类外静态成员定义，才能构造该常量静态成员的地址，才可以通过地址访问。

内联静态成员

C++ 17 中提供了内联静态成员。由于静态成员和内联函数的相似性（多个翻译单元 / 多个类对象共用一份），因此可以如下方式在类中声明静态成员：

// 只保留一份静态成员的定义
// 不需要是常量
// 还可以使用 auto 推断成员
struct Str
{
    inline int array_size = 100;
    inline auto array_size2 = 100;
   
};
// 还可以直接进行修改
Str str;
str.array_size = 50;
Str *strPt = &str;
// 直接访问需要指定域
// 静态成员能被所有对象访问
Str::array_size;
// 可以通过指针访问
strPt->array_size;

一般会专门提供一个文件用于存放静态成员的定义。

类内部声明相同类型的静态数据成员

// 不使用 inline
// 类外定义
Str Str::member; 
// 使用 inline 
// 类中使用 inline 是不完全类型，需要在外部定义
inline Str Str::member;

成员函数

在结构体中定义的函数，作为结构的一部分
结构体与其成员和成员函数组成类，类是一种抽象数据类型
结构体和外部的桥梁：对内操作数据，对外提供接口
关键字 class
类拥有自己的域

声明和定义

类内定义在类结构简单的时候使用
类外定义在类结构复杂的的使用；外部定义做成链接库，用户通过 header 去调用

class Str
{
    // 类内定义
    // 隐式内联，避免多次包含 header 导致的重定义
    void fun1() {};

    // 类外定义的声明
    void fun2();
};

// 类外定义
// 非内联
// 将声明存储于 Header, 将定义存储于另外一个翻译单元
void Str::fun2() {};
// 类外内联定义
inline void Str::fun2() {};

类会经过编译器的两遍处理

类中处理函数和数据成员的逻辑与外部不同。简单来说，不是通过从上到下的顺序来执行的。对于类来说，成员函数较为重要（接口），往往实现会先写函数（约定俗成）。这种情况下，如果按照外部的编译顺序，当函数调用内部数据成员时，成员是不可见的。为了处理这个问题，C++ 会对类进行两遍处理：

函数可见时，并不会立即处理函数，而是接着处理其余的部分
函数内部的逻辑会在第二次扫描中处理。

两次处理区分的是函数外部的内容与函数内部的逻辑内容。

尾部类型返回与成员函数

通常情况下，C++ 在做函数的类外定义时，必须指定所有参与定义部分的来源（域）

struct Str
{
    int x;
    using MyRes = int;
    MyRes fun();
};

// 注意返回类型 MyRes 是在类中定义的
// 因此必须指定域
Str::MyRes Str::fun()
{
    return x;
}

但如果使用尾部返回的写法，C++可以自动推断出该返回类型的来源：

// 通常返回复杂的类型可以使用这种写法
auto Str::fun() -> MyRes
{
    return x;
}

成员函数与this指针

this 指针指向了当前的对象
this 指针可以配合箭头操作符使用，指定当前变量的域（访问类变量）

struct Str
{
    int x = 3;
    // 实际上参数是 fun(Str *this)
    void fun()
    {
        std::cout << x << std::endl;
    }
    void fun2(int x)
    {
        // 如果不使用 this, 则返回的是 fun2 的参数 x(局部变量)
        // std::cout << x << std::endl;
        // 使用 this 返回类对象中的 x
        std::cout << this->x << std::endl;
    }
};

int main(int argc, char const *argv[])
{
    Str myStr;
    Str* myStrP = &myStr;
    // 调用的是 Str::fun(&myStr)
    myStr.fun();
    // 使用箭头操作符
    // 等同 (*myStr).fun2()
    // 打印 类中的 x，值为 3
    myStrP->fun2(5);

    return 0;
}

this 指针的类型是指向类对象的指针。由于指向不能变换，this 本身不能被修改；但因为我们要通过 this 修改对象中的内容，因此 this 是 top-const 类型的指针（const Str*）

常量成员函数

由于 this 只能保证自身无法被修改，当需要阻止成员函数修改类中数据成员时，我们需要将成员函数声明为常量成员函数：

// 不允许该接口改变类成员
// 实际上，是将 this 的类型从 const Str* 转换为了 const Str* const
void fun() const {...}

基于 const 的重载

基于上述的特性，C++ 允许同名的函数基于 constness 进行重载：

// 这是两个不同的函数
// 参数类型不同
void fun() {...} // plain this, const Str*
void fun() const {...} // low-const this, const Str* const

成员函数的查找与隐藏

函数内部的名称 > 类内部的名称 > 类外部的名称
都找不到会返回错误
需要访问指定的名字时，需要指定域（依赖性查找）

静态成员函数

可以被所有类对象共享的函数
用于描述与类（而不是对象）相关的内容
- 比如表述固定长度数组的类，其数组长度与类对象的具体信息无关。如果想取回该类所表示数组的长度信息，可以使用静态成员函数来处理。
可以返回静态成员
只能对共享对象进行操作

从原理上来说，成员函数使用 this 指针来访问内部成员。而静态成员函数因为被共享，其参数不再是 this（编译器也不可能知道当前的类对象是哪个）。因此，对象无法通过静态成员函数来访问当前对象中的普通成员。

使用静态成员函数的两种方式：

// 使用静态函数返回静态成员
struct Str {
    static int size()
    {
        return x;
    }
    inline static int x = 11;
};
// 对象调用
myStr1.fun();
// 域调用
Str::fun();

注意局部静态成员与类静态成员的区别

static int size()
{
    // 局部静态成员，生存周期从函数被调用到程序结束
    static int x; 
    // 会返回上面的 x，而不是类中静态成员 x
    return x;
}

这个特性可以利用起来。当处理需要按需使用的共享资源时，可以将静态存储于静态成员函数中；这样只有调用静态成员函数时，才会申请该资源。
另外一种应用更有名：singleton

基于引用限定符的重载

// 该重载基于调用者的左右值属性来重载
// C++11 的写法：不可与 98 混用。只要后面有一个加了 &，那么所有的重载都要加 (&)
// 调用者为左值时调用
void foo() &;
// 调用者为右值时调用
void foo() &&;
// 调用者为常量左值时
void foo() const &;
// 通常不使用
void foo() const &&;

关键字：ref-qualified-member-functions。

访问限定符和友元

允许对内部数据进行封装，再使用成员函数作为外部接口
struct 的默认访问权限是 public，class 的默认访问权限是 private
三种限定符：
- private：只允许类域内部的访问
- public：所有类外都可访问
- protected：只允许类域内部和子类域内部访问

友元函数 / 类

允许从类外访问类中的私有成员
关键字 friend
声明在类中声明

友元破坏封装，慎用
友元的权限由被访问的类提供
友元的访问是单向的
友元不受访问限定符的限定

函数 / 类的声明可以以友元的方式在类中声明

函数的定义受声明顺序的影响，因此在某些函数的定义牵涉到在其之后（不可见的）类型时，需要对这些类型进行前置声明。如果函数会被定义为友元函数，C++ 允许以友元的方式在类中完成首次声明：

class Str
{
    // fun() 被声明，并视作为 Str 的友元函数
    friend void fun();
    // Str2 类被声明，并被视作 Str 的友元类
    friend class Str2;
    
    // 注意：使用域限定符会破坏友元的首次声明
    // 此时必须要提前对其作出声明
    // friend void ::fun();
    
    int x = 100;
};

class Str2 {
public:
    void print()
    {
        Str str;
        std::cout << str.x << std::endl;
    }
};

void fun()
{
    Str str;
    std::cout << str.x << std::endl;
}

友元函数的类内定义和类外定义

在类中定义的友元函数会被隐藏：

class Str
{
    // 隐藏友元
    // fun() 是友元，不是成员
    // 因此 fun() 的作用域处于 Str 外部
    // 此时编译器会隐藏友元的首次定义，也就是认为 fun() 并没有声明
    friend void fun()
    {
        Str val;
        std::cout << val.x << std::endl;
    }
    int x = 100;
};

int main(int argc, char const *argv[])
{
    // undefined
    fun();
    
    return 0;
}

减轻编译器负担：友元函数的声明会使搜寻范围扩大。
使用友元函数的类外定义即可解决问题
或使用参数，使用 const 实参类型的依赖查找来实现

class Str
{
    // 使用实参依赖关系进行类中的友元函数定义
    friend void fun2(Str& val)
    {
        std::cout << val.x << std::endl;
    }
    int x = 100;
};

int main(int argc, char const *argv[])
{
    Str val;
    fun2(val);
    return 0;
}

特殊成员：构造/析构/拷贝

构造函数

与类同名，无返回值，允许重载

委托构造函数

某个构造函数调用已有构造函数的功能，提高复用性

class Str
{
    public:

    // 委托构造函数
    // 委托单参数版本给 x 赋值 3

    // 2. 再执行委托构造函数
    Str():Str(3) { // 最后执行委托构造函数的函数体}

    // 1. 先执行被调用的函数
    Str(int x)
    {
        this->x = x;
    }

    void fun() const 
    {
        std::cout << x << std::endl;
    }
    private:
    int x;
};

int main(int argc, char const *argv[])
{
    Str str;
    str.fun();
    return 0;
}

构造函数的初始化列表

初始化：使用初始值
赋值：复制，使用函数体
提高初始化的性能
不能通过拷贝构造的成员必须通过初始化列表初始化（比如引用）
初始化顺序取决于声明顺序，与初始化列表的顺序无关
初始化列表会覆盖类成员的初始化

class Str
{
    public:
    Str(const std::string& strVal)
    {
        // val 以默认初始化构造
        // 复制初始化，低效
        val = strVal;
    }

    // 初始化列表版本
    // 可读性：初始化列表需要与声明顺序一致
    // 初始化列表会覆盖类内成员初始化
    Str(const std::string& strVal, int& refSource): val(strVal), y(0),ref(refSource) {}

    std::string val;
    // y 被初始化为 0，而不是 2
    int y = 2;
    // 必须通过初始化列表初始化
    int& ref;
};

C++ 中构造与销毁是一个栈的结构，先创建后销毁。如果变量的初始化根据初始化列表中的顺序进行，那么变量的构造销毁顺序就是基于构造函数来进行。这样做会导致 C++ 必须记录每一个构造函数的初始化列表顺序来进行构造和销毁，这对性能会有非常大的影响。因此，初始化顺序只与类中成员声明顺序有关。

默认构造函数

不需要提供任何参数就能进行初始化的构造函数
如果类中没有定义构造函数，则编译器会自动合成一个默认构造函数
合成默认构造函数通过拷贝的方式来进行构造，如果元素中存在无法拷贝初始化的类型，那么合成默认构造函数无法创建
对于抽象数据类型，会调用该类型的默认构造函数
调用缺省构造函数不应该加上括号：Str m 而不是 Str ()，后者：Str 是返回类型，a() 是函数
显式定义合成默认构造函数：Str() = default;

单一参数构造函数

可以视作一种类型转换函数（比如从buit-in 类型到抽象类型）

struct Str
{
    Str(int x)
        : val(x)
        {}

    int val;
};

void fun(Str str)
{}

int main(int argc, char const *argv[])
{
    // 内置->抽象：将 int 类型转化为了 Str 类型
    Str str = 3;
    // 该转换支持隐式转换
    // 函数调用时，int 转换为了 Str 类型
    fun(3);
    return 0;
}

如果希望阻止该转换，则使用 explicit 关键字要求必须采用显式转换

explicit Str(int x): val(x) {}
// 使用括号，大括号显式转化即可
fun(Str{3});
fun(Str(3));
// 或者使用显式的 cast
Str a = static_cast<Str>(3);
fun(a);

拷贝构造函数

用于拷贝相同类型的对象
第一个参数是常量类类型的引用 Foo(const classType& para)

struct Str
{
    Str() = default;
    //拷贝构造函数的定义
    Str(const Str& x):val(x.val) { std::cout << "copy cstr called!"; }

    int val = 3;
};

int main(int argc, char const *argv[])
{
    Str m1;
    // 第一种拷贝方式
    Str m2 = m1;
    // 第二种拷贝方式
    Str m3(m1);
    return 0;
}

为什么使用 const classType& ?

拷贝构造函数需要类对象的拷贝作为参数进行初始化；如果不使用引用，那么参数的传递需要通过拷贝构造函数来进行。这样就进入了一个死循环。

默认拷贝构造函数

// 默认拷贝构造函数的定义
Str(const Str&) = default;

移动构造函数

从输入的对象接过，而不是拷贝资源（类似指针换指向，而不是将指针指向的内容复制到新的空间）
输入的对象不会再使用，所以接收参数的类型是 xvalue，类对象的右值引用 Str(Str&&)
基于 std::move() 实现
偷窃资源之后，传入的对象需要保证是合法的（可访问）
没有拷贝构造函数时会尝试自动合成移动构造函数（如果存在不能移动的成员那么尝试会失败）

class Str
{
public:
    Str() = default;
    Str(const Str&) = default;

    // 拷贝内置类型，移动抽象类型
    // 注意不能加 const，移动本身就会修改类对象的内容，而拷贝不会
    Str(Str&& newStr):val(newStr.val), a(std::move(newStr.a)) { std::cout << "move cstr called." ; }

    // 打印函数
    void fun()
    {
    std::cout << val << " " << a << std::endl;
    }

private:
    int val = 3;
    std::string a = "abc";
};

int main(int argc, char const *argv[])
{

    Str myStr;
    myStr.fun();
    // 调用拷贝构造函数
    Str myCopiedStr = myStr;
    // 调用移动构造函数
    Str myMovedStr = std::move(myStr);
    // 3 是拷贝的，myStr 中存在 3
    // "abc" 是移动的，因此 myStr 中不存在 "abc"
    myStr.fun();
    return 0;
}

编译器能否成功合成特殊函数的逻辑类似：

合成的核心点是对每一个数据成员都采取相同的构造方法（比如拷贝都拷贝，移动都移动）
如果是内置类型，则直接拷贝，如果是抽象类型，则调用抽象类型中对应的构造函数（拷贝构造调用拷贝构造等等）
如果没有对应的构造函数时：
- 拷贝构造会失败
- 移动构造会查看是否有拷贝构造的方式，如果没有，也失败 (C++ 14)

struct Str2
{
    // 没有该构造函数时，Str 也无法使用合成构造函数
    // 构造抽象类型成员时，所有的合成构造函数都会调用其本身的构造函数
    Str2() = default;
    Str2(const Str2&) {std::cout << "copy cstr called."; }
    // 开启或关闭看看区别
    // Str2(Str2&&) {std::cout << "mv cstr called."; }
};

class Str
{
public:
    Str() = default;
    Str(const Str&) = default;
    Str(Str&&) = default;

    // 打印函数
    void fun()
{
    std::cout << val << " " << a << std::endl;
}

private:
    int val = 3;
    std::string a = "abc";
    // 当成员包含抽象数据成员时，会调用对应类型的拷贝 / 移动构造函数
    Str2 str2;
};

int main(int argc, char const *argv[])
{

    Str myStr;
    // 有 Str2 的移动构造函数则会调用移动构造函数
    // 否则，有拷贝构造函数调用拷贝构造函数
    // 否则报错
    Str myMovedStr = std::move(myStr);
    return 0;
}

移动构造函数与异常

异常通常会出现在拷贝过程中
移动操作不涉及拷贝，不会抛出异常
这种情况下，通常使用 noexcept 标记函数，说明该操作不用考虑抛出异常

Str(Str&&) noexcept = default;

不引入异常的好处：

异常会带来额外的逻辑，会带来性能上的损失
移动机制决定了其不能抛出异常。假设移动的过程是从旧的内存区域到新的区域（比如 vector 的扩容），如果移动过程中出现异常，则：
- 旧区域的内容已经被移动
- 内容没有移动到新的区域

结果就会导致数据完全丢失。实际上，vector 的实现中，如果移动构造函数没有 noexcept 时，vector 会在扩容期间调用拷贝构造函数来确保数据安全。

noexcept 也有链式效应。如果上游类型定义了 noexcept 的移动构造函数，那么下游构造函数也必须是不会抛出异常的。否则当下游函数抛出异常，程序将无法处理这种现象。

右值引用对象作为表达式时是左值

// 函数体中的 x 是左值
// 参数的类型是右值引用，意味着可以从里面做移动操作
// 但在具体的执行中，我们决定不移动操作，而是进行访问
// 此时是将 x 作为左值来使用
Str(Str&& x) { std::string temp = x.a; }

Copy & Move Assignment

本质是以类对象为左算子，对 operator= 运算符的重载
返回类型为 Str&，是因为需要支持赋值的右结合的特性；比如 Str3 = Str2 = Str1。正常的逻辑是 Str1 的内容赋值到 Str2 中，再将 Str2 的内容赋值到 Str3 中，因此 Str2 = Str1 应该返回的是 Str2 本身（而不是临时对象）。因此，返回类型应该是 Str&
参数的 constness 与特殊构造函数一致：拷贝不改变参数(const)，移动改变参数
函数返回值为 *this

自我赋值的处理

以移动元素为例，如果参数是指针，通常赋值经过三步：

将被赋值的对象占用的资源释放（通过指针）：也就是 delete ptr；
使用当前的指针指向需要移动的对象所在位置：ptr = rhs.ptr
然后将被移动对象的指针空置，避免不必要的访问：即 rhs.ptr = nullptr

但问题在于，如果赋值的两遍都是同一个对象，上面这套逻辑会在第一步就清除掉所有信息。在第二步进行的时候，无论是 ptr 还是 rhs.ptr，都成为了悬挂指针。解决办法是提前做一次判断：如果赋值运算符两边为同一个对象，则直接返回当前的类对象：

if(&rhs == this) { return *this; }

析构函数

负责对象资源的释放
不需要返回类型，不需要提供参数，与类同名 ~Str()
先创建后释放；内存会在析构函数调用完毕之后才会释放。析构函数的函数体可以用来做一些额外收尾操作（主要是对象的销毁）
如果不主动声明，析构函数会合成一个，内部逻辑是调用类成员自身的析构函数。
析构函数不应该出异常。

特殊成员函数的补充

指针类

class PtrStr
{
public:
    // 构造函数
    PtrStr(): ptr(new int()) {}

    // 拷贝构造函数
    PtrStr(const PtrStr& rhs):ptr(new int())
    {
        std::cout << "call copy cstr\n";
        *ptr = *(rhs.ptr);
    }

    // 拷贝赋值运算符
    PtrStr& operator=(const PtrStr& rhs)
    {
        std::cout << "call copy assignment\n";
        if(this == &rhs)
        {
            return *this;
        }
        // 如果不需要 reallocate
        *ptr = *(rhs.ptr);

        // 如果需要 reallocate
        // delete ptr;
        // ptr = new int(*rhs.ptr);
        return *this;
    }

    // 移动构造函数
    PtrStr(PtrStr&& rhs) noexcept 
        :ptr(rhs.ptr)
    {
        std::cout << "call move cstr\n";
        rhs.ptr = nullptr;
    }
    
    // 移动赋值运算符
    PtrStr& operator=(PtrStr&& rhs)
    {
        std::cout << "call move assignment\n";
        if(this == &rhs)
        {
            return *this;
        }
        delete ptr;
        ptr = rhs.ptr;
        rhs.ptr = nullptr;
        return *this;
    }

    // 析构函数
    // 析构函数只能释放当前对象拥有的资源
    ~PtrStr()
    {
        std::cout << "call dstr\n";
        delete ptr;
    }
private:
    int* ptr;
};

int main(int argc, char const *argv[])
{
    PtrStr myStr;
    PtrStr myCopyStr = myStr;
    PtrStr myMoveStr = std::move(myStr);
    PtrStr myCopyAss, myMoveAss;
    myCopyAss = myCopyStr;
    myMoveAss = std::move(myMoveStr);
    return 0;
}

default 关键字

只对特殊函数有效

delete 关键字

对所有函数都有效
表示函数无法被调用
定义方式：

void fun(int) = delete;

和未声明的区别：一个是无法调用，一个是找不到
- 无法调用的一个大的影响是，某些合成函数不会自动进行合成。
不要为移动构造 / 赋值引入 delete：
- 希望可以拷贝，但不能移动：只需要定义拷贝构造即可。编译器不会合成移动
- 如果不需要拷贝，那么申明拷贝构造为 delete 即可。由于拷贝构造的存在，编译器依然不会合成移动
- C++17以及以后：C++ 17 中，移动初始化会被其他方式顶替。C++17 以后的编译器会忽视被删除的移动构造函数。

特殊成员的合成行为列表

行：用户声明（定义）的特殊函数
列：基于用户声明的特殊函数，编译器是否声明，或者生成合成函数的结果。
红色：可能会被废除的行为（查看标准）

Ref: Engineering Distinguished Speaker Series: Howard Hinnant

字面值类 / 成员指针 / bind

字面值类

字面值类（Literal class）指可以用于构造编译期常量对象类型的类。要求：

所有数据成员必须是数据类型
构造函数必须是 constexpr 或者 consteval 类型的构造函数
必须要有一个平凡的析构函数
成员函数必须是 constexpr 或者 consteval 类型

«WRAP center round tip 100%>

constexpr 函数：可以在编译期和运行期调用的函数
constveal 函数：只能返回编译期常量的函数（意味着其参数也应该是编译期常量）

</WRAP>

C++ 14 之后允许在 constexpr 函数内部实现复杂的逻辑，因此取消了在 C++11 中默认 constexpr 函数的 this 指针只读的限制。

class Str
{
    public:
    // 常量版本
    constexpr Str(int val):x(val) {};
    // 运行期执行版本
    Str(double val):x(val) {};

    // 平凡的析构函数
    ~Str() = default;

    // 接口成员函数
    // 需要是 constexpr 或 consteval
    // C++14 之后默认 constexpr 函数不带 const
    constexpr int fun() const
    {
        return x + 1;
    }
    private:
    // 字面值类型
    int x = 3;
};

// error
// 字面值类要求构造函数的类型必须是 constexpr 或 consteval
constexpr Str Stra(1);

注意 constexpr 与 consteval 的混用问题

由于 constexpr 函数在编译期和运行期均可以被调用；因此 constexpr 内部允许存在运行期的构造函数版本。但如果使用该版本进行构造，那么得到的对象不是编译期常量对象，因此不能调用 consteval 版本的成员函数：

// error, b 不是常量表达式，无法调用 consteval 成员
class Str
{
    //....
    consteval int fun() const
    {
        return x + 1;
    }
}
int main {
    // error, b 不是常量表达式，无法调用 consteval 成员
    Str b(3.0);
    b.fun();
}

类成员指针

C++ 允许定义对指定类域成员进行访问的指针。

类成员指针不支持指针的相减操作。

类成员指针声明

声明只要求有类的声明，不需要类的定义：

class Str
{
    public:
    int x;
    void fun() {};
};
int main(int argc, char const *argv[])
{
// 可以用 auto 简化声明的写法

// 数据成员指针的声明
// 类名 + 指针名
int Str::*mem_ptr = &Str::x;

// 成员函数指针的声明
// 返回类型 + 域::函数指针名 + 参数列表
void (Str::*memFunc_ptr)() = &Str::fun;
}

通过成员指针访问

当通过成员指针访问指定成员时，访问的是具体对象中的成员。因此，成员必须实例化。访问方式有两种：

使用成员指针访问：操作符 .*
使用对象指针访问：操作符 →*

int main(int argc, char const *argv[])
{
    // 访问前必须初始化类对象
    Str obj;
    // 定义类指针
    Str *ptr_obj = &obj;
    // 通过成员指针访问 x
    obj.*mem_ptr;
    // 通过成员指针访问函数 fun
    // 注意括号不能省
    (obj.*memFunc_ptr)();
    // 通过类对象指针访问 x
    ptr_obj->*mem_ptr;
    // 通过类对象指针访问成员函数 fun
    (ptr_obj->*memFunc_ptr)();
}

std::bind

std::bind 允许将成员函数标定到一个特定的对象上，从而使得可以通过调用该对象来对成员函数进行调用。该函数定义于 <functional> 头文件中，写法如下：

std::bind(&className::Function, classInstance, placeholder...);

应用实例：

class MyClass {
public:
    void display(int x) {
        cout << "Display called with value: " << x << endl;
    }

    int add(int a, int b) {
        return a + b;
    }
};

int main() {
    MyClass obj;

    // 使用 std::bind 绑定 display 成员函数
    auto boundDisplay = std::bind(&MyClass::display, &obj, std::placeholders::_1);
    boundDisplay(10);  // 调用 boundDisplay，相当于 obj.display(10)

    // 使用 std::bind 绑定 add 成员函数
    auto boundAdd = std::bind(&MyClass::add, &obj, std::placeholders::_1, std::placeholders::_2);
    int result = boundAdd(5, 7);  // 调用 boundAdd，相当于 obj.add(5, 7)
    cout << "Result of add: " << result << endl;

    return 0;
}

目录