最佳做法与参考

Question

Only for curiosity and educating and clarification reasons I would like to ask that the way I use references and values are good practices or not.

Theoretically:

class ComplexGraphicalShape {
...
public:
    void setRasterImageURL(const QString &rasterImageURL);
    const QString &rasterImageURL() const;
...
private:
    const QString *_rasterImageURL;
};

...

void ShadowGram::setRasterImageURL(const QString &rasterImageURL) {
    safeDelete(_rasterImageURL); // handle deletion
    _rasterImageURL = new QString(rasterImageURL);
}

const QString &ShadowGram::rasterImageURL() const{
    // Question 2: Why is it a problem if I return 
              // return "www.url.com/shape_url.jpg"
    return *_rasterImageURL; // that is the right way
}

...

complexGraphicalShape().setRasterImageURL(kURLImagesToShare + imageName);
complexGraphicalShape().setRasterImageURL("www.url.com/url.jpg"); // Question 1.

My first question is that how long can I use the temporary object reference which is created inside setRasterImageURL functioncall? Where exist that variable?(in the stack If I am not mistaken, but what if I call another function with that temporary reference.

My second question is that why I got a warning in Question 2 section if I would like to use this return "www.url.com/shape_url.jpg" ? That thing is kind of similar. How long can I use that temporary object?

Thanks for your time for the answer and explanations

Answer 1

Q1: The temporary string exists as long as the temporary reference that is "bound" to it. That is - as long as you are "inside" setRasterImageURL() function. This - of course - includes all functions called "within" this function. Note that storing another reference to this temporary string does NOT prolong the lifetime of the temporary object.

complexGraphicalShape().setRasterImageURL("www.url.com/url.jpg");
// the temporary object is "destroyed" when it goes out of scope, and it's scope is just the called function

Q2: The problem with returning is that you use "C string" (array of characters) to create a temporary QString object (on stack, still inside the function) and return reference to that temporary. As this temporary object is destroyed right after this function returns, your reference is never valid and refers to a dead object. On the other hand - returning a reference to a member variable works, because this object is not destroyed, so the reference is valid as long as your main object lives.

const QString &ShadowGram::rasterImageURL() const{
    return "www.url.com/shape_url.jpg"
    // the temporary object is destroyed here, before the function returns, reference is invalid
}

Answer 2

1. The temporary exists until setRasterImageURL returns, so you can safely pass a reference to it along, but you need to be careful not to save the reference for later. The temporary is stored wherever the compiler wants to. The reference is most likely passed either in a register or on the stack.

2. It is a problem because you're returning a reference to a temporary QString object, and that object is destroyed when the function returns. You're not allowed to use the reference at all.

Passing a reference "inwards" to a function is (usually) safe as long as you don't store it, while passing a reference "outwards" from a function requires you to make sure that the referenced object still exists when the function returns.

Answer 3

My first question is that how long can I use the temporary object reference which is created inside setRasterImageURL functioncall?

It's not created inside the function call, it's created on the caller's stack before the function is called, and is destroyed after the function returns.

Where exist that variable?(in the stack If I am not mistaken, but what if I call another function with that temporary reference.

Yes, on the stack. It is destroyed at the ; after the function call returns (at the end of the "full expression").

That thing is kind of similar. How long can I use that temporary object?

Until the end of the full expression that creates the temporary, which is the return statement, so it goes out of scope immediately before the function has even finished returning . That's why you get a warning - the returned reference is bound to an object which no longer exists, and is never safe to use.

Both these cases are covered by 12.2 [class.temporary] paragraph 5 in the standard:

— A temporary object bound to a reference parameter in a function call (5.2.2) persists until the completion of the full-expression containing the call.
— The lifetime of a temporary bound to the returned value in a function return statement (6.6.3) is not extended; the temporary is destroyed at the end of the full-expression in the return statement.