零基础C++(24) 可调用对象function类

Posted on | In

引言

C++ 提供了多种方式来表示和操作可调用对象，包括传统的函数指针、仿函数（Functors）、Lambda表达式、std::function 和 std::bind 等。这些工具极大地增强了C++的灵活性和表达能力，尤其在处理回调、事件驱动编程和函数式编程时表现尤为出色。

函数指针

函数指针是C++中最基本的可调用对象之一，用于指向普通函数和静态成员函数。

定义与使用

函数指针的定义涉及到函数的返回类型和参数列表。例如，定义一个指向返回 int 且接受两个 int 参数的函数指针：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 定义函数指针类型
int (*funcPtr)(int, int);

// 定义一个普通函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 给函数指针赋值
    funcPtr = &add;

    // 调用函数
    int result = funcPtr(3, 4);
    std::cout << "结果: " << result << std::endl; // 输出: 结果: 7

    return 0;
}

优点与局限性

优点:

  • 简单直观，适用于简单的回调函数。

局限性:

  • 不能捕获上下文（如lambda中的闭包）。
  • 语法相对复杂，尤其是指针的声明和使用。

仿函数（Functors）

仿函数（Functors），又称函数对象（Function Objects），是在C++中重载了 operator() 的类或结构体实例。仿函数不仅可以像普通函数一样被调用，还能携带状态，提供更大的灵活性和功能性。

定义与使用

仿函数是通过定义一个类或结构体，并重载其调用运算符 operator() 来实现的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

// 定义一个仿函数类
struct Adder {
    int to_add;

    // 构造函数
    Adder(int value) : to_add(value) {}

    // 重载()运算符
    int operator()(int x) const {
        return x + to_add;
    }
};

int main() {
    Adder add5(5); // 创建一个添加5的仿函数

    std::cout << "10 + 5 = " << add5(10) << std::endl; // 输出: 10 + 5 = 15

    return 0;
}

特点

  1. 携带状态： 仿函数可以拥有内部状态，通过成员变量存储数据，使其在调用时具备上下文信息。
  2. 灵活性高： 可以根据需要添加更多的成员函数和变量，扩展功能。
  3. 性能优化： 编译器可以对仿函数进行优化，例如内联展开，提高执行效率。

高级示例

仿函数不仅可以执行简单的计算，还可以进行复杂的操作。例如，实现一个可变的仿函数，用于累加多个值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <iostream>

// 可变累加器仿函数
struct Accumulator {
    int sum;

    Accumulator() : sum(0) {}

    // 重载()运算符
    void operator()(int x) {
        sum += x;
    }
};

int main() {
    Accumulator acc;

    acc(10);
    acc(20);
    acc(30);

    std::cout << "总和: " << acc.sum << std::endl; // 输出: 总和: 60

    return 0;
}

使用仿函数的标准库算法

许多标准库算法可以接受仿函数作为参数，使得算法的行为更加灵活和可定制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <vector>
#include <algorithm>

// 仿函数：判断一个数是否大于某个阈值
struct IsGreaterThan {
    int threshold;

    IsGreaterThan(int t) : threshold(t) {}

    bool operator()(int x) const {
        return x > threshold;
    }
};

int main() {
    std::vector<int> numbers = {1, 5, 10, 15, 20};

    // 使用仿函数进行筛选
    IsGreaterThan greaterThan10(10);
    auto it = std::find_if(numbers.begin(), numbers.end(), greaterThan10);

    if(it != numbers.end()) {
        std::cout << "第一个大于10的数是: " << *it << std::endl; // 输出: 第一个大于10的数是: 15
    } else {
        std::cout << "没有找到大于10的数。" << std::endl;
    }

    return 0;
}

仿函数与模板

仿函数与模板相结合，可以实现高度通用和可复用的代码。例如，编写一个通用的比较仿函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
#include <vector>
#include <algorithm>

// 通用比较仿函数
template <typename T>
struct Compare {
    bool operator()(const T& a, const T& b) const {
        return a < b;
    }
};

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9};

    // 使用仿函数进行排序
    std::sort(numbers.begin(), numbers.end(), Compare<int>());

    std::cout << "排序后的数字: ";
    for(auto num : numbers) {
        std::cout << num << " "; // 输出: 1 2 5 8 9
    }
    std::cout << std::endl;

    return 0;
}

仿函数的优势

  • 可扩展性： 能够根据需要添加更多功能和状态。
  • 与Lambda的互补性： 在需要携带复杂状态或多次调用时，仿函数比Lambda更适合。
  • 类型安全： 仿函数是具体的类型，可以在编译期进行类型检查。

何时使用仿函数

  • 需要携带状态时： 当回调函数需要维护内部状态时，仿函数是理想选择。
  • 复杂操作： 当简单的函数指针或Lambda难以表达复杂逻辑时。
  • 性能关键场景： 由于仿函数可以被编译器优化，适用于性能敏感的代码。

Lambda表达式

Lambda表达式是C++11引入的一种轻量级函数对象，允许在代码中定义匿名函数。它们可以捕获周围的变量，具有更强的表达能力。

基本语法

1
2
3
[captures](parameters) -> return_type {
    // 函数体
}
  • captures: 捕获外部变量的方式，可以是值捕获、引用捕获或者混合捕获。
  • parameters: 参数列表。
  • return_type: 返回类型，可以省略，编译器会自动推导。
  • 函数体: 实际执行的代码。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    int threshold = 5;
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};

    // 使用lambda表达式进行过滤
    numbers.erase(std::remove_if(numbers.begin(), numbers.end(),
        [threshold](int n) -> bool {
            return n < threshold;
        }), numbers.end());

    // 输出结果
    for(auto n : numbers) {
        std::cout << n << " "; // 输出: 6 8 7
    }

    return 0;
}

捕获方式

  1. 值捕获 ([=]): 捕获所有外部变量的副本。
  2. 引用捕获 ([&]): 捕获所有外部变量的引用。
  3. 混合捕获: 指定部分变量按值捕获，部分按引用捕获，如 [=, &var] 或 [&, var]。
  4. 无捕获 ([]): 不捕获任何外部变量。

可变Lambda

默认情况下，Lambda表达式是不可变的（const）。通过mutable关键字，可以允许修改捕获的变量副本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>

int main() {
    int count = 0;

    auto increment = [count]() mutable {
        count++;
        std::cout << "Count inside Lambda: " << count << std::endl;
    };

    increment(); // 输出: Count inside Lambda: 1
    increment(); // 输出: Count inside Lambda: 2

    std::cout << "Count outside Lambda: " << count << std::endl; // 输出: Count outside Lambda: 0

    return 0;
}

捕获成员函数和类变量

Lambda表达式可以捕获类的成员变量和成员函数，使其在类的上下文中更加灵活。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <iostream>
#include <vector>
#include <algorithm>

class Processor {
public:
    Processor(int threshold) : threshold(threshold) {}

    void process(std::vector<int>& data) {
        std::cout << "处理前数据: ";
        for(auto num : data) std::cout << num << " ";
        std::cout << std::endl;

        // 使用Lambda表达式进行过滤
        data.erase(std::remove_if(data.begin(), data.end(),
            [this](int n) -> bool {
                return n < threshold;
            }), data.end());

        std::cout << "处理后数据: ";
        for(auto num : data) std::cout << num << " ";
        std::cout << std::endl;
    }

private:
    int threshold;
};

int main() {
    std::vector<int> numbers = {1, 6, 3, 8, 2, 7};
    Processor proc(5);
    proc.process(numbers);
    /*
    输出:
    处理前数据: 1 6 3 8 2 7 
    处理后数据: 6 8 7 
    */

    return 0;
}

Lambda与标准库算法

Lambda表达式与标准库算法紧密结合，提供了更简洁和直观的代码书写方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {4, 2, 5, 1, 3};

    // 使用Lambda表达式进行排序
    std::sort(numbers.begin(), numbers.end(),
        [](int a, int b) -> bool {
            return a < b;
        });

    std::cout << "排序后的数字: ";
    for(auto num : numbers) {
        std::cout << num << " "; // 输出: 1 2 3 4 5
    }
    std::cout << std::endl;

    return 0;
}

Lambda表达式的优势

  • 简洁性： 代码更加紧凑，易于理解。
  • 灵活性： 能够捕获外部变量，适应更多场景。
  • 性能优化： 编译器可以对Lambda进行优化，如内联展开。
  • 与标准库的良好集成： 与STL算法无缝结合，简化代码逻辑。

std::function 对象

std::function 是C++11提供的一个通用的可调用包装器，能够封装任何可调用对象，包括普通函数、Lambda表达式、函数对象以及绑定表达式。它实现了类型擦除，使得不同类型的可调用对象可以通过统一的接口进行操作。

定义与使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <functional>

// 普通函数
int add(int a, int b) {
    return a + b;
}

// 函数对象
struct Multiply {
    int operator()(int a, int b) const {
        return a * b;
    }
};

int main() {
    // 封装普通函数
    std::function<int(int, int)> func1 = add;
    std::cout << "Add: " << func1(3, 4) << std::endl; // 输出: Add: 7

    // 封装Lambda表达式
    std::function<int(int, int)> func2 = [](int a, int b) -> int {
        return a - b;
    };
    std::cout << "Subtract: " << func2(10, 4) << std::endl; // 输出: Subtract: 6

    // 封装函数对象
    Multiply multiply;
    std::function<int(int, int)> func3 = multiply;
    std::cout << "Multiply: " << func3(3, 4) << std::endl; // 输出: Multiply: 12

    return 0;
}

特点

  • 类型擦除： 可以存储任何符合签名的可调用对象。
  • 灵活性： 支持动态改变存储的可调用对象。
  • 性能开销： 相比于直接使用函数指针或Lambda，std::function 可能带来一定的性能开销，尤其是在频繁调用时。

用法场景

  • 回调函数的传递。
  • 事件处理系统。
  • 策略模式的实现。

示例：回调机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <functional>

// 定义回调类型
using Callback = std::function<void(int)>;

// 触发事件的函数
void triggerEvent(Callback cb, int value) {
    // 事件发生，调用回调
    cb(value);
}

int main() {
    // 使用Lambda作为回调
    triggerEvent([](int x) {
        std::cout << "事件触发，值为: " << x << std::endl;
    }, 42); // 输出: 事件触发，值为: 42

    // 使用仿函数作为回调
    struct Printer {
        void operator()(int x) const {
            std::cout << "Printer打印值: " << x << std::endl;
        }
    } printer;

    triggerEvent(printer, 100); // 输出: Printer打印值: 100

    return 0;
}

存储和调用不同类型的可调用对象

std::function 可以在容器中存储各种不同类型的可调用对象，只要它们符合指定的签名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
#include <functional>
#include <vector>

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

struct Multiply {
    int operator()(int a, int b) const {
        return a * b;
    }
};

int main() {
    std::vector<std::function<int(int, int)>> operations;

    // 添加不同类型的可调用对象
    operations.emplace_back(add); // 普通函数
    operations.emplace_back(Multiply()); // 仿函数
    operations.emplace_back([](int a, int b) -> int { return a - b; }); // Lambda

    // 执行所有操作
    for(auto& op : operations) {
        std::cout << op(10, 5) << " "; // 输出: 15 50 5
    }
    std::cout << std::endl;

    return 0;
}

std::bind 操作

std::bind 是C++11中提供的一个函数适配器，用于绑定函数或可调用对象的部分参数，生成一个新的可调用对象。它允许提前固定某些参数，简化函数调用或适应接口需求。

基本用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
#include <functional>

// 普通函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 绑定第一个参数为10，生成新的函数对象
    auto add10 = std::bind(add, 10, std::placeholders::_1);

    std::cout << "10 + 5 = " << add10(5) << std::endl; // 输出: 10 + 5 = 15

    return 0;
}

占位符 (std::placeholders)

std::bind 使用占位符来表示未绑定的参数，这些占位符决定了在生成的新函数对象中如何传递参数。

常用的占位符包括：

  • std::placeholders::_1
  • std::placeholders::_2
  • std::placeholders::_3
  • 等等，根据需要传递的参数数量。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <functional>

void display(const std::string& msg, int count) {
    for(int i = 0; i < count; ++i) {
        std::cout << msg << std::endl;
    }
}

int main() {
    // 绑定消息为"Hello"，生成新的函数对象，只需要传递次数
    auto sayHello = std::bind(display, "Hello", std::placeholders::_1);

    sayHello(3);
    /*
    输出:
    Hello
    Hello
    Hello
    */

    // 绑定次数为2，生成新的函数对象，只需要传递消息
    auto sayTwice = std::bind(display, std::placeholders::_1, 2);
    sayTwice("Hi");
    /*
    输出:
    Hi
    Hi
    */

    return 0;
}

与Lambda表达式的对比

std::bind 曾在C++11中广泛使用，但随着Lambda表达式的普及，很多情况下Lambda更为直观和高效。不过，在某些复杂的参数绑定场景下，std::bind 依然有其独特优势。

使用 std::bind:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <functional>

int multiply(int a, int b) {
    return a * b;
}

int main() {
    // 绑定第一个参数为2，生成新的函数对象
    auto multiplyBy2 = std::bind(multiply, 2, std::placeholders::_1);

    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10

    return 0;
}

使用 Lambda 表达式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <functional>

int multiply(int a, int b) {
    return a * b;
}

int main() {
    // 使用Lambda表达式绑定第一个参数为2
    auto multiplyBy2 = [](int b) -> int {
        return multiply(2, b);
    };

    std::cout << "2 * 5 = " << multiplyBy2(5) << std::endl; // 输出: 2 * 5 = 10

    return 0;
}

总结：

  • 可读性： Lambda表达式通常更具可读性，语法更直观。
  • 灵活性： Lambda更易于捕获和使用外部变量。
  • 性能： Lambda通常比std::bind更高效，因为std::bind可能引入额外的间接层。

绑定类的成员函数

在C++中，成员函数与普通函数不同，因为它们需要一个对象实例来调用。使用 std::bind 或Lambda表达式，可以方便地绑定类的成员函数，生成可调用对象。

使用 std::bind 绑定成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <functional>

class Calculator {
public:
    int multiply(int a, int b) const {
        return a * b;
    }
};

int main() {
    Calculator calc;

    // 绑定成员函数multiply，固定第一个参数为5
    auto multiplyBy5 = std::bind(&Calculator::multiply, &calc, 5, std::placeholders::_1);

    std::cout << "5 * 3 = " << multiplyBy5(3) << std::endl; // 输出: 5 * 3 = 15

    return 0;
}

使用Lambda表达式绑定成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <functional>

class Greeter {
public:
    void greet(const std::string& name) const {
        std::cout << "Hello, " << name << "!" << std::endl;
    }
};

int main() {
    Greeter greeter;

    // 使用Lambda表达式绑定成员函数
    auto greetFunc = [&greeter](const std::string& name) {
        greeter.greet(name);
    };

    greetFunc("Alice"); // 输出: Hello, Alice!

    return 0;
}

绑定静态成员函数

静态成员函数不依赖于类的实例，可以像普通函数一样使用 std::bind 和 std::function。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <functional>

class Logger {
public:
    static void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

int main() {
    // 使用std::bind绑定静态成员函数
    auto logFunc = std::bind(&Logger::log, std::placeholders::_1);

    logFunc("This is a static log message."); // 输出: Log: This is a static log message.

    return 0;
}

绑定带有返回值的成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <functional>

class Math {
public:
    double power(double base, double exponent) const {
        double result = 1.0;
        for(int i = 0; i < static_cast<int>(exponent); ++i) {
            result *= base;
        }
        return result;
    }
};

int main() {
    Math mathObj;

    // 绑定成员函数power，固定基数为2
    auto powerOf2 = std::bind(&Math::power, &mathObj, 2.0, std::placeholders::_1);

    std::cout << "2^3 = " << powerOf2(3) << std::endl; // 输出: 2^3 = 8

    return 0;
}

注意事项

  • 对象生命周期： 绑定成员函数时，确保对象在可调用对象使用期间依然存在，以避免悬空指针问题。
  • 指针与引用： 可以通过指针或引用传递对象实例给 std::bind 或Lambda表达式。
  • 捕获方式： 在使用Lambda表达式时，选择合适的捕获方式（值捕获或引用捕获）以确保对象的正确访问。

C++ 可调用对象的总结

C++ 提供了多种方式来定义和操作可调用对象，每种方式有其独特的特点和适用场景。

可调用对象 描述 示例用法
函数指针 指向普通函数或静态成员函数的指针 int (*func)(int) = &funcName;
仿函数（Functors） 重载了 operator() 的类实例，可以携带状态 struct Foo { void operator()(); };
Lambda表达式 定义在表达式中的匿名函数，支持捕获上下文变量 [capture](params) { /* code */ }
std::function 通用的可调用对象包装器，能够封装任何符合签名的可调用对象 std::function<void(int)> func;
std::bind 绑定函数或可调用对象的部分参数，生成新的可调用对象 auto newFunc = std::bind(func, _1);

选择建议

  • 简单回调： 使用函数指针或Lambda表达式。
  • 需要携带状态或更复杂逻辑： 使用Lambda表达式或仿函数（Functors）。
  • 接口要求 std::function： 使用 std::function，不过要注意可能的性能开销。
  • 参数预绑定： 使用 std::bind，但在现代C++中，许多情况下Lambda表达式能达到相同效果且更直观。

完整示例代码

以下是一个综合示例，展示了函数指针、仿函数（Functors）、Lambda表达式、std::function、std::bind 以及绑定类成员函数的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>

// 1. 普通函数
int add(int a, int b) {
    return a + b;
}

// 2. 仿函数（Functors）
struct Multiply {
    int operator()(int a, int b) const {
        return a * b;
    }
};

// 3. Lambda表达式
auto subtract = [](int a, int b) -> int {
    return a - b;
};

// 4. 类定义
class Calculator {
public:
    int subtract(int a, int b) const {
        return a - b;
    }

    void displayOperation(const std::string& op, int result) const {
        std::cout << op << "结果: " << result << std::endl;
    }
};

// 5. 静态成员函数
class Logger {
public:
    static void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

int main() {
    // 1. 函数指针
    int (*funcPtr)(int, int) = &add;
    std::cout << "Add (Function Pointer): " << funcPtr(10, 5) << std::endl; // 输出: 15

    // 2. 仿函数（Functors）
    Multiply multiply;
    std::cout << "Multiply (Functors): " << multiply(10, 5) << std::endl; // 输出: 50

    // 3. Lambda表达式
    std::cout << "Subtract (Lambda): " << subtract(10, 5) << std::endl; // 输出: 5

    // 4. std::function 封装不同可调用对象
    std::function<int(int, int)> funcAdd = add;
    std::function<int(int, int)> funcSubtract = subtract;
    std::function<int(int, int)> funcMultiply = multiply;

    std::cout << "Add (std::function): " << funcAdd(20, 10) << std::endl; // 输出: 30
    std::cout << "Subtract (std::function): " << funcSubtract(20, 4) << std::endl; // 输出: 16
    std::cout << "Multiply (std::function): " << funcMultiply(4, 5) << std::endl; // 输出: 20

    // 5. std::bind 绑定部分参数
    auto add5 = std::bind(add, 5, std::placeholders::_1);
    std::cout << "5 + 10 = " << add5(10) << std::endl; // 输出: 15

    auto multiplyBy2 = std::bind(multiply, 2, std::placeholders::_1);
    std::cout << "2 * 10 = " << multiplyBy2(10) << std::endl; // 输出: 20

    // 6. 绑定类成员函数
    Calculator calc;

    // 使用 std::bind 绑定成员函数 subtract
    auto boundSubtract = std::bind(&Calculator::subtract, &calc, 15, 5);
    std::cout << "15 - 5 = " << boundSubtract() << std::endl; // 输出: 10

    // 使用 std::bind 绑定成员函数 displayOperation
    auto displayAdd = std::bind(&Calculator::displayOperation, &calc, "Add", std::placeholders::_1);
    auto displayResult = funcAdd;
    int addResult = displayResult(7, 8); // 15
    displayAdd(addResult); // 输出: Add结果: 15

    // 7. 绑定静态成员函数
    auto logFunc = std::bind(&Logger::log, std::placeholders::_1);
    logFunc("This is a static log message."); // 输出: Log: This is a static log message.

    // 8. 使用 std::function 存储混合可调用对象
    std::vector<std::function<void()>> operations;

    // 添加不同的操作到容器
    operations.emplace_back([&]() { std::cout << "Lambda Operation" << std::endl; });
    operations.emplace_back(std::bind(&Calculator::displayOperation, &calc, "Multiply", 30));
    operations.emplace_back([&]() { std::cout << "Add5(10): " << add5(10) << std::endl; });
    operations.emplace_back([&]() { Logger::log("Lambda-based log message."); });

    // 执行所有操作
    for(auto& op : operations) {
        op();
    }
    /*
    输出:
    Lambda Operation
    Multiply结果: 30
    Add5(10): 15
    Log: Lambda-based log message.
    */

    return 0;
}

解释:

  1. 函数指针: 定义并使用了指向 add 函数的函数指针 funcPtr。
  2. 仿函数（Functors）: 定义了 Multiply 结构体，并使用其实例 multiply 进行乘法运算。
  3. Lambda表达式: 定义了一个用于减法的Lambda subtract。
  4. std::function: 封装了不同类型的可调用对象，包括普通函数、Lambda和仿函数。
  5. std::bind: 绑定 add 和 multiply 函数的部分参数，生成新的可调用对象 add5 和 multiplyBy2。
  6. 绑定类成员函数: 使用 std::bind 绑定 Calculator 类的成员函数 subtract 和 displayOperation。
  7. 绑定静态成员函数: 使用 std::bind 绑定 Logger 类的静态成员函数 log。
  8. 混合可调用对象容器: 使用 std::function 和 std::vector 存储并执行不同类型的可调用对象，包括Lambda、绑定成员函数和静态成员函数。

小结

通过本教案，学生应能够理解并运用C++中的各种可调用对象，包括传统的函数指针、仿函数（Functors）、Lambda表达式、std::function 和 std::bind 等。掌握这些工具不仅有助于编写更灵活和可维护的代码，还为进一步学习函数式编程和设计模式奠定了坚实的基础。在实际编程中，合理选择和组合这些可调用对象，可以大大提升代码的效率和表达力。