• c++ 新特性 std::bind 简单实验

    1.概要

    std::bind 是 C++11 引入的一个功能，它用于绑定函数/可调用对象到特定的参数，并生成一个新的可调用对象。这个新的可调用对象可以稍后调用，就像调用原始函数/可调用对象一样，但会带有预先绑定的参数。

    std::placeholders::_1、std::placeholders::_2 等是 C++11 引入的占位符，用于 std::bind 表达式中，以指示哪些参数将在稍后调用绑定后的函数对象时被提供。这些占位符用于替换被绑定的函数或可调用对象的某些参数。
    在 std::bind 的上下文中，std::placeholders::_1 表示第一个（从 1 开始计数）没有被显式绑定的参数，std::placeholders::_2 表示第二个，以此类推。当绑定后的函数对象被调用时，你需要为这些占位符提供具体的值。

    2.代码分析

    2.1std::bind 简单实验
    2.1.1 代码
    #include  
    #include // 包含 std::bind 的头文件  
    using namespace std;

    namespace t1 {
        // 一个简单的函数，接受两个整数参数并返回它们的和  
        int add(int a, int b) {
            return a + b;
        }
        void test() {
            cout << "----------------------------------------------\n";
            // 你也可以绑定多个参数  
            auto bound_add_ten_fifteen = std::bind(add, 10, 15);
            int another_result = bound_add_ten_fifteen(); // 这相当于调用 add(10, 15)  
            std::cout << "Another Result: " << another_result << std::endl; // 输出: Another Result: 25  
        }
    }
    2.1.2 实验结果
    Another Result: 25 == 10(占位)+15(占位)

    在这个例子中，我们首先定义了一个简单的 add 函数，它接受两个整数参数并返回它们的和。然后，我们使用 std::bind 来绑定 aadd 函数的两个参数，生成一个不接受任何参数的可调用对象 bound_add_ten_fifteen。这个可调用对象直接返回 add(10, 15) 的结果。

    注意，在绑定参数时，我们使用 std::placeholders::_1、std::placeholders::_2 等来表示原始函数/可调用对象的参数。这些占位符在 std::bind 的参数列表中按照它们在原始函数/可调用对象中的顺序来替代实际的参数。

    2.2 std::placeholders::_1 等占位符实验
    2.2.1 代码
    ///


    /// std::placeholders::_1 是 C++11 引入的占位符，用于 std::bind 表达式中，
    /// 以指示哪些参数将在稍后调用绑定后的函数对象时被提供。
    /// 这些占位符用于替换被绑定的函数或可调用对象的某些参数。
    ///
    namespace t2 {
        // 一个简单的函数，接受两个整数参数并返回它们的和  
        int add(int a, int b) {
            return a + b;
        }
        void test() {
            cout << "----------------------------------------------\n";
            // 使用 std::bind 绑定 add 函数的第一个参数为 5  
            // std::placeholders::_1 表示一个占位符
            auto bound_add_five = std::bind(add, 5, std::placeholders::_1);

            // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
            // 并返回该整数与 5 的和  
            int result = bound_add_five(3); // 这相当于调用 add(5, 3)  
            std::cout << "Result: " << result << std::endl; // 输出: Result: 8  

        }
    }
    2.2.3 实验结果
    Result: 8 = 5(占位)+3

    2.3 尝试多个占位符
    2.3.1 代码
    namespace t3 {
        // 一个简单的函数，接受两个整数参数并返回它们的和  
        int add(int a, int b,int c) {
            return a + b+c;
        }
        void test() {
            cout << "----------------------------------------------\n";
            // 使用 std::bind 绑定 add 函数的第一个参数为 5 
            // std::placeholders::_0 表示一个占位符 类似于数据的[0] 
            // std::placeholders::_1 表示一个占位符 类似于数据的[1]
            // std::placeholders::_2 表示一个占位符 类似于数据的[2]
            auto bound_add_five = std::bind(add, 5, std::placeholders::_1, std::placeholders::_2);

            // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
            // 并返回该整数与 5 的和  
            int result = bound_add_five(3,4); // 这相当于调用 add(5, 3)  
            std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
        }
    }
    2.3.2 运行结果
    Result: 12  = 5(占位)+3+4(占位)

    2.4 尝试交叉绑定参数
    //尝试交叉绑定参数
    // 参数，占位符，参数
    namespace t4 {
        // 一个简单的函数，接受两个整数参数并返回它们的和  
        int add(int a, int b, int c) {
            return a + b + c;
        }
        void test() {
            cout << "----------------------------------------------\n";
            // 使用 std::bind 绑定 add 函数的第一个参数为 5  
            // std::placeholders::_1 表示一个占位符
            auto bound_add_five = std::bind(add, 5, std::placeholders::_1, 7);

            // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
            // 并返回该整数与 5 的和  
            int result = bound_add_five(3); // 这相当于调用 add(5, 3)  
            std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
        }
    }

    2.5 我在已经有值的位置，输入了，是使用预定义的参数，还是我目前的
    2.5.1 代码
    //我在已经有值的位置，输入了，是使用预定义的参数，还是我目前的
    //结果：使用预定义的数据，即使std::bind生成的函数不报错，也没有用
    namespace t5 {
        // 一个简单的函数，接受两个整数参数并返回它们的和  
        int add(int a, int b, int c) {
            return a + b + c;
        }
        void test() {
            
            // 使用 std::bind 绑定 add 函数的第一个参数为 5  
            // std::placeholders::_1 表示一个占位符
            auto bound_add_five = std::bind(add, 5, std::placeholders::_1, 7);

            // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
            // 并返回该整数与 5 的和  
            // 这是即使输入了9也不会有用，因为只有一个占位符需要天才
            int result = bound_add_five(3,9); // 这相当于调用 add(5, 3)  
            std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
        }
    }
    2.5.2 运行结果
    Result: 15 = 5(占位)+3+7(占位)

    3.代码

    1. #include <iostream>  
    2. #include <functional> // 包含 std::bind 的头文件  
    3. using namespace std;
    4.  
    5. namespace t1 {
    6.     // 一个简单的函数，接受两个整数参数并返回它们的和  
    7.     int add(int a, int b) {
    8.         return a + b;
    9.     }
    10.     void test() {
    11.         cout << "----------------------------------------------\n";
    12.         // 你也可以绑定多个参数  
    13.         auto bound_add_ten_fifteen = std::bind(add, 10, 15);
    14.         int another_result = bound_add_ten_fifteen(); // 这相当于调用 add(10, 15)  
    15.         std::cout << "Another Result: " << another_result << std::endl; // 输出: Another Result: 25  
    16.     }
    17. }
    18.  
    19. /// <summary>
    20. /// std::placeholders::_1 是 C++11 引入的占位符，用于 std::bind 表达式中，
    21. /// 以指示哪些参数将在稍后调用绑定后的函数对象时被提供。
    22. /// 这些占位符用于替换被绑定的函数或可调用对象的某些参数。
    23. /// </summary>
    24. namespace t2 {
    25.     // 一个简单的函数，接受两个整数参数并返回它们的和  
    26.     int add(int a, int b) {
    27.         return a + b;
    28.     }
    29.     void test() {
    30.         cout << "----------------------------------------------\n";
    31.         // 使用 std::bind 绑定 add 函数的第一个参数为 5  
    32.         // std::placeholders::_1 表示一个占位符
    33.         auto bound_add_five = std::bind(add, 5, std::placeholders::_1);
    34.  
    35.         // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
    36.         // 并返回该整数与 5 的和  
    37.         int result = bound_add_five(3); // 这相当于调用 add(5, 3)  
    38.         std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
    39.  
    40.     }
    41. }
    42.  
    43. //尝试多个占位符
    44. namespace t3 {
    45.     // 一个简单的函数，接受两个整数参数并返回它们的和  
    46.     int add(int a, int b,int c) {
    47.         return a + b+c;
    48.     }
    49.     void test() {
    50.         cout << "----------------------------------------------\n";
    51.         // 使用 std::bind 绑定 add 函数的第一个参数为 5 
    52.         // std::placeholders::_0 表示一个占位符 类似于数据的[0] 
    53.         // std::placeholders::_1 表示一个占位符 类似于数据的[1]
    54.         // std::placeholders::_2 表示一个占位符 类似于数据的[2]
    55.         auto bound_add_five = std::bind(add, 5, std::placeholders::_1, std::placeholders::_2);
    56.  
    57.         // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
    58.         // 并返回该整数与 5 的和  
    59.         int result = bound_add_five(3,4); // 这相当于调用 add(5, 3)  
    60.         std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
    61.     }
    62. }
    63.  
    64. //尝试交叉绑定参数
    65. // 参数，占位符，参数
    66. namespace t4 {
    67.     // 一个简单的函数，接受两个整数参数并返回它们的和  
    68.     int add(int a, int b, int c) {
    69.         return a + b + c;
    70.     }
    71.     void test() {
    72.         cout << "----------------------------------------------\n";
    73.         // 使用 std::bind 绑定 add 函数的第一个参数为 5  
    74.         // std::placeholders::_1 表示一个占位符
    75.         auto bound_add_five = std::bind(add, 5, std::placeholders::_1, 7);
    76.  
    77.         // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
    78.         // 并返回该整数与 5 的和  
    79.         int result = bound_add_five(3); // 这相当于调用 add(5, 3)  
    80.         std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
    81.     }
    82. }
    83.  
    84. //我在已经有值的位置，输入了，是使用预定义的参数，还是我目前的
    85. //结果：使用预定义的数据，即使std::bind生成的函数不报错，也没有用
    86. namespace t5 {
    87.     // 一个简单的函数，接受两个整数参数并返回它们的和  
    88.     int add(int a, int b, int c) {
    89.         return a + b + c;
    90.     }
    91.     void test() {
    92.         cout << "----------------------------------------------\n";
    93.         // 使用 std::bind 绑定 add 函数的第一个参数为 5  
    94.         // std::placeholders::_1 表示一个占位符
    95.         auto bound_add_five = std::bind(add, 5, std::placeholders::_1, 7);
    96.  
    97.         // 现在 bound_add_five 是一个新的可调用对象，它接受一个整数参数  
    98.         // 并返回该整数与 5 的和  
    99.         // 这是即使输入了9也不会有用，因为只有一个占位符需要天才
    100.         int result = bound_add_five(3,9); // 这相当于调用 add(5, 3)  
    101.         std::cout << "Result: " << result << std::endl; // 输出: Result: 8  
    102.     }
    103. }
    104.  
    105. int main() {
    106.     
    107.     t1::test();
    108.     t2::test();
    109.     t3::test();
    110.     t4::test();
    111.     t5::test();
    112.     return 0;
    113. }

    4.运行结果

    ----------------------------------------------
    Another Result: 25
    ----------------------------------------------
    Result: 8
    ----------------------------------------------
    Result: 12
    ----------------------------------------------
    Result: 15
    ----------------------------------------------
    Result: 15

  • 相关阅读:
    【STL之前】[C++] string类 模拟实现 及 框架分析 ~
    从零开始实现一个MyBatis加解密插件
    递归在多级数据结构中的简单应用
    信创办公–基于WPS的PPT最佳实践系列 （项目8创建电子相册）
    【深入浅出Spring原理及实战】「原理分析专题」重新回顾一下Spring框架的异步执行调用的原理和实战
    运维：k8s常用命令大全
    Python爬虫爬取某会计师协会网站的指定文章（文末送书）
    1.3.17 扩展 IP 访问控制列表配置
    飞天使-template模版相关知识
    基于最低水平面的三维装箱问题的启发式算法
  • 原文地址：https://blog.csdn.net/xie__jin__cheng/article/details/138210542