CODEWITHSUNDEEP
c++lambda
bradgonesurfing
bradgonesurfing

Reputation: 32202

My lambda does not correctly convert the captured 'this' during copy construction

I've narrowed down my problem to exactly this

#include <iostream>
#include <functional>

struct Foo {
    std::function<Foo*()> lambda;
    Foo()
        :lambda([this](){return this;})
    {}

};

int main(){

    Foo a;
    Foo b = a; 
    std::cout << &a << " " << a.lambda() << std::endl;
    std::cout << &b << " " << b.lambda() << std::endl;
}

where the output is

0x7ffd9128b8a0 0x7ffd9128b8a0
0x7ffd9128b880 0x7ffd9128b8a0

I originally expected that this would always point to the instance that owned the lambda. However I forgot about copy construction. In this case the lambda captures this and then it is fixed and no matter how many times the lambda is copied it points to the original value of this.

Is there a way fix this so that lambda always has a reference to it's owning object this even under copy construction of the owning object.

Upvotes: 4

Views: 65

Answers (2)

bradgonesurfing
bradgonesurfing

Reputation: 32202

Whilst @lubgr answered the question for what I asked I think it is worth noting the other solution I have for my exact problem. The question stemmed from building a class to encapsulate lazy initialisation of members. My original attempt was

template <typename T>
class Lazy {
    mutable boost::once_flag _once;
    mutable boost::optional<T> _data;
    std::function<T()> _factory;
    void Init() const { boost::call_once([&] { _data = _factory(); }, _once); }
public:
    explicit Lazy(std::function<T()> factory):_once(BOOST_ONCE_INIT),_factory(factory){}

    T& Value() {
        Init();
        return *_data;
    }

};

which can be used like

class Foo { 
    int _a;
    Lazy<int> _val;
    Foo(a):_a(a):_val([this](){return this->_a+1;}){}
}

Foo f(10);
int val = f._val.Value();

but has the same problem that I asked in my question in that this is a circular reference that doesn't get preserved for copy construction. The solution is not to create a custom copy constructor and possibly move constructor but to fix the Lazy implementation class so that we can pass in an arg to the factory.

The new implementation of Lazy for members is

template <typename T, typename TThis>
class LazyMember {
    mutable boost::once_flag _once;
    mutable boost::optional<T> _data;
    typedef std::function<T(TThis const*)> FactoryFn;
    FactoryFn _factory;
    void Init(TThis const * arg0) const { boost::call_once([&] { _data = _factory(arg0); }, _once); }
public:
    explicit LazyMember(FactoryFn factory):_once(BOOST_ONCE_INIT),_factory(factory){}

    T& Value(TThis const * arg0) { Init(arg0); return *_data; }
    T const & Value(TThis const * arg0) const { Init(arg0); return *_data; }
};

which is used as

class Foo { 
    int _a;
    Lazy<int> _val;
    Foo(a):_a(a):_val([](Foo const * _this){return _this->_a+1;}){}
}

Foo f(10);
int val = f._val.Value(&f);

and this doesn't have the circular reference problems and thus doesn't require a custom copy/move constructor.

Upvotes: 1

lubgr
lubgr

Reputation: 38325

Sounds like you need to provide your own special member functions, no? E.g., for the copy constructor:

Foo(const Foo& other)
   :lambda([this](){return this;})
{}

Upvotes: 10

Related Questions