Re: Best practice for passing std::string to functions?

"Norbert Unterberg" <nunterberg@newsgroups.nospam> wrote in message
news:%234L1zqOrHHA.4108@TK2MSFTNGP06.phx.gbl


By const reference. Some experts (Herb Sutter, IIRC) would make an
exception for the following case:

// Taking a string and immediately making a copy
string f(const string& s) {
    string ret = s;
    // modify ret in some way
    return ret;
}

// Allegedly better:
string f(string s) {
    // modify s in some way
    return s;
}

The claim is that some compilers can perform a return value optimization
(RVO) on the second version but not the first. Personally, I don't like
the way an implementation detail leaks into interface in the second
case. The programmer using such function would have to stop and think
why it takes a string by value while everything else takes it by const
reference.


Some implementations of std::string use copy-on-write (COW), where two
strings that are copies of each other share the underlying data until
one of the strings is modified, at which time it gets its own copy.
However, such an implementation is next to impossible to make
thread-safe (and when you do make it thread-safe, you invoke
considerable overhead even for single-threaded programs). Most modern
STL implementations don't use COW. Thus it would be a bad idea to assume
COW is used.

Another popular technique is small string optimization (SSO), where
short enough strings are stored inside the string object itself,
avoiding heap allocations. With SSO, copying a short string (16
characters is a commonly used threshold) is cheap, but copying a longer
string is expensive as it involves a heap allocation.
--
With best wishes,
    Igor Tandetnik

With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925