c++迭代器的方法有哪些 (c++迭代器详解)

C++标准库中的Predicate（判断式）和Function Object（函数对象）都是在算法中使用的函数类型。

Predicate（判断式）是一个可调用的函数或函数对象，它接受一个或多个参数，并返回一个bool值，用于判断某个条件是否成立。Predicate通常用于算法中的条件判断，比如使用std::find_if()来查找满足某个条件的元素。

以下是一个使用Predicate的示例：

bool isOdd(int num) {
    return num % 2 != 0;
}

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

在上面的示例中，isOdd()是一个Predicate，它接受一个整数参数，并返回一个bool值，判断该数是否为奇数。通过调用std::find_if()算法，我们可以找到第一个满足isOdd()条件的奇数。

Function Object（函数对象）是一个类或结构体，它重载了函数调用运算符operator()。它可以具有内部状态，并且可以在多次调用之间保持状态。Function Object通常用于算法中需要对元素执行某种操作的情况。

以下是一个使用Function Object的示例：

struct Print {
    void operator()(int num) const {
        std::cout << num << " ";
    }
};

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    std::for_each(numbers.begin(), numbers.end(), Print());
    
    return 0;
}

在上面的示例中，Print是一个Function Object，它重载了函数调用运算符operator()，用于打印传入的整数。通过调用std::for_each()算法，我们可以对numbers中的每个元素应用Print函数对象，从而打印出所有的元素。

总结来说，Predicate用于条件判断，而Function Object用于对元素执行某种操作。它们都是在C++标准库中用于算法的函数类型。

C++标准库中的Predicate（判断式）和Function Object（函数对象）都是在算法中使用的函数类型。

Predicate（判断式）是一个可调用的函数或函数对象，它接受一个或多个参数，并返回一个bool值，用于判断某个条件是否成立。Predicate通常用于算法中的条件判断，比如使用std::find_if()来查找满足某个条件的元素。

以下是一个使用Predicate的示例：

bool isOdd(int num) {
    return num % 2 != 0;
}

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

在上面的示例中，isOdd()是一个Predicate，它接受一个整数参数，并返回一个bool值，判断该数是否为奇数。通过调用std::find_if()算法，我们可以找到第一个满足isOdd()条件的奇数。

Function Object（函数对象）是一个类或结构体，它重载了函数调用运算符operator()。它可以具有内部状态，并且可以在多次调用之间保持状态。Function Object通常用于算法中需要对元素执行某种操作的情况。

以下是一个使用Function Object的示例：

struct Print {
    void operator()(int num) const {
        std::cout << num << " ";
    }
};

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    std::for_each(numbers.begin(), numbers.end(), Print());
    
    return 0;
}

在上面的示例中，Print是一个Function Object，它重载了函数调用运算符operator()，用于打印传入的整数。通过调用std::for_each()算法，我们可以对numbers中的每个元素应用Print函数对象，从而打印出所有的元素。

总结来说，Predicate用于条件判断，而Function Object用于对元素执行某种操作。它们都是在C++标准库中用于算法的函数类型。

C++标准库中提供了一些预定义的Function Object（函数对象）和Binder（绑定器），它们是一些可调用的对象，用于在算法中进行特定的操作。

预定义的Function Object包括：

1. std::less<T>：用于比较两个对象是否满足"<"关系。
2. std::greater<T>：用于比较两个对象是否满足">"关系。
3. std::equal_to<T>：用于比较两个对象是否相等。
4. std::not_equal_to<T>：用于比较两个对象是否不相等。
5. std::logical_and<T>：用于逻辑与操作。
6. std::logical_or<T>：用于逻辑或操作。
7. std::logical_not<T>：用于逻辑非操作。

以下是一个使用预定义的Function Object的示例：

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

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    
    // 使用std::less进行排序
    std::sort(nums.begin(), nums.end(), std::less<int>());
    
    // 使用std::greater进行排序
    std::sort(nums.begin(), nums.end(), std::greater<int>());
    
    // 使用std::equal_to进行比较
    bool isEqual = std::equal_to<int>()(3, 3);
    
    std::cout << isEqual << std::endl;  // 输出：1
    
    return 0;
}

Binder（绑定器）是一种用于将函数对象和参数绑定在一起的工具。它可以创建一个新的函数对象，该对象会在调用时自动传递绑定的参数。

预定义的Binder包括：

1. std::bind1st：将一个二元函数对象的第一个参数绑定为指定的值。
2. std::bind2nd：将一个二元函数对象的第二个参数绑定为指定的值。

以下是一个使用预定义的Binder的示例：

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

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5};
    
    // 使用std::bind1st将小于3的元素替换为0
    std::replace_if(nums.begin(), nums.end(), std::bind1st(std::less<int>(), 3), 0);
    
    // 输出修改后的向量
    for (int num : nums) {
        std::cout << num << " ";
    }
    
    return 0;
}

在上面的示例中，我们使用std::bind1st将std::less函数对象的第一个参数绑定为3，然后将小于3的元素替换为0。最终输出修改后的向量：0 0 3 4 5。

C++标准库中提供了一些预定义的Function Object（函数对象），它们是一些可调用的对象，用于在算法中进行特定的操作。

以下是一些常见的预定义Function Object：

1. std::less<T>：用于比较两个对象的小于关系，返回一个bool值。举例：

std::less<int> lessThan;
bool result = lessThan(5, 10); // 返回true，因为5小于10

2. std::greater<T>：用于比较两个对象的大于关系，返回一个bool值。举例：

std::greater<int> greaterThan;
bool result = greaterThan(10, 5); // 返回true，因为10大于5

3. std::equal_to<T>：用于比较两个对象是否相等，返回一个bool值。举例：

std::equal_to<int> equalTo;
bool result = equalTo(5, 5); // 返回true，因为5等于5

4. std::not_equal_to<T>：用于比较两个对象是否不相等，返回一个bool值。举例：

std::not_equal_to<int> notEqualTo;
bool result = notEqualTo(5, 10); // 返回true，因为5不等于10

这些预定义的Function Object可以直接在算法中使用，例如在std::sort()中指定排序的方式，或者在std::find_if()中指定查找的条件。

C++标准库中提供了一些Function Adapter（函数适配器）和Binder（绑定器），它们用于对函数对象进行适配和绑定。

Function Adapter是一种函数适配器，它可以将一个函数对象的调用方式进行修改，以满足特定的需求。

以下是一些常见的Function Adapter：

1. std::bind：用于将一个函数对象的参数进行绑定，生成一个新的函数对象。可以通过绑定部分参数来创建一个新的函数对象，或者改变参数的顺序。例如：

#include <functional>
#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add5 = std::bind(add, std::placeholders::_1, 5);
    std::cout << add5(10) << std::endl; // 输出 15
    return 0;
}

在上面的例子中，使用std::bind将add函数的第二个参数绑定为5，生成了一个新的函数对象add5。当调用add5时，实际上是调用了add函数，并且第一个参数为传入的参数，第二个参数为5。

2. std::function：用于包装任意可调用对象，使其具有统一的调用方式。例如：

#include <functional>
#include <iostream>

void printHello() {
    std::cout << "Hello" << std::endl;
}

int main() {
    std::function<void()> func = printHello;
    func(); // 输出 Hello
    return 0;
}

在上面的例子中，使用std::function将printHello函数包装成一个可调用对象func。当调用func时，实际上是调用了printHello函数。

Binder（绑定器）是一种特殊的Function Adapter，它可以将一个函数对象和一部分参数进行绑定，生成一个新的函数对象。绑定的参数可以是具体的值，也可以是占位符。例如：

#include <functional>
#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add5 = std::bind(add, std::placeholders::_1, 5);
    std::cout << add5(10) << std::endl; // 输出 15
    return 0;
}

在上面的例子中，使用std::bind将add函数的第二个参数绑定为5，生成了一个新的函数对象add5。当调用add5时，实际上是调用了add函数，并且第一个参数为传入的参数，第二个参数为5。

总结来说，Function Adapter和Binder是C++标准库中提供的一些工具，用于对函数对象进行适配和绑定，以满足特定的需求。

C++标准库中的Function Adapter可以与用户自定义的Function Object搭配使用，以实现特定的功能。

一个常见的例子是使用std::bind函数适配一个用户自定义的Function Object，实现函数的部分参数绑定。std::bind函数接受一个可调用对象和一些参数，并返回一个新的可调用对象，该对象可以在调用时自动绑定部分参数。

下面是一个示例代码：

#include <iostream>
#include <functional>

// 自定义的函数对象
class Multiply {
public:
    int operator()(int a, int b) {
        return a * b;
    }
};

int main() {
    Multiply multiply;

    // 使用std::bind函数适配Multiply对象，将第一个参数绑定为5
    auto multiplyBy5 = std::bind(multiply, 5, std::placeholders::_1);

    int result = multiplyBy5(10); // 调用multiply对象，第一个参数为5，第二个参数为10
    std::cout << result << std::endl; // 输出50

    return 0;
}

在上面的例子中，我们定义了一个Multiply的函数对象，它接受两个参数并返回它们的乘积。然后，我们使用std::bind函数将Multiply对象适配为一个新的函数对象multiplyBy5，其中第一个参数被绑定为5，第二个参数使用std::placeholders::_1占位符表示。

最后，我们调用multiplyBy5函数对象，并传入10作为第二个参数，得到的结果是50，因为5乘以10等于50。这样，我们就通过Function Adapter和用户自定义的Function Object实现了函数的部分参数绑定。

在C++标准库中，有一些Function Adapter被标记为过时的（Deprecated），意味着它们不再推荐使用，可能在未来的版本中会被移除或替换。

以下是一些过时的Function Adapter：

1. std::bind1st和std::bind2nd：这两个函数用于将一个二元函数对象的其中一个参数绑定为固定的值。它们已经被std::bind函数替代，std::bind可以更灵活地绑定参数。

例如：

#include <functional>
#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add5 = std::bind1st(std::plus<int>(), 5);
    std::cout << add5(10) << std::endl; // 输出 15

    auto add5_new = std::bind(add, std::placeholders::_1, 5);
    std::cout << add5_new(10) << std::endl; // 输出 15

    return 0;
}

在上面的例子中，使用std::bind1st将std::plus函数对象的第一个参数绑定为5，生成了一个新的函数对象add5。这种方式已经被std::bind函数取代，可以使用std::bind来实现相同的功能。

2. std::mem_fun和std::mem_fun_ref：这两个函数用于将成员函数适配为函数对象。它们已经被std::mem_fn函数替代，std::mem_fn可以更灵活地处理成员函数和成员指针。

例如：

#include <functional>
#include <iostream>

class MyClass {
public:
    void print() {
        std::cout << "Hello, World!" << std::endl;
    }
};

int main() {
    MyClass obj;

    auto print_func = std::mem_fun(&MyClass::print);
    print_func(obj); // 调用成员函数print

    auto print_func_new = std::mem_fn(&MyClass::print);
    print_func_new(obj); // 调用成员函数print

    return 0;
}

在上面的例子中，使用std::mem_fun将MyClass类的print成员函数适配为函数对象print_func。这种方式已经被std::mem_fn函数取代，可以使用std::mem_fn来实现相同的功能。

总的来说，过时的Function Adapter在新的C++标准中已经被替代或者不再推荐使用，建议使用新的替代方案来实现相同的功能。

C++标准库中的Lambda表达式是一种方便的方式，用于在需要函数对象的地方提供一个匿名的、内联的函数定义。

Lambda表达式的语法如下：

[capture list](parameters) -> return_type { body }

其中：

• capture list：指定在Lambda表达式中可访问的外部变量。可以是空的，或者包含一个或多个变量，使用方括号括起来。可以使用=表示捕获所有外部变量，或使用&表示引用捕获。
• parameters：指定Lambda表达式的参数列表。
• return_type：指定返回值的类型。可以省略，根据返回值的推导规则自动推导。
• body：指定Lambda表达式的函数体。

下面是一个示例代码，展示如何使用Lambda表达式：

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

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

    // 使用Lambda表达式打印每个数字
    std::for_each(numbers.begin(), numbers.end(), [](int num) {
        std::cout << num << " ";
    });
    std::cout << std::endl;

    // 使用Lambda表达式计算所有数字的和
    int sum = 0;
    std::for_each(numbers.begin(), numbers.end(), [&sum](int num) {
        sum += num;
    });
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

在上面的例子中，我们使用Lambda表达式作为std::for_each算法的参数，对每个数字进行打印和求和操作。Lambda表达式中捕获了外部变量sum，并将每个数字加到sum中。

C++标准库中的Lambda和Binder是两种不同的概念和用法。

1. Lambda表达式：Lambda表达式是一种方便的方式，用于在需要函数对象的地方提供一个匿名的、内联的函数定义。它可以捕获外部变量，并且可以具有参数列表和返回类型。

Lambda表达式的语法如下：

[capture list](parameters) -> return type {
    // 函数体
}

例如，下面的代码展示了一个Lambda表达式的示例，它将两个整数相加并返回结果：

#include <iostream>

int main() {
    int a = 5;
    int b = 10;

    auto add = [](int x, int y) -> int {
        return x + y;
    };

    std::cout << add(a, b) << std::endl;

    return 0;
}

2. Binder（绑定器）：Binder是一种函数适配器，用于将一个多参数的函数对象转换为一个只有部分参数的函数对象。它可以用于将某个参数绑定为固定的值，从而生成一个新的函数对象。

C++标准库中的std::bind函数可以用于创建Binder对象。std::bind接受一个可调用对象（函数指针、函数对象、成员函数指针等）以及需要绑定的参数，并返回一个新的函数对象。

例如，下面的代码展示了std::bind的使用示例，将一个二元函数对象std::plus的第一个参数绑定为5，并生成一个新的函数对象add5：

#include <functional>
#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add5 = std::bind(std::plus<int>(), 5, std::placeholders::_1);
    std::cout << add5(10) << std::endl;

    return 0;
}

在这个例子中，bind函数将std::plus函数对象的第一个参数绑定为5，生成一个新的函数对象add5。当调用add5(10)时，实际上是调用了std::plus的operator()(5, 10)，返回15。

C++标准库中的Lambda和带有状态的Function Object都是用于实现函数对象的方式，但它们有一些不同之处。

1. Lambda表达式：Lambda表达式是一种方便的方式，用于在需要函数对象的地方提供一个匿名的、内联的函数定义。Lambda表达式可以捕获外部变量，并且可以在函数体内部使用这些变量。Lambda表达式可以是无状态的，也可以是有状态的。

以下是一个使用Lambda表达式的例子：

#include <iostream>

int main() {
    int x = 5;
    auto lambda = [x](int y) { return x + y; };
    std::cout << lambda(3) << std::endl; // 输出8
    return 0;
}

在上面的例子中，Lambda表达式捕获了外部变量x，并且在函数体内部使用了这个变量。

2. 带有状态的Function Object：带有状态的Function Object是一种自定义的函数对象，它可以保存状态，并且可以在多次调用中保持这个状态。通常情况下，带有状态的Function Object是通过定义一个类来实现的，这个类重载了函数调用运算符operator()。

以下是一个使用带有状态的Function Object的例子：

#include <iostream>

class StatefulFunctionObject {
public:
    StatefulFunctionObject(int initialValue) : value(initialValue) {}
    
    int operator()(int x) {
        value += x;
        return value;
    }
    
private:
    int value;
};

int main() {
    StatefulFunctionObject obj(5);
    std::cout << obj(3) << std::endl; // 输出8
    std::cout << obj(2) << std::endl; // 输出10
    return 0;
}

在上面的例子中，我们定义了一个带有状态的Function Object类StatefulFunctionObject，它保存了一个状态变量value。每次调用这个对象时，它会将传入的参数与状态变量相加，并返回结果。在多次调用中，状态变量会保持更新。

在C++标准库中，Lambda表达式可以用于调用全局函数和成员函数。

1. 调用全局函数：Lambda表达式可以直接调用全局函数，无需通过函数指针或函数对象来间接调用。

例如，下面的代码展示了一个Lambda表达式调用全局函数的示例：

#include <iostream>

void globalFunction(int x) {
    std::cout << "Global function called with " << x << std::endl;
}

int main() {
    int x = 5;

    // 调用全局函数
    auto lambda = [](int x) {
        globalFunction(x);
    };

    lambda(x);

    return 0;
}

2. 调用成员函数：Lambda表达式也可以用于调用成员函数，需要使用成员函数指针或成员函数对象来调用。

例如，下面的代码展示了一个Lambda表达式调用成员函数的示例：

#include <iostream>

class MyClass {
public:
    void memberFunction(int x) {
        std::cout << "Member function called with " << x << std::endl;
    }
};

int main() {
    MyClass obj;
    int x = 5;

    // 调用成员函数
    auto lambda = [&obj](int x) {
        obj.memberFunction(x);
    };

    lambda(x);

    return 0;
}

在上面的示例中，Lambda表达式通过捕获obj对象来调用MyClass类的成员函数memberFunction

C++标准库中的Lambda表达式可以用作Hash函数、排序准则或相等准则的定义。Lambda表达式可以在需要函数对象的地方使用，通过Lambda表达式可以方便地定义匿名函数对象。

作为Hash函数：在C++标准库中，例如unordered_map和unordered_set等容器需要一个Hash函数来确定元素的存储位置。Lambda表达式可以用来定义Hash函数，根据元素的特定属性计算出一个哈希值。

举例：

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<std::string, int, decltype([](const std::string& str) {
        std::hash<std::string> hasher;
        return hasher(str);
    })> myMap;

    myMap["apple"] = 5;
    myMap["banana"] = 3;
    myMap["orange"] = 2;

    std::cout << "Number of apples: " << myMap["apple"] << std::endl;

    return 0;
}

在上面的例子中，我们使用了unordered_map容器，并通过Lambda表达式定义了一个Hash函数。这个Hash函数使用std::hashstd::string来计算字符串的哈希值，然后返回哈希值作为元素的存储位置。

作为排序准则或相等准则：在C++标准库中，例如sort和binary_search等算法需要一个排序准则或相等准则来确定元素的顺序或比较元素是否相等。Lambda表达式可以用来定义这样的准则。

举例：

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

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

    // 使用Lambda表达式作为排序准则
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a < b;
    });

    // 使用Lambda表达式作为相等准则
    bool found = std::binary_search(numbers.begin(), numbers.end(), 8, [](int a, int b) {
        return a == b;
    });

    if (found) {
        std::cout << "Number 8 found in the vector." << std::endl;
    } else {
        std::cout << "Number 8 not found in the vector." << std::endl;
    }

    return 0;
}

在上面的例子中，我们使用了sort算法来对一个vector进行排序，通过Lambda表达式定义了一个排序准则，使得元素按照从小到大的顺序排序。同时，我们使用了binary_search算法来查找vector中是否存在某个元素，通过Lambda表达式定义了一个相等准则，使得元素的比较结果为相等。