Closures in C++

C++ supports anonymous functions, which can form closures. Anonymous functions are useful when you want to define a function inline without having to name it.

#include <iostream>
#include <functional>

// This function intSeq returns another function, which
// we define anonymously in the body of intSeq. The
// returned function closes over the variable i to
// form a closure.
std::function<int()> intSeq() {
    int i = 0;
    return [i]() mutable -> int {
        return ++i;
    };
}

int main() {
    // We call intSeq, assigning the result (a function)
    // to nextInt. This function value captures its
    // own i value, which will be updated each time
    // we call nextInt.
    auto nextInt = intSeq();

    // See the effect of the closure by calling nextInt
    // a few times.
    std::cout << nextInt() << std::endl;
    std::cout << nextInt() << std::endl;
    std::cout << nextInt() << std::endl;

    // To confirm that the state is unique to that
    // particular function, create and test a new one.
    auto newInts = intSeq();
    std::cout << newInts() << std::endl;

    return 0;
}

To compile and run this program:

$ g++ -std=c++11 closures.cpp -o closures
$ ./closures
1
2
3
1

In C++, we use lambda functions to create closures. The mutable keyword allows the lambda to modify its captured variables. The std::function type is used to store and pass around these closures.

The last feature of functions we’ll look at for now is recursion.

Variadic Functions in C++

Recursion in C++

Learn X By Example

Title here

Closures in C++