c++ - When exactly does the destruction of a temporary object happen in a function call?

Question

This code compiles and executes. I know that we have undefined behaviour in the first case. But what happens exactly in the second case?

#include <string>
#include <iostream>
#include <cstdio>

std::string foo() {
    return "HELLO";
}

void bar(const char *p) {
    std::printf("%s
", p);
}


int main() {

    // FIRST CASE:
    // I know this is bad, because after the assignment
    // the variable returned by foo() is destroyed and we
    // have a bad reference.
    const std::string &s = foo(); 
    bar(s.c_str());


    // SECOND CASE:
    // But what about that ? I don't know exactly if the 
    // object is alive after the call to c_str() 
    bar(foo().c_str());

    return 0;
}

GCC output is in both cases "HELLO" but I think that's because it's not cleaning the raw memory.

In the second case when exactly is the temporary object destroyed?

Answer 1

Actually, both of these cases are okay.

In the first case, binding the temporary to a const reference extends its lifetime to that of s. So it won't be destroyed until main exits.

In the second case, the temporary is destroyed after the end of the full-expression containing it. In this case, it is the function call. If you stored that C string anywhere which outlived bar and then tried to access it, then you're due a date with undefined behaviour.