网站建设电脑免费进销存软件哪个简单好用

网站建设电脑,免费进销存软件哪个简单好用,seo网站优化服务商,福州网络公司可调用对象function类 函数指针 用于指向普通成员函数和静态成员函数 定义与使用 定义一个普通函数 int func(int, int);定义函数指针类型的变量 int (*funcPtr)(int, int); //指针通常用ptr表示使用函数指针的实例#xff1a; #includeiostream//定义函数指针…可调用对象function类函数指针用于指向普通成员函数和静态成员函数定义与使用定义一个普通函数int func(int, int);定义函数指针类型的变量int (*funcPtr)(int, int); //指针通常用ptr表示使用函数指针的实例#includeiostream //定义函数指针类型的变量 int (*funcPtr)(int, int); //定义一个普通函数 int add(int a, int b){ return a b; } int main() { //函数指针指向函数 funcPtr add; //也可以写funcPtr add;函数名等于函数的地址 //调用函数指针指向的函数 funcPtr(1, 2); //不用写成(*funcPtr)(1, 2),编译器会自动解引用两种写法效果一样 return 0; }优点与局限性优点简单直观适用于简单的回调函数1。局限性不能捕获上下文如lambda中的闭包。语法相对复杂尤其是指针的声明和使用。仿函数Functors)仿函数又称为函数对象是在C中重载了operator()的类或结构体实例仿函数不仅可以像普通函数一样被调用还能携带状态。定义和使用代码实例#includeiostream struct Adder{ int to_add; Adder(int value) : to_add(value){} //构造函数 int operator()(int x){ //重载() return x to_add; } }; int main() { Adder adder(5); adder(10); //adder是结构体Adder的实例且结构体内重载了(),所以可以像函数一样使用 std::cout510adder(10)std::endl;//输出51015 return 0; }特点携带状态仿函数可以拥有内部状态通过成员变量存储数据使其在调用时具备上下文信息。灵活性高可以根据需要添加更多的成员函数和变量扩展功能。性能优化编译器可以对仿函数进行优化。仿函数应用场景1.高级实例#includeiostream //可变累加器仿函数 struct Accumulator{ int sum; Accumulator() : sum(0){} //重载() void operator()(int x){ return sum x; } }; int main() { Accumulator acc; acc(10); acc(20); acc(30); std::cout acc.sum std::endl; //输出60 return 0; }2.使用仿函数的标准库算法#includeiostream #includevector #includealgorithm //反函数判断一个数是否大于某个阈值 struct IsGreaterThan{ int threshold; //阈值的英文 IsGreaterThan(int t) : threshold(t){} bool operator()(int x) const { return x threshold; } }; int main() { std::vectorint numbers {1, 5, 10, 15, 20}; //使用仿函数进行筛选 IsGreaterThan greaterThan10(10); auto it std::find_if(numbers.begin(), numbers.end(), greaterThan10); if(it ! numbers.end()){ std::cout 第一个大于10的数是 *it std:;endl; }else{ std::cout 没有找到大于10的数 std:;endl; } return 0; }find_if()是在迭代器指定范围内查找第一个满足自定义条件的元素前两个参数传入查找范围的迭代器第三个参数是一元谓词他是一个可调用对象函数Lambda函数对象等作用是定义查找查找条件接受遍历到的元素作为参数返回bool。3.仿函数与模板#includeiostream #includevector #includealgorithm //通用比较仿函数 templatetypename T struct Compare{ bool operator()(const T a, const T b){ return a b; } }; int main() { std::vectorint numbers {5, 2, 8, 1, 9}; //使用仿函数进行排序 std::sort(numbers.begin(), numbers.end(), Compareint()); for(auto it : numbers) { std::cout num ; //输出1,2,5,8,9 } retuurn 0; }std::sort主要使用快速排序4.仿函数的优势可扩展性能够根据需要添加更多功能和状态。与Lambda互补性在需要携带复杂状态或多次调用时仿函数比Lambda更适合。类型安全仿函数是具体的类型可以在编译期进行类型检查。5.何时使用仿函数需要携带状态时当回调函数需要维护内部状态时仿函数是理想选择。复杂操作当简单的函数指针或Lambda难以表达复杂逻辑时。性能关键场景由于仿函数可以被编译器优化适用于性能敏感的代码。Lambda表达式Lambda表达式是C11引入的一种轻量级函数对象允许在代码中定义匿名函数。它们可以捕获周围的变量具有更强的表达能力。基本语法[captures](parameters) - return_type{ //函数体 }captures捕获外部变量的方式可以是值捕获、引用捕获或者混合捕获。parameters参数列表。return_type返回类型可以省略省略后需把-一起删掉编译器会自动推导。#includeiostream #includevector #includealgorithm int main() { int threshold 5; std::vectorint numbers {1,6,3,8,2,7}; auto new_end std::remove_if(numbers.begin(), numbers.end(), [threshold](int n){//值捕获把threshold的值捕获使用 return x threshold; }); numbers.erase(new_end, numbers.end()); for(auto n : numbers){ std::cout n ; //输出6,8,7 } std::coutstd::endl; return 0; }示例中remove_if()是把大于等于5的数字移动到容器前前面小于5的数字会被覆盖掉在C中 remove_if 是一个标准库算法用于移除容器中满足特定条件的元素。它不会真正从容器中删除元素而是将不满足条件的元素移动到容器的前面并返回一个指向新逻辑末尾的迭代器吗可以结合 erase 方法来实现真正的删除。捕获方式值捕获[]捕获所有外部变量的副本若要修改需加mutable关键字修改不会影响原变量。引用捕获[]捕获所有外部变量的引用直接操作原变量无需mutable关键字即可修改。混合捕获指定部分变量按值捕获部分按引用捕获如[, var]或[, var]。无捕获[]不捕获任何外部变量。#includeiostream #includememory struct Adder{ int to_add; Adder(int value) : to_add(value){} //构造函数 int operator()(int x){ //重载() return x to_add; } void add(int x){ to_add x; } }; int main() { auto add_ptr std::make_sharedAdder(10); auto lambda1 [add_ptr](int x){ //lambda1经过这个lambda表达式后就是一个可调用对象 add_ptr-add(x); //打印引用计数 std::cout add_ptr.use_count() std::endl; //2 //这个智能指针被[]通过值的方式捕获相当于捕获这个智能指针的副本两个智能指针指向这块内存引用计数加一 }; lambda1(5); return 0; }可变Lambda默认情况下Lambda表达式是不可变的 const 。通过 mutable 关键字可以允许修改捕获的变量副本。不常用#includeiostream int main() { int count 0; auto increment [count]() mutable{ count; std::cout Count inside Lambda: count std::endl; }; increment(); //输出Count inside Lambda: 1 increment(); //输出Count inside Lambda: 2 std::cout Count outside Lambda: count std::endl; //输出Count outside Lambda: 0 return 0; }捕获成员函数和类变量#includeiostream #includevector #includealgorithm class Processor { public: Processor(int x) : _threshold(x) {} void process(std::vectorint data) { std::cout 处理前的数据 std::endl; for(auto num : data) std::cout num ; std::coutstd::endl; //使用Lambda表达式进行过滤 data.erase(std::remove_if(data.begin(), data.end(), [this](int n){ return n _threshold; }), data.end()); std::cout 处理后的数据 std::endl; for(auto num : data) std::cout num ; std::coutstd::endl; } private: int _threshold; //变量前加下划线隐含“私有/内部使用” }; int main() { std::vectorint numbers {1, 6, 3, 8, 2, 7}; Processor proc(5); proc.process(numbers); /* 输出 处理前的数据1 6 3 8 2 7 处理后的数据6 8 7 */ return 0; }Lambda与标准库算法#includeiostrea #includevector #includealgorithm int main() { std::vectorint numbers {4, 2, 5, 1, 3} //使用Lambda表达式进行排序 std::sort(numbers.begin(), numbers.end(), [](int a, int b) - bool { return a b; }); std::cout 排序后的数字; for(auto num : numbers){ std::cout num ; //输出1 2 3 4 5 } std::cout std::endl return 0; }Lambda表达式的优势简洁性代码更加紧凑易于理解。灵活性能够捕获外部变量适应更多场景。性能优化编译器可以对Lambda进行优化如内联展开。与标准库的良好集成与STL算法无缝结合简化代码逻辑。std::function 对象std::function 是C11提供的一个通用的可调用包装器能够封装任何可调用对象包括普通函数、Lambda表达式、函数对象以及绑定表达式。它实现了类型擦除使得不同类型的可调用对象可以通过统一的接口进行操作。#include iostream #include functional // 普通函数 int add(int a, int b) { return a b; } // 函数对象 struct Multiply { int operator()(int a, int b) const { return a * b; } }; int main() { // 封装普通函数 std::functionint(int, int) func1 add; std::cout Add: func1(3, 4) std::endl; // 输出Add: 7 // 封装Lambda表达式 std::functionint(int, int) func2 [](int a, int b) - int { return a - b; }; std::cout Subtract: func2(10, 4) std::endl; // 输出Subtract: 6 // 封装函数对象 Multiply multiply; std::functionint(int, int) func3 multiply; std::cout Multiply: func3(3, 4) std::endl; // 输出Multiply: 12 return 0; }特点类型擦除可以存储任何符合签名的可调用对象。灵活性支持动态改变存储的可调用对象。性能开销相比于直接使用函数指针或Lambda std::function 可能带来一定的性能开销尤其是在频繁调用时。用法场景回调函数的传递。事件处理系统。策略模式的实现。示例回调机制#include iostream #include functional // 定义回调类型 using Callback std::functionvoid(int); // 触发事件的函数 void triggerEvent(Callback cb, int value) { // 事件发生调用回调 cb(value); } int main() { // 使用Lambda作为回调 triggerEvent([](int x) { std::cout 事件触发值为 x std::endl; }, 42); // 输出事件触发值为42 // 使用仿函数作为回调 struct Printer { void operator()(int x) const { std::cout Printer打印值 x std::endl; } } printer; triggerEvent(printer, 100); // 输出Printer打印值100 return 0; }存储和调用不同类型的可调用对象#include iostream #include functional #include vector int add(int a, int b) { return a b; } struct Multiply { int operator()(int a, int b) const { return a * b; } }; int main() { std::vectorstd::functionint(int, int) operations; // 添加不同类型的可调用对象 operations.emplace_back(add); // 普通函数 operations.emplace_back(Multiply()); // 仿函数 operations.emplace_back([](int a, int b) - int { return a - b; }); // lambda // 执行所有操作 for(auto op : operations) { std::cout op(10, 5) ; // 输出15 50 5 } std::cout std::endl; return 0; }std::bind操作std::bindC11中提供的一个函数适配器用于绑定函数或可调用对象的部分参数生成一个新的可调用对象。它允许提前固定某些参数简化函数调用或适应接口需求。#include iostream #include functional // 普通函数 int add(int a, int b) { return a b; } int main() { // 绑定第一个参数为10生成新的函数对象 auto add10 std::bind(add, 10, std::placeholders::_1); std::cout 10 5 add10(5) std::endl; // 输出10 5 15 return 0; }bind头文件也在functional里。占位符std::placeholdersstd::bind使用占位符来表示未绑定的参数这些占位符决定了在生成的新函数对象中如何传递参数。常用占位符包括std::placeholder::_1std::placeholder::_2std::placeholder::_3等等最多10个。以 _1 、 _2 、 _3 …表示代表新可调用对象被调用时的第1、2、3…个参数。属于 std::placeholders 命名空间使用时需显式指定如 std::placeholders::_1 。#include iostream #include functional void display(const std::string msg, int count) { for(int i 0; i count; i) { std::cout msg std::endl; } } int main() { // 绑定消息为Hello生成新的函数对象只需要传递次数 auto sayHello std::bind(display, Hello, std::placeholders::_1); sayHello(3); /* 输出: Hello Hello Hello */ // 绑定次数为2生成新的函数对象只需要传递消息 auto sayTwice std::bind(display, std::placeholders::_1, 2); sayTwice(Hi); /* 输出: Hi Hi */ return 0; }与Lambda表达式的对比std::bind曾在C11中广泛使用但随着Lambda表达式的普及很多情况下Lambda更为直观和高效。不过在某些复杂的参数绑定场景下std::bind依然有其独特优势。使用std::bind#include iostream #include functional int multiply(int a, int b) { return a * b; } int main() { // 绑定第一个参数为2生成新的函数对象 auto multiplyBy2 std::bind(multiply, 2, std::placeholders::_1); std::cout 2 * 5 multiplyBy2(5) std::endl; // 输出2 * 5 10 return 0; }使用Lambda表达式#include iostream #include functional int multiply(int a, int b) { return a * b; } int main() { // 使用Lambda表达式绑定第一个参数为2 auto multiplyBy2 [](int b) - int { return multiply(2, b); }; std::cout 2 * 5 multiplyBy2(5) std::endl; // 输出2 * 5 10 return 0; }使用std::bind绑定成员函数#include iostream #include functional class Calculator { public: int multiply(int a, int b) const { return a * b; } }; int main() { Calculator calc; // 绑定成员函数multiply固定第一个参数为5 auto multiplyBy5 std::bind(Calculator::multiply, calc, 5, std::placeholders::_1); std::cout 5 * 3 multiplyBy5(3) std::endl; // 输出5 * 3 15 return 0; }类的成员函数需要加取地址符使用Lambda表达式绑定成员函数#include iostream #include functional class Greeter { public: void greet(const std::string name) const { std::cout Hello, name ! std::endl; } }; int main() { Greeter greeter; // 使用Lambda表达式绑定成员函数 auto greetFunc [greeter](const std::string name) { greeter.greet(name); }; greetFunc(Alice); // 输出Hello, Alice! return 0; }如果绑定的成员函数有返回值在Lambda表达式中要return。绑定静态成员函数静态成员函数不依赖于类的实例可以像普通函数一样使用std::bind和std::function。#include iostream #include functional class Logger { public: static void log(const std::string message) { std::cout Log: message std::endl; } }; int main() { // 使用std::bind绑定静态成员函数 auto logFunc std::bind(Logger::log, std::placeholders::_1); logFunc(This is a static log message.); // 输出Log: This is a static log message. return 0; }绑定带有返回值的成员函数#include iostream #include functional class Math { public: double power(double base, double exponent) const { double result 1.0; for(int i 0; i static_castint(exponent); i) { result * base; } return result; } }; int main() { Math mathObj; // 绑定成员函数power固定基数为2 auto powerOf2 std::bind(Math::power, mathObj, 2.0, std::placeholders::_1); std::cout 2^3 powerOf2(3) std::endl; // 输出2^3 8 return 0; }注意事项对象生命周期绑定成员函数时确保对象在可调用对象使用期间依然存在以避免悬空指针问题。指针与引用可以通过指针或引用传递对象实例给std::bind或Lambda表达式。捕获方式在使用Lambda表达式时选择合适的捕获方式值捕获或引用捕获以确保对象的正确访问。回调函数是指被作为参数传递给另一个函数称为“主调函数”的函数主调函数在合适时机会调用这个回调函数。 ↩︎