Retaining a pointer by extending the life of capture

Question

Is it possible to extend the life of a unique_ptr by capturing it in a lambda and extending the life of the lambda?

I tried out but getting syntax errors with the a=move(a) expression.

#include <cstdio>
#include <functional>
#include <memory>
#include <iostream>

using namespace std;

struct A {
  A() { cout << "A()" << endl; }
 ~A() { cout << "~A()" << endl; }
};

int main() {
  std::function<void ()> f;
  {
    std::unique_ptr<A> a(new A());
    f = [a=move(a)] () mutable { return; };
  }
  return 0;
}

Answer 1

Well the problem with your code is std::function. It is not very move friendly as it needs its callable to be copy constructible/assignable which your lambda is not because of the use of a move only type, unique_ptr in your example.

There are many examples out there which can provide you with a move friendly version of std::function.

I have come here with a quick, hacky, and probably error prone but "working on my machine" version of the same:

#include <memory>
#include <iostream>
#include <type_traits>


struct A {
  A() { std::cout << "A()" << std::endl; }
 ~A() { std::cout << "~A()" << std::endl; }
};

template <typename Functor>
struct Holder
{
    static void call(char* sbo) {
        Functor* cb = reinterpret_cast<Functor*>(sbo);
        cb->operator()();
    }

    static void deleter(char* sbo) {
        auto impl = reinterpret_cast<Functor*>(sbo);
        impl->~Functor();
    }

};

template <typename Sign> struct Function;

template <>
struct Function<void()>
{
    Function() = default;
    ~Function() {
        deleter_(sbo_);
    }

    template <typename F>
    void operator=(F&& f)
    {
        using c = typename std::decay<F>::type;
        new (sbo_) c(std::forward<F>(f));
        call_fn_ = Holder<c>::call;
        deleter_ = Holder<c>::deleter;
    }

    void operator()() {
        call_fn_(sbo_);
    }

    typedef void(*call_ptr_fn)(char*);
    call_ptr_fn call_fn_;
    call_ptr_fn deleter_;
    char sbo_[256] = {0,};
};

int main() {
  Function<void()> f;
  {
      std::unique_ptr<A> a(new A());
      f = [a=move(a)] () mutable { return; };
  }
  std::cout << "Destructor should not be called before this" << std::endl;
  return 0;
}

To try it out yourself: http://coliru.stacked-crooked.com/a/60e1be83753c0f3f