Re: How to pass STL containers (say a vector) ?

From:

"peter koch" <peter.koch.larsen@gmail.com>

Newsgroups:

comp.lang.c++

Date:

20 May 2006 13:15:08 -0700

Message-ID:

<1148156108.536441.265040@j55g2000cwa.googlegroups.com>

Markus Schoder skrev:

peter koch wrote:

Sanjay Kumar wrote:

Folks,

I am getting back into C++ after a long time and I have
this simple question: How do pyou ass a STL container
like say a vector or a map (to and from a function) ?

Prefer to return by value and pass by const reference.

function:

vector<string> tokenize(string s){

vector<string> tokenize(string const& s){

     vector<string> myvector;
    //split s and push_back into myvector;

    //is this ok ? vector destroyed on exit from funcion ?
    return myvector;
}

main:
vector<string> result = tokenize(s);

For it to work, there has to be deep copy of the result of vector inside
function (myvector) into the "result" vector before myvector is destroyed.
Is that how it works?

Most likely not (at least in a non-debug build). RVO (google for that
one) will kick in and remove the redundant copy. This is the case for
all modern (2000 or later) compilers I know.

Unfortunately this does not work for assigning to an already existing
vector.
You can still benefit from RVO by first creating a new vector
and then swapping it into the existing one but that is all but
intuitive and only works for fast swappable objects.

I agree that assigning to already constructed objects is non-optimal
and that you have to use somewhat unintuitive code for optimal
performance in that case. But my guess is that this situation occurs
rarely. And the other solution is counterintuitive in all cases.

Could this be inefficient if there is large amount
of data to be copied from the container ?

It could if your compiler cant optimise (which I doubt). If it can't
and you spend to much time returning your container, pass the
returnvalue by reference and finish with a swap instead of the return:

void tokenize(string const& s,vector<string>& result){

    vector<string> myvector;
    //split s and push_back into myvector;

    //is this ok ? vector destroyed on exit from funcion ?
                std::swap(result,myvector);
    return;
}

Notice that the function now is not so easy to use. Also, it will most
likely be slightly slower than the original function.

You can also just do result.clear() and use it directly.

In the example above you most likely could. But in the general case you
would reduce the exception-guarantee for no benefit at all.

Because of what I said above I still think this approach has some value
even though it is more clumsy to use.

My opinion is that readability should be the number one priority in the
general case. So I'd just have to differ.

/Peter