C++ STL:函数对象

简介: C++ STL:函数对象

Part 5:函数对象

函数对象(仿函数):重载了函数调用运算符的类创建的对象,将所有的函数形式进行统筹,实现容器的定制化操作。

1、function

函数类型的容器。包装具有指定函数调用签名的任意可复制构造类型的可调用对象

  • 普通函数 | 成员函数
  • 函数指针
  • 重载了函数调用运算符的类创建的对象
// std::function 相当于是函数类型的容器
 // 1、std::bind + std::function 绑定普通函数
 std::function<> f = std::bind(add, 1, 2);
 cout << f() << endl;        // 输出 3
 std::function<int(int)> f1 = std::bind(add, 1, _1);
 cout << f1(10) << endl;     // 输出 11
 std::function<int(int, int)> f2 = std::bind(add, 1, _2);  // 不推荐,这里只为了演示
 cout << f2(10, 11) << endl;  // 输出 12
 ///2、std::bind + std::function 绑定普通函数
 std::function<> f = std::bind(&MyTest::add, &mytest, 1, 2);
 cout << f() << endl;         // 输出 3
 std::function<int(int)> f1 = std::bind(&MyTest::add, &mytest, _1, 2);
 cout << f1(10) << endl;      // 输出 12
 std::function<int(int, int)> f2 = std::bind(&MyTest::add, mytest, _1, _1);
 cout << f2(10, 20) << endl;  // 输出 20

2、function + bind 多态

关于 bind 的方法:见我的博客 C++ STL:适配器 Adapter 中的函数适配器部分。

多态的实现机制

  • 继承 + 虚函数
  • 回调函数:组件 + 接口

function + bind 通过函数对象,注册回调函数,实现多态,取代继承 + 虚函数实现多态的机制。相比于虚函数多态机制,回调函数多态机制具有灵活性:

  • 不再需要虚函数。虚函数本身就很严格
  • 不再需要继承。聚合
  • 非常直接,想调用哪个方法,注册对应的回调函数即可

例如:计算图形的面积

测试1:继承 + 虚函数实现的多态

#include <math.h>
 #include <iostream>
 #include <string>
 #include <memory>
 using std::cout;
 using std::endl;
 using std::string;
 using std::unique_ptr;
 class Figure {
 public:
     virtual void display() const =0;
     virtual double area()=0;
     virtual ~Figure() {}
 };
 class Circle: public Figure {
 public:
     Circle(double radius)
     : _radius(radius)
     {}
     void display() const
     {   cout << "circle";   }
     double area() {
         return 3.14159 * _radius * _radius;
     }
     ~Circle() { cout << "~Circle()" << endl;    }
 private:
     double _radius;
 };
 class Rectangle: public Figure {
 public:
     Rectangle(double length, double width)
     : _length(length)
     , _width(width)
     {}
     ~Rectangle() { cout << "~Rectangle()" << endl; }
     void display() const
     {   cout << "rectangle";    }
     double area()
     {   return _length * _width;    }
 private:
     double _length;
     double _width;
 };
 class Triangle: public Figure {
 public:
     Triangle(double a, double b, double c)
     : _a(a), _b(b), _c(c) {}
     ~Triangle() {   cout << "~Triangle()" << endl;  }
     void display() const
     {   cout << "triangle";}
     double area() {
         double p = (_a + _b + _c) / 2;
         return sqrt(p * (p - _a) * (p - _b) * (p - _c));
     }
 private:
     double _a;
     double _b;
     double _c;
 };
 void display(Figure * fig) {
     fig->display();
     cout << "的面积是:" << fig->area() << endl;
 }
 int main(void) {
     Rectangle rectangle(10, 20);
     Circle circle(10);
     Triangle triangle(3, 4, 5);
     display(&rectangle);
     display(&circle);
     display(&triangle);
     return 0;
 }

测试2:function + bind 实现的多态

#include <math.h>
 #include <iostream>
 #include <string>
 #include <memory>
 #include <functional>
 using std::cout;
 using std::endl;
 using std::string;
 using std::unique_ptr;
 /* 
     通过 std::function + std::bind 取代继承 + 虚函数, 实现多态的机制
     这种多态机制的灵活性体现在:
     1. 不再需要虚函数,虚函数本身就是很严格
     2. 不再需要继承
     3. 非常直接,想调用哪个方法,注册对应的回调函数即可
 */
 // Figure 不是抽象类,而是一个具体类
 class Figure {
 public:
     using DisplayCallback = std::function<void()>;
     using AreaCallback = std::function<double()>;
     Figure() {  cout << "Figure()" << endl;};
     ~Figure() {}
     void setCallbacks(DisplayCallback && cb1, AreaCallback && cb2) {
         _displayCallback = std::move(cb1);
         _areaCallback = std::move(cb2);
     }
     void handleDisplayCallback() {
         if(_displayCallback){
             _displayCallback();
         }
     }
     double handleAreaCallback() {
         if(_areaCallback) 
             return  _areaCallback();
         else 
             return 0;
     }
     DisplayCallback _displayCallback;
     AreaCallback _areaCallback;
 };
 // 不再使用继承
 class Circle {
 public:
     Circle(double radius)
     : _radius(radius)
     {}
     void display() const
     {   cout << "circle";   }
     double area() {
         return 3.14159 * _radius * _radius;
     }
     ~Circle() { cout << "~Circle()" << endl;    }
 private:
     double _radius;
 };
 class Rectangle {
 public:
     Rectangle(double length, double width)
     : _length(length), _width(width) {}
     ~Rectangle() { cout << "~Rectangle()" << endl; }
     void print() const
     {   cout << "rectangle";    }
     double calcArea()
     {   return _length * _width;    }
 private:
     double _length;
     double _width;
 };
 class Triangle {
 public:
     Triangle(double a, double b, double c)
     : _a(a), _b(b), _c(c) {}
     ~Triangle() {   cout << "~Triangle()" << endl;  }
     void show() const
     {   cout << "triangle";}
     double getArea() {
         double p = (_a + _b + _c) / 2;
         return sqrt(p * (p - _a) * (p - _b) * (p - _c));
     }
 private:
     double _a;
     double _b;
     double _c;
 };
 void display(Figure & fig) {
     fig.handleDisplayCallback();
     cout << "的面积是:" << fig.handleAreaCallback() << endl;
 }
 int main(void) {
     Rectangle rectangle(10, 20);
     Circle circle(10);
     Triangle triangle(3, 4, 5);
     // 1、注册回调函数
     // 2、执行回调函数
     Figure fig;
     fig.setCallbacks(
         std::bind(&Rectangle::print, &rectangle),
         std::bind(&Rectangle::calcArea, &rectangle));
     display(fig);
     cout << endl;
     fig.setCallbacks(
         std::bind(&Circle::display, &circle),
         std::bind(&Circle::area, &circle));
     display(fig);
     cout << endl;
     fig.setCallbacks(
         std::bind(&Triangle::show, &triangle),
         std::bind(&Triangle::getArea, &triangle));
     display(fig);
     return 0;
 }
目录
打赏
0
0
0
0
2
分享
相关文章
【c++丨STL】基于红黑树模拟实现set和map(附源码)
本文基于红黑树的实现,模拟了STL中的`set`和`map`容器。通过封装同一棵红黑树并进行适配修改,实现了两种容器的功能。主要步骤包括:1) 修改红黑树节点结构以支持不同数据类型;2) 使用仿函数适配键值比较逻辑;3) 实现双向迭代器支持遍历操作;4) 封装`insert`、`find`等接口,并为`map`实现`operator[]`。最终,通过测试代码验证了功能的正确性。此实现减少了代码冗余,展示了模板与仿函数的强大灵活性。
116 2
【c++丨STL】map/multimap的使用
本文详细介绍了STL关联式容器中的`map`和`multimap`的使用方法。`map`基于红黑树实现,内部元素按键自动升序排列,存储键值对,支持通过键访问或修改值;而`multimap`允许存在重复键。文章从构造函数、迭代器、容量接口、元素访问接口、增删操作到其他操作接口全面解析了`map`的功能,并通过实例演示了如何用`map`统计字符串数组中各元素的出现次数。最后对比了`map`与`set`的区别,强调了`map`在处理键值关系时的优势。
232 73
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
48 0
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
【c++丨STL】set/multiset的使用
本文深入解析了STL中的`set`和`multiset`容器,二者均为关联式容器,底层基于红黑树实现。`set`支持唯一性元素存储并自动排序,适用于高效查找场景;`multiset`允许重复元素。两者均具备O(logN)的插入、删除与查找复杂度。文章详细介绍了构造函数、迭代器、容量接口、增删操作(如`insert`、`erase`)、查找统计(如`find`、`count`)及`multiset`特有的区间操作(如`lower_bound`、`upper_bound`、`equal_range`)。最后预告了`map`容器的学习,其作为键值对存储的关联式容器,同样基于红黑树,具有高效操作特性。
171 3
C++ 容器全面剖析:掌握 STL 的奥秘,从入门到高效编程
C++ 标准模板库(STL)提供了一组功能强大的容器类,用于存储和操作数据集合。不同的容器具有独特的特性和应用场景,因此选择合适的容器对于程序的性能和代码的可读性至关重要。对于刚接触 C++ 的开发者来说,了解这些容器的基础知识以及它们的特点是迈向高效编程的重要一步。本文将详细介绍 C++ 常用的容器,包括序列容器(`std::vector`、`std::array`、`std::list`、`std::deque`)、关联容器(`std::set`、`std::map`)和无序容器(`std::unordered_set`、`std::unordered_map`),全面解析它们的特点、用法
C++ 容器全面剖析:掌握 STL 的奥秘,从入门到高效编程
|
4月前
|
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
241 6
【c++丨STL】priority_queue(优先级队列)的使用与模拟实现
本文介绍了STL中的容器适配器`priority_queue`(优先级队列)。`priority_queue`根据严格的弱排序标准设计,确保其第一个元素始终是最大元素。它底层使用堆结构实现,支持大堆和小堆,默认为大堆。常用操作包括构造函数、`empty`、`size`、`top`、`push`、`pop`和`swap`等。我们还模拟实现了`priority_queue`,通过仿函数控制堆的类型,并调用封装容器的接口实现功能。最后,感谢大家的支持与关注。
219 1
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等