Do objects captured by a lambda exist for as long as the lambda?

Question

I have always assumed lambda were just function pointers, but I've never thought to use capture statements seriously...

If I create a lambda that captures by copy, and then move that lambda to a completely different thread and make no attempt to save the original objects used in the lambda, will it retain those copies for me?

std::thread createThread() {
    std::string str("Success");
    auto func = [=](){ 
        printf("%s", str.c_str());
    };
    str = "Failure";
    return std::thread(func);
}

int main() {
    std::thread thread = createThread();
    thread.join();  
    // assuming the thread doesn't execute anything until here...
    // would it print "Success", "Failure", or deference a dangling pointer?
    return 0;
}

Answer 1

It is guaranteed to print Success. Capture-by-copy does exactly what it says. It make a copy of the object right there and stores this copy as part of the closure object. The member of the closure object created from the capture lives as long as the closure object itself.

A lambda is not a function pointer. Lambdas are general function objects that can have internal state, which a function pointer can't have. In fact, only capture-less lambdas can be converted to function pointers and so may behave like one sometimes.

The lambda expression produces a closure type that basically looks something like this:

struct /*unnamed1*/ {
    /*unnamed1*/(const /*unnamed1*/&) = default;  
    /*unnamed1*/(/*unnamed1*/&&) = default;           

    /*unnamed1*/& operator=(const /*unnamed1*/&) = delete;       

    void operator()() const {
        printf("%s", /*unnamed2*/.c_str());
    };

    std::string /*unnamed2*/;  
};

and the lambda expression produces an object of this type, with /*unnamed2*/ direct-initialized to the current value of str. (Direct-initialized meaning as if by std::string /*unnamed2*/(str);)