Using Fold Expressions in C

The collapsed expression in C 17 simplifies the processing of variadic parameter templates by applying binary operators. It supports single and binary folding forms, such as (args ...) and (args ... init), which can intuitively implement operations such as accumulation, splicing, etc.; 1. It can be used to accumulate numerical values or splicing strings, such as sum(1, 2, 3) returns 6, join function splicing parameters; 2. Check multiple conditions, such as all_true to determine whether it is true; 3. Print multiple parameters and use comma operators to output in sequence; when using it, pay attention to type consistency, empty parameter package processing and operator priority issues, such as using initial values to avoid compilation errors, and brackets ensure correct parsing.

C 17 introduces Fold Expressions, which provides a concise and powerful way to deal with variadic templates. If you have used std::make_tuple or written code for parameter package expansion, you will find that folding expressions can make these operations clearer and more intuitive.

What is a fold expression?

Collapse expressions allow you to apply a binary operator to all elements in a parameter package, thus avoiding manually expanding the parameter package. It is suitable for unary operations (such as printing all parameters) and binary operations (such as summing, splicing strings, etc.).

Syntax, fold expressions are divided into two forms:

• One dollar fold : for example (args ...)
• Binary folding : for example (args ... init)

Here ... is the collapse operator, which tells the compiler that this is a collapse operation of a parameter package.

To give a simple example:

 template<typename... Args>
auto sum(Args... args) {
    return (args ...);
}

Calling sum(1, 2, 3) will return 6 . Does it look cleaner than before?

Common usage scenarios for folding expressions

1. Accumulate or combine multiple values

This is the most intuitive application scenario. For example, you want to add multiple numbers or splice multiple strings:

 template<typename... Args>
std::string join(Args... args) {
    return (... args); // Pay attention to the order, combine from left to right}

Note that above is (... args) , that is, left folding. If you write (args ...) , that's OK, but by default it's right-folding, which can cause type mismatch issues, especially when different types are mixed.

2. Check whether multiple conditions are met

You can use a collapse expression to determine whether a set of values meets a certain condition. For example:

 template<typename... Args>
bool all_true(Args... args) {
    return (args && ...);
}

Calling all_true(true, false, true) in this way will return false .

If you want to check if at least one is true? Then change it to || :

 return (args || ...);

This writing method is very practical in scenarios such as writing policy mode, permission checking, and configuration verification.

3. Print multiple parameters

Sometimes you need to output multiple parameters to the console or log in sequence:

 template<typename... Args>
void print_all(Args... args) {
    ((std::cout << args << " "), ...);
}

Here, the comma operator is used, first execute the output on the left, and then continue to collapse the parameters on the right. This way, all parameters can be output in turn.

Things to note when using fold expressions

• Type consistency is important : a folding expression requires that the parameter types be unified during operation. For example, you cannot add int and std::string directly.

• Empty parameter package problem : If you pass in an empty parameter package, expressions like (args ...) will cause compilation errors. The solution is to use binary collapse and specify the initial value:

   return (args ... 0); // Safe version, return 0 even if there are no parameters

• Priority and brackets : The operator priority involved in a collapse expression is error-prone. To be on the safe side, it is best to add brackets:

   (args * ...) // Correct args * ... // Error! Need brackets

  Basically that's it. Folding expressions are not a must-have, but they do simplify many common tasks in template programming, and the code written is clearer and easier to understand. If you often write template code, especially when dealing with parameter packages, you might as well give it a try.

  The above is the detailed content of Using Fold Expressions in C. For more information, please follow other related articles on the PHP Chinese website!