移动互联网应用程序开发/绍兴百度seo

移动互联网应用程序开发,绍兴百度seo,广州网站定做教程,河北石家庄疫情最新消息今天基础介绍 c17版本引入了std::invoke特性，这是一个通用的调用包装器，可以统一调用： 普通函数成员函数函数对象Lambda表达式指向成员的指针它的主要作用是提供一个统一的方式来调用各种可调用对象。 std::invoke依赖的头文件：#…

基础介绍

c++17版本引入了std::invoke特性，这是一个通用的调用包装器，可以统一调用：

普通函数
成员函数
函数对象
Lambda表达式
指向成员的指针

它的主要作用是提供一个统一的方式来调用各种可调用对象。

std::invoke依赖的头文件：#include <functional>

基本用法

下面将详细介绍基本用法，即对上节中提到的对象(普通函数、成员函数、函数对象、Lambda表达式等)的调用。

#include <functional>
#include <iostream>
using namespace std;//普通函数
void basic_function(int x)
{cout <<" 普通函数："<<x<<endl;
}//具有返回值的普通函数
int add(int a, int b) 
{return a + b;
}//成员函数
class MyClass{public:void member_function(int x){cout <<"成员函数:"<<x<<endl;}int value = 33;
}//函数对象
class Functor
{public:void operator()(int x){cout <<"仿函数对象"<<x<<endl;}
}//示例函数
void basic_usage()
{//调用普通函数std::invoke(basic_function, 5);//调用具有返回值的普通函数int value = std::invoke(add, 4, 5);//调用成员函数MyClass obj;std::invoke(&MyClass::member_function, obj, 5);//调用仿函数对象Functor funtor;std::invoke(funtor, 5);//调用lambda表达式std::invoke([](int x){cout <<"lambda表达式："<<x<<endl;
}, 5);//访问成员变量,这个成员变量必须时public的std::invoke(&Myclass::value, obj);
}

特性总结

通过上面示例可以得到以下结论：

std::invoke表示函数调用：只要调用std::invoke，且执行了这个语句，那么就相当于调用了传入的函数对象
std::invoke的含义传入一个函数对象及这个函数对象的参数，然后通过std::invoke完成这个函数的调用

思考：为什么引入std::invoke?

统一的调用语法

函数对象有多种，比如普通函数，成员函数、仿函数对象，lambda表达式等不同的形式，不同的函数对象的调用方法都不相同，请看下面的例子：

#include <functional>
#include <iostream>class Example {
public:void method(int x) {std::cout << "Method called: " << x << "\n";}int value = 42;
};void normal_function(int x) {std::cout << "Function called: " << x << "\n";
}void unified_call_syntax() {Example obj;// 不使用 std::invoke 时的不同调用语法normal_function(1);           // 普通函数调用obj.method(2);               // 成员函数调用int val = obj.value;         // 成员变量访问// 使用 std::invoke 的统一语法std::invoke(normal_function, 1);          // 普通函数std::invoke(&Example::method, obj, 2);    // 成员函数std::invoke(&Example::value, obj);        // 成员变量
}

从上面的例子可以看到，如果不使用std::invoke，那么不同的函数对象的对象方法和形式各不相同；但是引入std::invoke后，可以很明显的看到针对不同的函数对象实现了相同的调用形式。

泛型编程的支持

前面的例子是针对不同的函数对象不同调用，但是提到泛型编程，就会涉及不同的函数对象，不同的参数数量和类型。那如何设计一个函数可以实现不同的函数对象类型，不同参数数量和参数类型的调用呢？首先肯定是需要依靠模板实现的。请看下面的例子：

#include <functional>
#include <iostream>
#include <type_traits>//函数模板
template<typename F, typename... Args>
decltype(auto) modern_call(F&& f, Args&&... args)
{return std::invoke(std::forward<F>(f),std::forward<Args>(args));
}//普通函数
void normal_function(int x) 
{std::cout << "Function called: " << x << "\n";
}
//示范类
class Calculator {
public:int add(int a, int b) { return a + b; }double factor = 1.5;
};void example() {Calculator calc;// 可以统一处理各种可调用对象modern_call(normal_function, 1);                  // 普通函数modern_call(&Calculator::add, calc, 2, 3);       // 成员函数modern_call(&Calculator::factor, calc);          // 成员变量modern_call([](int x) { return x * 2; }, 5);    // lambda表达式
}

通过上面的例子可以看到，通过modern_call的封装，实现了不同类型的函数对象的统一调用。可以这样说，若要实现对不同函数对象的统一调用的支持，必须要依靠模板的方式实现对std::invoke的封装。那这种泛型编程的应用场景有哪些呢？

回调系统
事件系统
命令模式

具体请看下面的例子：

#include <functional>
#include <iostream>
#include <vector>
#include <string>// 1. 事件系统
class EventSystem {
public:template<typename F, typename... Args>void trigger(F&& handler, Args&&... args) {std::invoke(std::forward<F>(handler),std::forward<Args>(args)...);}
};// 2. 命令模式
class Command {std::function<void()> action;
public:template<typename F, typename... Args>Command(F&& f, Args&&... args) {action = [=]() {std::invoke(f, args...);};}void execute() { action(); }
};// 3. 回调系统
class CallbackSystem {
public:template<typename Callback, typename... Args>void registerCallback(Callback&& cb, Args&&... args) {callbacks.emplace_back([=]() {std::invoke(cb, args...);});}void executeAll() {for (auto& callback : callbacks) {callback();}}private:std::vector<std::function<void()>> callbacks;
};

通过上面的例子可以清楚的看到各种场景下的使用方法，但是相同点都是在函数内部都是通过定义函数模板（泛型编程）实现的。

支持智能指针和引用包装器

#include <functional>
#include <memory>
#include <iostream>class Service {
public:int process(int x) { return x * 2; }
};void smart_pointer_example() {// 智能指针支持auto ptr = std::make_shared<Service>();auto unique = std::make_unique<Service>();// std::invoke 可以直接使用智能指针int result1 = std::invoke(&Service::process, ptr, 10);int result2 = std::invoke(&Service::process, unique, 20);// 引用包装器支持Service service;auto ref = std::ref(service);int result3 = std::invoke(&Service::process, ref, 30);
}