如何为C++的copy_if等函数定义一元谓词？

Let's break down your questions one by one—this is such a common (and important) point of confusion when getting comfortable with C++ standard algorithms!

1. What's the purpose of the square brackets [] in the lambda? #

Those brackets are the capture list of a lambda expression. They control how the lambda can access variables from the surrounding code scope:

• []: Empty capture list — the lambda can't use any external variables (like your example, where it only needs the input int i).
• [x]: Capture variable x by value (the lambda gets a copy).
• [&x]: Capture variable x by reference (the lambda uses the original variable).
• [=]: Capture all used external variables by value.
• [&]: Capture all used external variables by reference.

2. Can I use a custom function instead of a lambda? #

Absolutely! You have a few flexible options:

Option 1: A standalone named function #

If your predicate logic is reusable, define a simple function that takes one argument (since std::copy_if expects a unary predicate—something that takes one parameter and returns a bool):

bool isNonNegative(int i) {
    return !(i < 0);
}

// Use it with std::copy_if:
auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), isNonNegative);

Option 2: A functor (function object) #

If you need your predicate to hold persistent state (like extra values you want to reuse), create a class with an overloaded operator():

class IsGreaterThan {
private:
    int threshold;
public:
    IsGreaterThan(int val) : threshold(val) {}

    bool operator()(int i) const {
        return i > threshold;
    }
};

// Usage: Filter values greater than 5
auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), IsGreaterThan(5));

3. How to pass extra parameters to the predicate? #

There are three straightforward ways to do this:

Method 1: Capture variables via the lambda's capture list #

If you have an extra value in your current scope, capture it directly in the lambda:

int minAllowed = 3;
auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), [minAllowed](int i) {
    return i >= minAllowed;
});

Method 2: Use std::bind #

Bind extra arguments to a multi-parameter function, leaving the first parameter to be filled by std::copy_if:

bool isGreaterThan(int i, int threshold) {
    return i > threshold;
}

// Bind the threshold to 5; std::placeholders::_1 marks where the element will go
auto it = std::copy_if(foo.begin(), foo.end(), bar.begin(), 
                       std::bind(isGreaterThan, std::placeholders::_1, 5));

Method 3: Use a stateful functor #

As shown earlier, a functor can store extra parameters as member variables, which you set when constructing the functor instance.

4. How to declare unary predicates properly? #

A unary predicate for algorithms like std::copy_if just needs to follow these rules:

• It takes exactly one argument (matching the type of elements in your range).
• It returns a bool (or a type that can be implicitly converted to bool).
• It doesn't modify the input argument (unless you're using algorithms explicitly designed for mutable predicates—std::copy_if expects a non-modifying one).

You can implement it as:

• A lambda (perfect for one-off, short logic).
• A standalone function (great for reusable, stateless logic).
• A functor (ideal for stateful, reusable logic).

5. Where to learn more about this syntax? #

Here are some reliable, accessible resources:

• cppreference: The go-to reference for C++ standard library features. Look up the algorithm you're using (like std::copy_if) and check the "Parameters" section for predicate details. It also has deep dives on lambdas, functors, and std::bind.
• C++ Primer / Effective C++: These books have clear, practical explanations of standard algorithms and predicate usage, with real-world examples.
• Compiler Documentation: Resources from GCC, Clang, or MSVC often include tutorials and examples for C++ features like lambdas and predicates.

内容的提问来源于stack exchange，提问作者Klaus Haukenstein