作为参数传递的std :: string的生命周期

Question

I want to be sure I understand correctly. In the c++ functions below three instances of std::string will be created:

• one for s1 in caller() via what I believe is called the assignment constructor
• one for the s2 parameter of the callee() function via it's copy constructor
• one for s3 via its copy constructor

Am I correct? And if so will all three instances be cleaned up as they go out of scope? I'm not really asking if this is good code or not, just if my understanding is correct.

void caller(void) {
    std::string s1 = "hi";
    callee(s1);
}

void callee(std::string s2) {
    std::string s3 = s2;
}

Answer 1

Don't assume copies are made everywhere they seem to be made. In practice, copy-elision occurs more often than you'd think. Compilers are free to optimize away extra copies, even if the copy has a side-effect:

void caller(void) {
    std::string s1 = "hi";
    //theoretically, s1 is copied here
    //in practice, the compiler will optimize the call away
    functionCallee(s1);
}

void callee(std::string s2) {
    //although s2 is passed by value, it's probably no copy was created
    //most likely, it's exactly the same as s1 from the calling context
    std::string s3 = s2;
}

Moreover, if the methods are inline and the compiler detects no side-effects occur, the strings might not even be created.

Answer 2

You are almost correct.

Either three or four strings may be created (depending on whether the construction of s1 is elided), and in each case a constructor is called to construct them. Despite appearances, there are no calls to any assignment operators.

void caller(void) {
    //A temporary std::string is constructed with the
    //basic_string(const CharT* s, const Allocator& alloc = Allocator())
    //constructor.
    //(In the call, `s` is initialized to point to the first element of "hi".)
    //This temporary is then move constructed in to s1.
    //The move constructor is
    //basic_string(basic_string&& other)
    //This move construction may be elided.
    std::string s1 = "hi"; //At the end of the full expression (ie, at the semicolon)
                           //the lifetime of the temporary string ends (unless
                           //the construction of s1 is elided, in which
                           //case the temporary becomes s1, and its lifetime ends
                           //with s1).
    //s2 is copy constructed from s1
    //The copy constructor is
    //basic_string(const basic_string& other)
    callee(s1);
    //the lifetime of s1 ends
}

void callee(std::string s2) {
    //s3 is copy constructed from s2
    std::string s3 = s2;
    //the lifetime of s3 ends
    //the lifetime of s2 ends
}