基础8：可调用对象类型

目录

一、闭包

🍅 闭包的定义

🍆 闭包实现的三种方式：

重载operator()

lambda表达式

std::bind

二、可调用对象与function (C++ Primer P511)

🥑 C++语言中的可调用对象

🥦 这五种对象类型都不同，有没有一种类型可以容纳所有？

一、闭包

🍅 闭包的定义

闭包:带有上下文状态的函数。(有些函数的参数列表已经不能改变)

例如：

std::vector<std::string> wordVec{"fun", "hello", "world"};

int sz = 4;
auto wc = find_if(wordVec.begin(), wordVec.end(), [sz](const std::string &a)
                  { return a.size() >= sz; });

find_if函数中第三个lambda表达式不一定需要通过参数列表来进行传递参数，可以通过捕获列表来获取

🍆 闭包实现的三种方式：

1. 重载operator()

2. lambda表达式

   #include <iostream>
   #include <functional>
   
   class Adder {
   public:
       // 构造函数，初始化要添加的值
       explicit Adder(int value) : valueToAdd(value) {}
   
       // 重载()运算符以实现闭包行为
       int operator()(int x) const {
           return x + valueToAdd;
       }
   
   private:
       int valueToAdd; // 要添加到传入参数的值
   };
   
   // 使用lambda表达式实现的闭包
   std::function<int(int)> make_adder_lambda(int value) {
       return [value](int x) { return x + value; };
   }
   
   int main() {
       // 使用类实现的闭包
       Adder add5(5);
       std::cout << "Using class-based closure: " << add5(10) << std::endl;
   
       // 使用lambda表达式实现的闭包
       auto add10 = make_adder_lambda(10);
       std::cout << "Using lambda-based closure: " << add10(20) << std::endl;
   
       return 0;
   }

3. std::bind

   #include <iostream>
   #include <algorithm>
   #include <functional>
   #include <string>
   #include <vector>
   #include <map>
   
   bool isShorter(const std::string &a, int sz)
   {
       return a.size() >= sz;
   }
   
   int main()
   {
       using namespace std::placeholders;
       auto fun = std::bind(isShorter, _1, sz);
       auto wc2 = find_if(wordVec.begin(), wordVec.end(), fun);
       return 0;
   }
   
   

二、可调用对象与function (C++ Primer P511)

🥑 C++语言中的可调用对象

• 函数
• 函数指针
• lambda表达式
• std::bind
• 重载函数调用运算符

🥦 这五种对象类型都不同，有没有一种类型可以容纳所有？

有。std::function

#include <iostream>
#include <functional> // for std::function, std::bind
#include <memory>     // for std::make_unique

// 普通函数
void regularFunction(int x) {
    std::cout << "Regular function: " << x << std::endl;
}

// 函数对象（重载了()运算符）
struct Functor {
    void operator()(int x) const {
        std::cout << "Functor: " << x << std::endl;
    }
};

// Lambda 表达式 (定义在 main 函数中)

// 使用 std::bind 绑定成员函数
class MyClass {
public:
    void memberFunction(int x) {
        std::cout << "Member function of MyClass: " << x << std::endl;
    }
};

int main() {
    // 创建 std::function 对象来存储不同类型的可调用对象
    std::function<void(int)> func;

    // 1. 普通函数
    func = regularFunction;
    func(42);

    // 2. 函数指针
    void (*funcPtr)(int) = regularFunction;
    func = funcPtr;
    func(43);

    // 3. lambda 表达式
    auto lambda = [](int x) { std::cout << "Lambda: " << x << std::endl; };
    func = lambda;
    func(44);

    // 4. 使用 std::bind 绑定成员函数
    auto myClassInstance = std::make_unique<MyClass>();
    func = std::bind(&MyClass::memberFunction, myClassInstance.get(), std::placeholders::_1);
    func(45);

    // 5. 重载函数调用运算符
    Functor functor;
    func = functor;
    func(46);

    return 0;
}