How do I return an immutable parameter from a method, unchanged, and without a copy in c++?

Question

How do I return a parameter from a method, unchanged, and without a copy in c++?

// This is more or less the desired signature from the caller's point of view
SomeImmutableObject ManipulateIfNecessary(SomeImmutableObject const& existingObject)
{
    // Do some work…
    // ...

    if (manipulationIsNeccessary)
    {
        // Return a new object with new data etc (preferably without another copy)...
        return SomeImmutableObject(...);
    }
    else
    {
        // Return the original object intact (but with no further copies!)...
        return existingObject;
    }
}

An example is C#'s String.Trim method. C# strings are immutable and if Trim doesn't have to do any work, a reference to the existing string is returned, otherwise a new string object with the trimmed content is returned.

How would I mimic this semantic in C++ given something close to the above method signature?

Answer 1

Your object must be a reference type for this to work. Let's give a toy example for strings:

class RefString {
public:
    RefString() : ref(new std::string()) { }
    RefString(const std::string& str) : ref(new std::string(str)) { }

    RefString trim_trailing_newline() {
        if (ref->back() == '\n') {
            return RefString(ref->substr(0, ref->size()-1));
        }

        return *this;
    }

    size_t size() { return ref->size(); }

private:
    std::shared_ptr<std::string> ref;
};

int main(int argc, char** argv) {
    RefString s("test\n");
    std::cout << s.size() << "\n";
    std::cout << s.trim_trailing_newline().size() << "\n";
    return 0;
}