1. C++可调用对象概述

在C++编程中，可调用对象(Callable Objects)是指那些能够通过函数调用运算符 () 进行调用的实体。这个概念在C++11标准之后变得尤为重要，因为它为函数式编程风格提供了强大的支持。可调用对象主要包括以下几种类型：

• 普通函数指针
• 函数对象（仿函数）
• Lambda表达式
• 类成员函数指针
• 被 std::bind 绑定的对象
• std::function 包装的对象

理解这些可调用对象的特性和使用场景，对于编写现代C++代码至关重要。它们不仅能够提高代码的灵活性，还能实现回调机制、事件处理等高级功能。

2. 函数指针：最基础的可调用对象

2.1 普通函数指针

函数指针是C语言遗留下来的可调用对象形式，它直接指向函数的地址：

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

int main() {
    int (*funcPtr)(int, int) = &add;
    std::cout << funcPtr(3, 4) << std::endl;  // 输出7
    return 0;
}

函数指针的声明语法较为复杂，需要明确指定返回类型和参数类型。它的主要限制在于无法捕获上下文状态，且指向的必须是全局函数或静态成员函数。

2.2 成员函数指针

成员函数指针与普通函数指针类似，但用于指向类的成员函数：

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

int main() {
    Calculator calc;
    int (Calculator::*memFuncPtr)(int, int) = &Calculator::multiply;
    std::cout << (calc.*memFuncPtr)(3, 4) << std::endl;  // 输出12
    return 0;
}

成员函数指针需要通过对象实例来调用，使用 .* 或 ->* 运算符。这种调用方式在实际编程中较为少见，通常会被其他更灵活的可调用对象替代。

3. 函数对象（仿函数）

3.1 函数对象的基本概念

函数对象（Function Object），也称为仿函数（Functor），是通过重载 operator() 的类实例：

struct Adder {
    int operator()(int a, int b) const {
        return a + b;
    }
};

int main() {
    Adder adder;
    std::cout << adder(3, 4) << std::endl;  // 输出7
    return 0;
}

函数对象相比函数指针的主要优势在于：

1. 可以保存状态（通过成员变量）
2. 可以作为模板参数传递，编译器可以更好地优化
3. 可以重载多个 operator() 版本

3.2 带状态的函数对象

函数对象可以维护内部状态，这是普通函数指针无法做到的：

class Accumulator {
    int total = 0;
public:
    int operator()(int value) {
        total += value;
        return total;
    }
};

int main() {
    Accumulator acc;
    std::cout << acc(10) << std::endl;  // 输出10
    std::cout << acc(20) << std::endl;  // 输出30
    return 0;
}

这种特性使得函数对象在STL算法中特别有用，例如在 std::accumulate 等算法中作为自定义操作。

4. Lambda表达式：现代C++的匿名函数

4.1 Lambda的基本语法

Lambda表达式是C++11引入的一种简洁的定义匿名函数的方式：

auto lambda = [](int a, int b) -> int {
    return a + b;
};
std::cout << lambda(3, 4) << std::endl;  // 输出7

Lambda表达式的完整语法为： [capture](parameters) mutable -> return-type { body }

其中：

• capture ：捕获列表，指定如何从外部作用域捕获变量
• parameters ：参数列表
• mutable ：允许修改按值捕获的变量
• return-type ：返回类型（可省略，由编译器推导）
• body ：函数体

4.2 捕获方式详解

Lambda的捕获方式决定了它如何访问外部变量：

int x = 10, y = 20;

// 按值捕获x，按引用捕获y
auto lambda1 = [x, &y]() {
    std::cout << x << ", " << y << std::endl;
    y++;  // 可以修改y，因为是引用
    // x++;  // 错误：不能修改按值捕获的变量
};

// 默认按值捕获所有变量
auto lambda2 = [=]() { /* 可以使用x和y的值 */ };

// 默认按引用捕获所有变量
auto lambda3 = [&]() { /* 可以修改x和y */ };

// 混合捕获方式
auto lambda4 = [=, &y]() { /* 按值捕获所有变量，但y按引用 */ };
auto lambda5 = [&, x]() { /* 按引用捕获所有变量，但x按值 */ };

4.3 mutable关键字

默认情况下，按值捕获的变量在lambda内是const的，使用 mutable 可以移除这个限制：

int counter = 0;
auto lambda = [counter]() mutable {
    counter++;
    std::cout << counter << std::endl;
};

lambda();  // 输出1
lambda();  // 输出2
std::cout << counter << std::endl;  // 输出0，外部counter未改变

注意： mutable 只影响lambda内部对捕获变量的修改，不影响外部变量。

5. std::function：通用的函数包装器

5.1 std::function的基本用法

std::function 是C++11提供的通用函数包装器，可以存储、复制和调用任何可调用对象：

#include <functional>
#include <iostream>

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

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

int main() {
    std::function<int(int, int)> func;
    
    // 存储普通函数
    func = add;
    std::cout << func(3, 4) << std::endl;  // 输出7
    
    // 存储函数对象
    func = Multiply();
    std::cout << func(3, 4) << std::endl;  // 输出12
    
    // 存储lambda表达式
    func = [](int a, int b) { return a - b; };
    std::cout << func(7, 3) << std::endl;  // 输出4
    
    return 0;
}

std::function 的模板参数形式为 std::function<返回类型(参数类型...)> ，它可以统一处理各种可调用对象，非常适合用于回调系统和事件处理。

5.2 std::function与空值检查

调用空的 std::function 会抛出 std::bad_function_call 异常，因此在使用前应该检查：

std::function<void()> emptyFunc;

try {
    emptyFunc();  // 抛出std::bad_function_call
} catch (const std::bad_function_call& e) {
    std::cerr << "Error: " << e.what() << std::endl;
}

// 更安全的调用方式
if (emptyFunc) {
    emptyFunc();
}

5.3 std::function的性能考虑

std::function 有一定的性能开销，主要体现在：

1. 类型擦除带来的间接调用成本
2. 可能涉及动态内存分配（对小对象可能有优化）
3. 调用虚函数表的开销

在性能敏感的代码中，可以考虑直接使用模板参数或特定类型的可调用对象。

6. std::bind：参数绑定工具

6.1 std::bind的基本用法

std::bind 可以将可调用对象与其参数部分或全部绑定，生成一个新的可调用对象：

#include <functional>
#include <iostream>

void printSum(int a, int b, int c) {
    std::cout << a + b + c << std::endl;
}

int main() {
    using namespace std::placeholders;  // 引入占位符_1, _2, _3...
    
    // 绑定所有参数
    auto bound1 = std::bind(printSum, 1, 2, 3);
    bound1();  // 输出6
    
    // 使用占位符部分绑定
    auto bound2 = std::bind(printSum, _1, _2, 10);
    bound2(5, 6);  // 输出21 (5+6+10)
    
    // 重排参数顺序
    auto bound3 = std::bind(printSum, _3, _1, _2);
    bound3(1, 2, 3);  // 输出6 (3+1+2)
    
    return 0;
}

6.2 std::bind与成员函数

std::bind 可以绑定成员函数，需要传递对象指针或引用：

class Printer {
public:
    void print(const std::string& msg) {
        std::cout << msg << std::endl;
    }
};

int main() {
    Printer printer;
    auto bound = std::bind(&Printer::print, &printer, _1);
    bound("Hello, world!");  // 输出Hello, world!
    return 0;
}

6.3 std::bind与lambda的比较

在C++11之后，很多 std::bind 的用法可以被lambda表达式替代：

// 使用std::bind
auto bound = std::bind(printSum, _1, 2, 3);

// 使用lambda实现相同功能
auto lambda = [](int a) { printSum(a, 2, 3); };

一般来说，lambda表达式更直观、类型安全，且编译器能更好地优化。 std::bind 的主要优势在于处理成员函数绑定和参数重排时语法更简洁。

7. 可调用对象的实际应用

7.1 回调系统设计

可调用对象非常适合用于实现回调系统：

class Button {
    std::function<void()> onClick;
public:
    void setOnClick(std::function<void()> callback) {
        onClick = callback;
    }
    
    void click() {
        if (onClick) {
            onClick();
        }
    }
};

int main() {
    Button btn;
    btn.setOnClick([]() {
        std::cout << "Button clicked!" << std::endl;
    });
    btn.click();  // 输出Button clicked!
    return 0;
}

7.2 STL算法中的可调用对象

许多STL算法接受可调用对象作为参数：

#include <algorithm>
#include <vector>

int main() {
    std::vector<int> nums {1, 2, 3, 4, 5};
    
    // 使用lambda作为谓词
    auto it = std::find_if(nums.begin(), nums.end(), 
        [](int n) { return n % 2 == 0; });
    if (it != nums.end()) {
        std::cout << "First even number: " << *it << std::endl;
    }
    
    // 使用函数对象作为比较器
    struct {
        bool operator()(int a, int b) const { return a > b; }
    } customGreater;
    std::sort(nums.begin(), nums.end(), customGreater);
    
    // 输出排序结果
    for (int n : nums) {
        std::cout << n << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

7.3 线程和异步任务

可调用对象常用于创建线程和异步任务：

#include <thread>
#include <future>

int main() {
    // 使用lambda创建线程
    std::thread t([]() {
        std::cout << "Hello from thread!" << std::endl;
    });
    t.join();
    
    // 使用std::async创建异步任务
    auto future = std::async(std::launch::async, []() {
        return 42;
    });
    std::cout << "The answer is: " << future.get() << std::endl;
    
    return 0;
}

8. 性能比较与选择建议

8.1 各种可调用对象的性能特点

1. 函数指针 ：调用开销最小，但灵活性最差
2. 函数对象 ：通常会被编译器内联，性能很好
3. Lambda表达式 ：根据捕获方式不同，性能接近函数对象或 std::function
4. std::function ：有一定的类型擦除开销，但提供了统一的接口
5. std::bind ：生成的绑定对象通常比lambda稍慢

8.2 选择指南

1. 对于简单的回调或算法谓词，优先使用lambda表达式
2. 需要保存状态时，考虑函数对象或捕获外部变量的lambda
3. 需要统一存储不同类型的可调用对象时，使用 std::function
4. 在性能关键路径上，避免不必要的 std::function 和 std::bind
5. 需要参数重排或部分绑定时， std::bind 可能更简洁

8.3 类型推导与auto

现代C++中， auto 关键字可以简化可调用对象的使用：

auto lambda = [](int x) { return x * 2; };
std::function<int(int)> func = lambda;  // 明确类型
auto func2 = lambda;  // 自动推导类型

使用 auto 可以避免冗长的类型声明，特别是对于复杂的lambda表达式。但需要注意， auto 推导的类型是唯一的，不能像 std::function 那样存储不同类型的可调用对象。