AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

C++函数对象(仿函数)

2024-06-26 159
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++函数对象(仿函数)

一、概念

重载函数调用操作符的类，其对象常称为函数对象；

函数对象使用重载的()时，行为类似函数调用，也叫仿函数；

函数对象(仿函数)是一个类，不是一个函数；

二、函数对象的使用

1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值；

2.函数对象超出普通函数的概念，函数对象可以有自己的状态

3. 函数对象可以作为参数传递

//函数对象(仿函数)
/*
 * 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值；
 * 函数对象超出普通函数的概念，函数对象可以有自己的状态
 * 函数对象可以作为参数传递
 */
class MyAdd {
public:
    int operator()(int v1, int v2) {
        return v1 + v2;
    }
};
 
// 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值；
void test01() {
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl;
}
 
// 函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint {
public:
    MyPrint() {
        this->count = 0;
    }
 
    void operator()(string test) {
        cout << test << endl;
        this->count++;
    }
 
    int count;//内部自己状态
};
 
void test02() {
    MyPrint myPrint;
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    cout << "函数myPrint的调用次数：" << myPrint.count << endl;
}
 
// 函数对象可以作为参数传递
void doPrint(MyPrint &mp, string test) {
    mp(test);
}
 
void test03() {
    MyPrint myPrint;
    doPrint(myPrint, "Hello");
}

三、谓词

返回bool类型的仿函数称为谓词；

如果operator()接受一个参数，那么叫做一元谓词；

如果operator()接受两个参数，那么叫做二元谓词；

 
//仿函数，返回值类型bool数据类型，称为谓词
//一元谓词
class BreaterFive {
public:
    bool operator()(int val) {
        return val > 5;
    }
};
 
void test04() {
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }
    // 查找容器中，有没有大于5的数字
    // BreaterFive()匿名函数对象
    vector<int>::iterator it = find_if(v.begin(), v.end(), BreaterFive());
 
    if (it != v.end()) {
        cout << "找到了大于5的数字：" << *it << endl;
    } else {
        cout << "没有找到" << endl;
    }
 
}
 
//二元谓词
class MyCompare {
public:
    bool operator()(int v1, int v2) {
        return v1 > v2;
    }
};
 
void test05() {
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    // 默认排序从小到大
    cout << "默认排序" << endl;
    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    cout << "自定义排序，从大到小：" << endl;
    sort(v.begin(), v.end(), MyCompare());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

四、内建算数仿函数

 
//内建函数对象，算数仿函数
// negate 一元仿函数，取反仿函数
void test06() {
    negate<int> n;
    cout << n(50) << endl;
    // 20 加法
    cout << plus<int>()(10, 20) << endl;
    // -10 减法
    cout << minus<int>()(10, 20) << endl;
    // 200 乘法
    cout << multiplies<int>()(10, 20) << endl;
    // 0 除法
    cout << divides<int>()(10, 20) << endl;
    // 10 取模
    cout << modulus<int>()(10, 20) << endl;
}

五、内建关系仿函数

 
//内建函数对象，关系函数
void test07() {
    // 等于 0
    cout << equal_to<int>()(10, 20) << endl;
    // 不等于 1
    cout << not_equal_to<int>()(10, 20) << endl;
    // 大于 0
    cout << greater<int>()(10, 20) << endl;
    // 大于等于 0
    cout << greater_equal<int>()(10, 20) << endl;
    // 小于 1
    cout << less<int>()(10, 20) << endl;
    // 小于等于 1
    cout << less_equal<int>()(10, 20) << endl;
}
 
void test08() {
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    // 默认排序从小到大
    cout << "默认排序" << endl;
    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    cout << "内建函数排序，从大到小：" << endl;
    sort(v.begin(), v.end(), greater<int>());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

六、内建逻辑仿函数

 
//内建函数对象_逻辑仿函数
//逻辑非 logical_not
void test09() {
    vector<bool> v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);
    for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    vector<bool> v2;
    v2.resize(v.size());
    //源数据开始位置、源数据结束位置、目标开始位置、转换函数
    transform(v.begin(),v.end(),v2.begin(),logical_not<bool>());
    for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}

七、全部代码

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>//内件函数对象头文件
 
using namespace std;
//函数对象(仿函数)
/*
 * 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值；
 * 函数对象超出普通函数的概念，函数对象可以有自己的状态
 * 函数对象可以作为参数传递
 */
class MyAdd {
public:
    int operator()(int v1, int v2) {
        return v1 + v2;
    }
};
 
// 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值；
void test01() {
    MyAdd myAdd;
    cout << myAdd(10, 10) << endl;
}
 
// 函数对象超出普通函数的概念，函数对象可以有自己的状态
class MyPrint {
public:
    MyPrint() {
        this->count = 0;
    }
 
    void operator()(string test) {
        cout << test << endl;
        this->count++;
    }
 
    int count;//内部自己状态
};
 
void test02() {
    MyPrint myPrint;
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    myPrint("hi");
    cout << "函数myPrint的调用次数：" << myPrint.count << endl;
}
 
// 函数对象可以作为参数传递
void doPrint(MyPrint &mp, string test) {
    mp(test);
}
 
void test03() {
    MyPrint myPrint;
    doPrint(myPrint, "Hello");
}
 
//仿函数，返回值类型bool数据类型，称为谓词
//一元谓词
class BreaterFive {
public:
    bool operator()(int val) {
        return val > 5;
    }
};
 
void test04() {
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }
    // 查找容器中，有没有大于5的数字
    // BreaterFive()匿名函数对象
    vector<int>::iterator it = find_if(v.begin(), v.end(), BreaterFive());
 
    if (it != v.end()) {
        cout << "找到了大于5的数字：" << *it << endl;
    } else {
        cout << "没有找到" << endl;
    }
 
}
 
//二元谓词
class MyCompare {
public:
    bool operator()(int v1, int v2) {
        return v1 > v2;
    }
};
 
void test05() {
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    // 默认排序从小到大
    cout << "默认排序" << endl;
    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    cout << "自定义排序，从大到小：" << endl;
    sort(v.begin(), v.end(), MyCompare());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
 
//内建函数对象，算数仿函数
// negate 一元仿函数，取反仿函数
void test06() {
    negate<int> n;
    cout << n(50) << endl;
    // 20 加法
    cout << plus<int>()(10, 20) << endl;
    // -10 减法
    cout << minus<int>()(10, 20) << endl;
    // 200 乘法
    cout << multiplies<int>()(10, 20) << endl;
    // 0 除法
    cout << divides<int>()(10, 20) << endl;
    // 10 取模
    cout << modulus<int>()(10, 20) << endl;
}
 
//内建函数对象，关系函数
void test07() {
    // 等于 0
    cout << equal_to<int>()(10, 20) << endl;
    // 不等于 1
    cout << not_equal_to<int>()(10, 20) << endl;
    // 大于 0
    cout << greater<int>()(10, 20) << endl;
    // 大于等于 0
    cout << greater_equal<int>()(10, 20) << endl;
    // 小于 1
    cout << less<int>()(10, 20) << endl;
    // 小于等于 1
    cout << less_equal<int>()(10, 20) << endl;
}
 
void test08() {
    vector<int> v;
    v.push_back(10);
    v.push_back(40);
    v.push_back(20);
    v.push_back(30);
    v.push_back(50);
    // 默认排序从小到大
    cout << "默认排序" << endl;
    sort(v.begin(), v.end());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    cout << "内建函数排序，从大到小：" << endl;
    sort(v.begin(), v.end(), greater<int>());
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
 
//内建函数对象_逻辑仿函数
//逻辑非 logical_not
void test09() {
    vector<bool> v;
    v.push_back(true);
    v.push_back(false);
    v.push_back(true);
    v.push_back(false);
    for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    vector<bool> v2;
    v2.resize(v.size());
    //源数据开始位置、源数据结束位置、目标开始位置、转换函数
    transform(v.begin(),v.end(),v2.begin(),logical_not<bool>());
    for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
 
int main() {
    // test01();
    // test02();
    // test03();
    // test04();
    // test05();
    // test06();
    // test07();
    // test08();
    test09();
    system("pause");
    return 0;
}

文章标签：
C++
关键词：
C++函数
C++对象
C++仿函数
C++函数对象
C++函数对象仿函数
好奇的菜鸟
目录
相关文章
平凡程序猿~
|
编译器 C++ 开发者
【C++篇】深度解析类与对象（下）
在上一篇博客中，我们学习了C++的基础类与对象概念，包括类的定义、对象的使用和构造函数的作用。在这一篇，我们将深入探讨C++类的一些重要特性，如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象，以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念，提升代码的健壮性、灵活性和可维护性。
平凡程序猿~
422 0
hahaha无
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果：注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。return 0;
hahaha无
277 0
羑悻的小杀马特
|
编译器 C语言 C++
类和对象的简述（c++篇）
类和对象的简述（c++篇）
羑悻的小杀马特
360 28
预备女程序员a
|
编译器 C++
类和对象（中 ）C++
本文详细讲解了C++中的默认成员函数，包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系，如构造函数的主要任务是初始化对象，而非创建空间；析构函数用于清理资源；拷贝构造与赋值运算符的区别在于前者用于创建新对象，后者用于已存在的对象赋值。同时，文章还探讨了运算符重载的规则及其应用场景，并通过实例加深理解。最后强调，若类中存在资源管理，需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
预备女程序员a
374 1
预备女程序员a
|
存储 编译器 C++
类和对象（上）（C++）
本篇内容主要讲解了C++中类的相关知识，包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符（public、protected、private）的使用规则，以及class与struct的区别。同时分析了类实例化的概念，对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制，解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
预备女程序员a
342 1
ephemerals__
|
安全 C++
【c++】继承（继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员）
本文深入探讨了C++中的继承机制，作为面向对象编程（OOP）的核心特性之一。继承通过允许派生类扩展基类的属性和方法，极大促进了代码复用，增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式（public、protected、private）、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题，并对比了继承与组合的优缺点。最后总结指出，虽然继承提高了代码灵活性和复用率，但也带来了耦合度高的问题，建议在“has-a”和“is-a”关系同时存在时优先使用组合。
ephemerals__
946 6
RossyYan
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
370 19
RossyYan
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
570 13
预备女程序员a
|
编译器 C++
类和对象（下）C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化，尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中，`explicit`可禁用隐式转换。静态成员属类而非对象，受访问限定符约束。内部类是独立类，可增强封装性。匿名对象生命周期短，常用于临时场景。编译器会优化对象拷贝以提高效率。最后，鼓励大家通过重复练习提升技能！
预备女程序员a
300 0
平凡程序猿~
|
安全 编译器 C语言
【C++篇】深度解析类与对象（中）
在上一篇博客中，我们学习了C++类与对象的基础内容。这一次，我们将深入探讨C++类的关键特性，包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键，也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
平凡程序猿~
314 0