C++STL函数对象的应用-EW帮帮网

STL函数对象

文章目录

- - STL函数对象

C++中的函数对象（Function Object），也常被称为仿函数（Functor），是一种模拟函数行为的类对象。它们允许用户自定义操作，并能像普通函数那样被调用，同时还能携带状态，这是普通函数所不具备的能力。函数对象是实现泛型编程、算法定制等高级技术的关键组件之一。下面概述了函数对象的基本概念和使用方法：

1.基本概念

类定义：函数对象通常是一个重载了()操作符的类。这个操作符使得该类的对象可以像函数一样被调用。
状态携带：与普通函数不同，函数对象可以拥有成员变量，从而在不同的调用之间保持状态。
类型要求：为了能够用于标准库算法中，函数对象需要满足可调用对象的要求，即至少要有一个operator()成员函数。

2.使用方法

1. 简单函数对象示例

#include <iostream>

// 定义一个简单的函数对象类，重载了()操作符
class Adder {
public:
    // 构造函数可以初始化内部状态
    Adder(int add_value) : value(add_value) {}

    // 重载()操作符，使得对象可以像函数一样被调用
    int operator()(int x) {
        return x + value;
    }

private:
    int value; // 成员变量，保存加到输入值上的额外值
};

int main() {
    Adder addFive(5); // 创建一个Adder对象，初始化加值为5
    std::cout << addFive(10) << std::endl; // 调用仿函数，输出15
    return 0;
}

2. 函数对象作为算法参数

C++标准库中的许多算法都接受函数对象作为参数，以定制其行为。例如，std::sort可以通过传递自定义比较函数来改变排序规则。

#include <algorithm>
#include <vector>
#include <iostream>

// 一个用于降序比较的仿函数
struct DescComp {
    bool operator()(int a, int b) {
        return a > b;
    }
};

int main() {
    std::vector<int> vec = {1, 3, 5, 2, 4};
    
    // 使用自定义的降序比较仿函数进行排序
    std::sort(vec.begin(), vec.end(), DescComp());
    
    for(int i : vec) {
        std::cout << i << " ";
    }
    // 输出：5 4 3 2 1
    return 0;
}

3. Lambda表达式作为函数对象

从C++11开始，Lambda表达式提供了一种更简洁的方式创建匿名函数对象，它可以直接在代码中定义并使用。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // 使用Lambda表达式作为自定义排序规则
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b; // 降序排列
    });
    
    for(int i : vec) {
        std::cout << i << " ";
    }
    // 输出：5 4 3 2 1
    return 0;
}

通过上述示例，可以看到函数对象在C++中提供了强大的灵活性和定制能力，是泛型编程和算法设计中的重要工具。

2.一元谓词和二元谓词

C++中的一元谓词和二元谓词是两种特定类型的函数对象，它们在标准模板库(STL)的算法中扮演着重要的角色，用于定制算法的行为。以下是它们的基本概念和使用方法：

1.一元谓词

基本概念：

一元谓词是只接受一个参数的函数对象，并返回一个布尔值（bool）。
这个函数对象通常用来测试或判断传入的参数是否满足某个条件。
在STL算法中，一元谓词常用于从容器中选择满足特定条件的元素，例如std::find_if。

使用示例：

#include <algorithm>
#include <vector>
#include <iostream>

// 一元谓词函数对象，检查一个数是否为偶数
struct IsEven {
    bool operator()(int x) {
        return x % 2 == 0;
    }
};

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    auto it = std::find_if(numbers.begin(), numbers.end(), IsEven());
    
    if(it != numbers.end())
        std::cout << "The first even number is: " << *it << std::endl;
    else
        std::cout << "No even number found." << std::endl;
    
    return 0;
}

2.二元谓词

基本概念：

二元谓词接受两个参数，并返回一个布尔值。
它们通常用于比较这两个参数是否满足某种关系，如小于、大于、等于等。
在STL中，二元谓词广泛应用于排序算法（如std::sort）、查找算法（如std::binary_search）等，用以定义元素间的比较规则。

使用示例：

#include <algorithm>
#include <vector>
#include <iostream>

// 二元谓词函数对象，检查第一个数是否大于第二个数
struct GreaterThan {
    bool operator()(int a, int b) {
        return a > b;
    }
};

int main() {
    std::vector<int> values = {5, 2, 9, 1, 5, 6};
    
    // 使用二元谓词进行降序排序
    std::sort(values.begin(), values.end(), GreaterThan());
    
    for(int val : values) {
        std::cout << val << " ";
    }
    // 输出：9 6 5 5 2 1
    
    return 0;
}

3.总结

无论是哪种谓词，它们的核心作用都是提供一个逻辑判断，使得STL算法能够基于这些逻辑判断来处理数据。一元谓词适用于单个元素的条件筛选，而二元谓词则用于定义元素间的关系，比如排序或查找时的比较逻辑。随着C++11及之后版本对Lambda表达式的支持，直接在算法中内联定义谓词变得更加方便快捷。

3.算术仿函数

C++ STL（标准模板库）提供了一系列算术仿函数（Arithmetic Functors），它们是对基本数学运算的封装，使得这些运算可以像函数对象一样被使用，尤其是在算法中进行定制操作时非常有用。以下是一些常用的算术仿函数及其简单说明：

plus：定义了加法操作，重载了operator()以执行加法。
minus：定义了减法操作。
multiplies：实现了乘法操作。
divides：提供了除法操作。
modulus：用于取模运算。
negate：执行取负操作。

1.使用示例

这些仿函数位于<functional>头文件。

#include <iostream>
#include <functional>
#include <algorithm> // 用于std::transform

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::vector<int> results;

    // 使用plus仿函数将每个元素自身相加（即每个元素乘以2）
    results.resize(numbers.size());
    std::transform(numbers.begin(), numbers.end(), results.begin(), std::plus<int>());

    // 输出结果
    for(int res : results) {
        std::cout << res << " ";
    }
    // 输出：2 4 6 8 10

    return 0;
}

在这个例子中，std::transform算法结合std::plus<int>()仿函数，将numbers容器中的每个元素与其自身相加，结果存储在results容器中。

2.Lambda表达式的替代

虽然算术仿函数非常有用，但在C++11及以后的版本中，Lambda表达式提供了更加灵活和直观的方式来定义这样的操作，特别是在复杂逻辑或需要访问外部变量时。然而，对于简单的数学运算，直接使用STL提供的算术仿函数可以简化代码，提高可读性。

4.关系仿函数

关系仿函数封装了基本的比较运算符，位于<functional>头文件中。

equal_to：测试两个参数是否相等。
not_equal_to：测试两个参数是否不相等。
greater：测试第一个参数是否大于第二个参数。
less：测试第一个参数是否小于第二个参数。
greater_equal：测试第一个参数是否大于等于第二个参数。
less_equal：测试第一个参数是否小于等于第二个参数。

#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int target = 3;
    

    // 使用equal_to查找目标值
    if(std::find_if(vec.begin(), vec.end(), std::bind2nd(std::equal_to<int>(), target)) != vec.end()) {
        std::cout << target << " is found in the vector." << std::endl;
    } else {
        std::cout << target << " is not found in the vector." << std::endl;
    }
    return 0;

}

5.逻辑仿函数

逻辑仿函数用于组合或反转布尔值，它们也是在<functional>中定义的，包括：

logical_and：对两个布尔值执行逻辑与操作。
logical_or：对两个布尔值执行逻辑或操作。
logical_not：对一个布尔值执行逻辑非操作。

逻辑仿函数示例

#include <iostream>
#include <functional>

int main() {
    bool flag1 = true, flag2 = false;
    
    // 使用逻辑与
    if(std::logical_and<bool>()(flag1, flag2)) {
        std::cout << "Both flags are true." << std::endl;
    } else {
        std::cout << "Not both flags are true." << std::endl;
    }
    
    // 使用逻辑或
    if(std::logical_or<bool>()(flag1, flag2)) {
        std::cout << "At least one flag is true." << std::endl;
    }
    
    // 使用逻辑非
    std::cout << "Negation of flag2: " << std::logical_not<bool>()(flag2) << std::endl;
    
    return 0;
}

C++STL函数对象的应用