Is this reference to ostream a local variable

Question

in c++primer 5th edition p393 it is written :

The variables captured by a lambda are local variables

The book then shows an ostream as a referenced parameter, captured by reference by the lambda. This is similar :

#include <iostream>
using namespace std;
void foo(ostream &os) {
    auto f = [&os]() { os << "Hellow World !" << endl; //return os;
    };
    f();
}
void main() {
    foo(cout);
    system("pause");
}

What i struggle with is that here os is not a local variable to foo, it exists outside of foo's scope, yet it can be captured by a lambda while "The variables captured by a lambda are local variables". What am i missing here? Also, why can the lambda not return os; ? After all, isn't os an object which exists outside of the lambda and foo's scope ?

Konrad Rudolph · Accepted Answer · 2020-05-01T09:20:30.273

3

What i struggle with is that here os is not a local variable to foo, it exists outside of foo's scope,

No, it’s local, it does not exist outside of foo.

The object that’s referenced by os exists outside of foo, because os is a reference. But that’s irrelevant here, since we’re talking about variables, not objects.

Also, why can the lambda not return os;?

It can, you just need to specify an explicit return type, otherwise the return type is inferred as std::ostream, i.e. the code will attempt to copy the stream, and it’s non-copyable.

But the following works:

auto f = [&os]() -> std::ostream& { return os << "Hellow World !" << endl; };

edited May 01 '20 at 09:20

answered May 01 '20 at 09:14

Konrad Rudolph

530,221
131
937
1,214

Thanks, that helps a lot, so `os` is a local variable reference to an `ostream` which exists outside of `foo` ? – user May 01 '20 at 09:24
@user Precisely. – Konrad Rudolph May 01 '20 at 10:02

StPiere · Answer 2 · 2020-05-02T16:11:41.617

The lambda from above is compiled by the compiler to something similar to f2 in foo2(). So lambda instance is local within foo2 and the ostream reference (pointer) is a member varible within the local lambda instance.

So you have to make sure, that the lambda with wrapped reference to ostream not outlives the ostream (os) itself, which doesn't happen in this case, because the lambda instance lives only within function scope -> smaller as the scope of passed ostream reference os argument.

#include <iostream>
using namespace std;
void foo(ostream &os) {
    auto f = [&os]() { os << "Hellow World !" << endl; //return os;
    };
    f();
}

void foo2(ostream& os) {
    // The lambda f from foo is compiled to something similar to f2.
    struct f2 {
        f2(ostream& oss)
        : os_(oss) {}

        void operator()() const
        {
            os_ << "Hellow World !" << endl; 
        }

        private:
        ostream& os_; // Note: this is reference, but local to f2 ( == "lambda")
    };

    f2 t(os);
    t(); // call "lambda"
}

int main() {
    foo(cout);
    foo2(cout);
    return 0;
}

Is this reference to ostream a local variable

2 Answers2