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

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
}