fold expression

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

C++ language

 

Templates

parameters and arguments

class templates

function templates

class member templates

variable templates(C++14)

template argument deduction

explicit (full) specialization

partial specialization

dependent names

parameter packs(C++11)

sizeof... (C++11)

fold-expressions(C++17)

SFINAE

Constraints and concepts(concepts TS)

 

Reduces (folds) a parameter pack over a binary operator.

Syntax

( pack op ... )	(1)	(since C++17)
( ... op pack )	(2)	(since C++17)
( pack op ... op init )	(3)	(since C++17)
( init op ... op pack )	(4)	(since C++17)

1) unary right fold

2) unary left fold

3) binary right fold

4) binary left fold

op	-	any of the following 32 binary operators: + - * / % ^ & | = < > << >> += -= *= /= %= ^= &= |= <<= >>= == != <= >= && || , .* ->*. In a binary fold, both ops must be the same. Precedence of this operator relative to either pack or init expressions is the highest (equivalent to unary operators)
pack	-	any expression that contains an unexpanded parameter pack
init	-	any expression that does not contain an unexpanded parameter pack

Explanation

The instantiation of a fold expression expands the expression e as follows:

1) Unary right fold (E op ...) becomes E
1 op (... op (E
op E
N))

2) Unary left fold (... op E) becomes ((E
1 op E
2) op ...) op E
N

3) Binary right fold (E op ... op I) becomes E
1 op (... op (E
N−1 op (E
N op I)))

4) Binary left fold (I op ... op E) becomes (((I op E
1) op E
2) op ...) op E
N

(where N is the number of elements in the pack expansion)

For example,

template<typename... Args>
bool all(Args... args) { return (... && args); }
 
bool b = all(true, true, true, false);
 // within all(), the unary left fold expands as
 //  return ((true && true) && true) && false;
 // b is false

When a unary fold is used with a pack expansion of length zero, only the following operators are allowed:

1) Multiplication (*). The value for the empty pack is 1

2) Addition (+). The value for the empty pack is int() (zero)

3) Bitwise AND (&). The value for the empty pack is -1 (bitwise all ones)

4) Bitwise OR (|). The value for the empty pack is int() (zero)

5) Logical AND (&&). The value for the empty pack is true

6) Logical OR (||). The value for the empty pack is false

7) The comma operator (,). The value for the empty pack is void()

Example

Run this code

#include <iostream>
template<typename ...Args>
void printer(Args&&... args) {
    (std::cout << ... << args) << '\n';
}
int main()
{
    printer(1, 2, 3, "abc");
}

Output:

123abc