• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号
登陆 注册

[c++]CallableObjects

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

Ref: 【c++】可调用对象(Callable Objects)

Five kinds of callable objects:

  1. Functions.
  2. Pointers to functions.
  3. Objects of a class that overloads ().
  4. Objects created by bind.
  5. Objects created by lamdba expressions.

 

 

函数、函数指针

1-2. Functions and Pointers to functions

普通函数

bool range5to10(int val)  // <-- bool (*p_func)(int) 改为函数指针是一个道理
{
　　 return (5 <= val && val <= 10);
}

vector<int> vec{ 20, 2, 4, 3, 8, 10, 15, 1};

auto presult = find_if(vec.begin(), vec.end(), range5to10);

if (presult == vec.end())
{
    cout << "no" << endl;
}
else
{
    cout << "yes" << endl;
}

 

 

仿函数

模板de仿函数

更高逼格的template，至少能在类型上更加灵活一些。

template <class T, T lb, T ub>
struct range {
    bool operator() (T val) {
        return (lb <=val && val <=ub);
    }
};

auto presult = find_if(vec.begin(), vec.end(), range<int, 5, 10>{});

 

3. Object of class

对象de仿函数

class range {
public:
    range(int l, int u): lb(l), ub(u) {　　// <-- 这里的构建函数的使用体现了其优势：初始化能多做些事情
    }

    bool operator() (int val) {
        return (lb <=val && val <=ub);
    }

private:
    int lb, ub;
};


auto presult = find_if(vec.begin(), vec.end(), range{5, 10});

以及补充的三个例子。

struct MyPlus{
    int operator() (const int &a , const int &b) const {
        return a + b;
    }
};
int main()
{
    MyPlus a;
    cout << MyPlus()(1,2) << endl;    　　// 1、通过产生临时对象 调用重载运算符
    cout << a.operator()(1,2) << endl;　　// 2、通过对象 显示调用重载运算符
    cout << a(1,2) << endl;           　　// 3、通过对象 隐示地调用重载运算符
    return 0;
}

  

 

std::function

4. Bind

占位符

一个变量的占位符, 用于函数绑定时使用。

void f(int a, int b, int c)
{
    cout << a << " " << b << " " << c << endl;
}

auto g1 = bind(f, placeholders::_1, placeholders::_2, 100);
g1(1, 2);

 

能绑定什么

Ref: C++11----std::bind/std::placeholder

std::bind 是用来绑定函数调用的参数的，解决的需求 是：

我们有时候可能不会一次性获得调用某个函数的全部参数，通过这个函数，我们可以将部分调用参数提前绑定到函数身上成为一个新的对象，然后在参数齐全后，再完成调用。

#include <functional>
#include <iostream>
int foo(int a, int b) {
    return a + b;
}
class Mybind {
public:
    int operator() (int a, int b)
    {
        return a + b;
    }
};
int main() {
// 1.将参数一:100绑定到函数 foo 上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    auto bindFoo = std::bind(foo, std::placeholders::_1,  100);
    // 这时调用 bindFoo 时，只需要提供第一个参数即可
    std::cout << bindFoo(50) << std::endl;
 
// 2.将参数一:100绑定到lambda上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    auto f1 = std::bind([](int a, int b)->int {return a + b; }, std::placeholders::_1, 100);
    std::cout << f1(50) << std::endl;
 
// 3.将参数一:100绑定到对象上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    Mybind m;
    auto f2 = std::bind(m, std::placeholders::_1, 100);
    std::cout << f2(50) << std::endl;
 
    std::cin.get();
    return 0;
}

提示：注意 auto 关键字的妙用。有时候我们可能不太熟悉一个函数的返回值类型，但是我们却可以通过 auto 的使用来规避这一问题的出现。

其中：绑定参数技术多用于设计模式中的适配器模式

 

参数绑定规则

<示范一>

fun1说明：占位符->第一个参数和函数第一个参数匹配（int），第二个参数和第二个参数匹配（char），第三个参数和第三个参数匹配。

fun2说明：占位符->第二个参数和函数第一个参数匹配（int），第三个参数和第二个参数匹配（char），第一个参数和第三个参数匹配。

fun3说明：占位符->第一个参数和函数第一个参数匹配（int），第二个参数和第二个参数匹配（char），第三个参数默认为98.77

#include <functional>
#include <iostream>

int TestFunc(int a, char c, float f)
{
    std::cout << a << std::endl;
    std::cout << c << std::endl;
    std::cout << f << std::endl;
    return a;
}

int main(void)
{
    auto fun1 = std::bind(TestFunc, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
    auto fun2 = std::bind(TestFunc, std::placeholders::_2, std::placeholders::_3, std::placeholders::_1);
    auto fun3 = std::bind(TestFunc, std::placeholders::_1, std::placeholders::_2, 98.77);

    fun1(30, 'C',100.1);
    fun2(100.1, 30, 'C');
    fun3(30,'C');

    return 0;
}

 

<示范二>

这里placeholders的位置发生变化，看似对结果没有影响。

 #include <functional>
 #include <iostream>
 #include <vector>
 #include <algorithm>
 
 using namespace std;
 
 class range {
     public:
         bool operator() (int lb, int ub, int val) {
             cout << "lb  = " << lb  << endl;
             cout << "ub  = " << ub  << endl;
             cout << "val = " << val << endl;
             return (lb <= val && val <= ub);
         }   
 };
  
 int main() 
 {
     vector<int> vec = {1,2,3,4,5,6,7,8,9,10};
     auto presult = find_if(vec.begin(), vec.end(), std::bind(range{}, 5, 10, std::placeholders::_1));
     auto second  = find_if(vec.begin(), vec.end(). std::bind(range{}, std::placeholders::_1, 5, 10));　　// 注意，placeholders放在第一位也可以。
 
     cout << *presult << endl;
     return 0;
 }

 

std::function 

初步认识，到底是个啥？ 

std::function 在C++11后加入标准，可以用它来描述C++中所有可调用实体，它是 可调用对象的包装器，声明如下：

#include <functional> 

 

比 “函数指针” 更强大？

std::function 强大的地方在于，它能够 兼容所有具有相同参数类型的函数实体。

相比较于函数指针，std::function能兼容带捕获的lambda函数，而且对类成员函数提供支持。

 

能力展示，遛一遛？

可以承接各种类型的函数，只要参数一致。

#include <iostream>
#include <functional>

// std::function
std::function<int(int, int)> SumFunction;

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

// 类（成员、静态）函数
class Calcu
{
public:
    int base = 20;
    // 类的成员方法，参数包含this指针
    int class_func_sum(const int a, const int b) const { return this->base + a + b; };
    // 类的静态成员方法，不包含this指针
    static int class_static_func_sum(const int a, const int b) { return a + b; };
};

// 仿函数
class ImitateAdd
{
public:
    int operator() (const int a, const int b) const { return a + b; };
};

// lambda函数
auto lambda_func_sum = [](int a, int b) -> int { return a + b; };

// 函数指针
int (*func_pointer)(int, int);


int main(void) 
{
    int x = 2; 
    int y = 5;

    // 普通函数
    SumFunction = func_sum;
    int sum = SumFunction(x, y);
    std::cout << "func_sum：" << sum << std::endl;

    // 类成员函数
    Calcu obj;
    SumFunction = std::bind(&Calcu::class_func_sum, obj, std::placeholders::_1, std::placeholders::_2); // 绑定this对象
    sum = SumFunction(x, y);
    std::cout << "Calcu::class_func_sum：" << sum << std::endl;

    // 类静态函数
    SumFunction = Calcu::class_static_func_sum;
    sum = SumFunction(x, y);
    std::cout << "Calcu::class_static_func_sum：" << sum << std::endl;

    // lambda函数
    SumFunction = lambda_func_sum;
    sum = SumFunction(x, y);
    std::cout << "lambda_func_sum：" << sum << std::endl;

    // 带捕获的lambda函数
    int base = 10;
    auto lambda_func_with_capture_sum = [&base](int x, int y)->int { return x + y + base; };
    SumFunction = lambda_func_with_capture_sum;
    sum = SumFunction(x, y);
    std::cout << "lambda_func_with_capture_sum：" << sum << std::endl;

    // 仿函数
    ImitateAdd imitate;
    SumFunction = imitate;
    sum = SumFunction(x, y);
    std::cout << "imitate func：" << sum << std::endl;

    // 函数指针
    func_pointer = func_sum;
    SumFunction = func_pointer;
    sum = SumFunction(x, y);
    std::cout << "function pointer：" << sum << std::endl;

    return 0;
}
View Code

 

 

Lambda 函数

5. Lambda Functions 

初步认识

可参考：[c++] C Language Features

“Lambda 表达式” (lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。

Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。 

 

返回值

由于Lambda的类型是唯一的，不能通过类型名来显式声明对应的对象，但可以利用auto关键字和类型推导：

auto f=[](int a,int b){return a>b;};

或者，返回值类型转换。

std::cout << [](float f)        { return std::abs(f); } (-3.5);
std::cout << [](float f) -> int { return std::abs(f); } (-3.5);

这个语句与前面的不同之处在于，lambda 表达式的返回时不是 float 而是 int。

第一个返回3.5；第二个返回3。

 

Return Type for Lambdas

 

 

参数

基本定义

[]        // 不捕获任何外部变量
[=]       // 以值的形式捕获所有外部变量
[&]       // 以引用形式捕获所有外部变量

[x, &y]   // x 以传值形式捕获，y 以引用形式捕获
[=, &z]   // z 以引用形式捕获，其余变量 以传值形式捕获
[&, x]    // x 以值的形式捕获，其余变量 以引用形式捕获

 

捕获外部变量

float f0 = 1.0;
std::cout << [=](float f) { return f0 + std::abs(f); } (-3.5);

传值：其输出值是 4.5

---------------------------------------------------------------------------------

float f0 = 1.0;
std::cout << [&](float f) { return f0 += std::abs(f); } (-3.5);
std::cout << '\n' << f0 << '\n';

传引用：输出值是 4.5 和 4.5

---------------------------------------------------------------------------------

float f0 = 1.0;
std::cout << [=](float f) mutable { return f0 += std::abs(f); } (-3.5);
std::cout << '\n' << f0 << '\n';

如果以传值的形式捕获外部变量，那么，lambda 体不允许修改外部变量。
你会觉得输出值是什么呢？答案是，4.5 和 1.0。

---------------------------------------------------------------------------------

float f0 = 1.0f;
float f1 = 10.0f;
std::cout << [=, &f0](float a) { return f0 += f1 + std::abs(a); } (-3.5);
std::cout << '\n' << f0 << '\n';

混合机制：这个例子的输出是 14.5 和 14.5。

 

不捕获外部变量

** 捕获 **
auto f = [x](int a,int b){return a>x;}); // x被捕获复制

int x=0,y=1;
auto g = [&](int x){return ++y;});　　　　// y被捕获引用，调用g后会修改y，需要注意y的生存期 (y是返回值)
auto g = [&y](int x) {return ++y;}); 　　// 这样也是可以的貌似。


** 未捕获 **
bool(*fp)(int,int) = [](int a,int b){return a>b;}); // 不捕获时才可转换为“函数指针”

 

 End.

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
C++调用shell脚本发布时间：2022-07-14
下一篇：
C#中精确计时的一点收获发布时间：2022-07-14
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap