Is it safe to capture a member reference if the class storing the original reference goes out of scope?

Question

Consider this:

#include <iostream>
#include <functional>

std::function<void()> task;
int x = 42;

struct Foo
{
   int& x;

   void bar()
   {
      task = [=]() { std::cout << x << '\n'; };
   }
};

int main()
{
   {
      Foo f{x};
      f.bar();
   }

   task();
}

My instinct was that, as the actual referent still exists when the task is executed, we get a newly-bound reference at the time the lambda is encountered and everything is fine.

However, on my GCC 4.8.5 (CentOS 7), I'm seeing some behaviour (in a more complex program) that suggests this is instead UB because f, and the reference f.x itself, have died. Is that right?

I'm not sure I understand. In task you bind to `int& x` which is no longer valid when `Foo` is destroyed. — freakish, Dec 01 '17 at 11:36
I suppose a "literal" reading of the program says I'm capturing a `this` that'll go out of scope and that `x` inside the task is just short for a now-invalid `this->x`. — Lightness Races in Orbit, Dec 01 '17 at 11:36
@freakish: But do I? Am I not binding a new variable to `::x`? What is `r2` bound to in `int x = 42; int& r1 = x; int& r2 = r1;`? — Lightness Races in Orbit, Dec 01 '17 at 11:37
That nasty implicit capture of `x` in the fact of the explicit `=` is a real PITA. — StoryTeller - Unslander Monica, Dec 01 '17 at 11:38
@LightnessRacesinOrbit I'm not really sure how it works formally and how to deduce this from the standard. I guess it was my intuitive observation. :) — freakish, Dec 01 '17 at 11:41
Actually, this could be a dupe of https://stackoverflow.com/q/21443023/560648. — Lightness Races in Orbit, Dec 01 '17 at 11:48
@LightnessRacesinOrbit: Not sure I like that duplicate. In your case `::x` is valid for the lifetime of the program. Being able to answer, unfortunately, is above my pay grade. — Bathsheba, Dec 01 '17 at 11:49
@Bathsheba: I believe that my `::x` is equivalent to Magnus's `main()::i`, which also seemingly lives as long as it is needed. The examples do differ, however, in that I'm capturing `this` instead. — Lightness Races in Orbit, Dec 01 '17 at 11:51

score 11 · Accepted Answer · edited Dec 03 '17 at 12:44

11

To capture a member reference you need to utilize the following syntax (introduced in C++14):

struct Foo
{
   int & m_x;

   void bar()
   {
      task = [&l_x = this->m_x]() { std::cout << l_x << '\n'; };
   }
};

this way l_x is an int & stored in closure and referring to the same int value m_x was referring and is not affected by the Foo going out of scope.

In C++11 we can workaround this feature being missing by value-capturing a pointer instead:

struct Foo
{
   int & m_x;

   void bar()
   {
      int * p_x = &m_x;
      task = [=]() { std::cout << *p_x << '\n'; };
   }
};

edited Dec 03 '17 at 12:44

underscore_d

6,309
3
38
64

answered Dec 01 '17 at 11:53

user7860670

35,849
4
58
84

2

Agreed. Only available since C++14 though right? Think I'm going to have to declare a pointer somewhere and take that by value. – Lightness Races in Orbit Dec 01 '17 at 11:54
Though my question is about C++11, this is close enough as it confirms the problem and suggests a solution I'd like to use in the future - and converting to a C++11 solution is now trivial (and works, btw). – Lightness Races in Orbit Dec 01 '17 at 12:18

Maxim Egorushkin · Answer 2 · 2017-12-01T12:57:20.290

3

You can capture a reference member in C++11 by creating a local copy of the reference and explicit capture to avoid capturing this:

void bar()
{
    decltype(x) rx = x; // Preserve reference-ness of x.
    static_assert(std::is_reference<decltype(rx)>::value, "rx must be a reference.");
    task = [&rx]() { std::cout << rx << ' ' << &rx << '\n'; }; // Only capture rx by reference.
}

edited Dec 01 '17 at 12:57

answered Dec 01 '17 at 12:30

Maxim Egorushkin

131,725
17
180
271

And this doesn't suffer from the same problem purely because we've eliminated the `this` intermediary? – Lightness Races in Orbit Dec 01 '17 at 12:39
@LightnessRacesinOrbit Yes, because it uses explicit capture `this` is not captured. And if the member is not a reference it breaks at compile time. – Maxim Egorushkin Dec 01 '17 at 12:42
I get that `this` doesn't come into your example - I'm trying to arrive at unquestionable proof that this one change results in a wholly valid program – Lightness Races in Orbit Dec 01 '17 at 12:47
1

@LightnessRacesinOrbit All these references end up referring the global `x`, since initializing a reference with a reference does not make a reference to a reference, if I understand you correctly. – Maxim Egorushkin Dec 01 '17 at 12:52
Right, which is what I thought my original solution would do, but it didn't, hence my caution - I guess I was hoping you'd flesh it out a bit with a proof to that end – Lightness Races in Orbit Dec 08 '17 at 17:42

Is it safe to capture a member reference if the class storing the original reference goes out of scope?

2 Answers2

Linked