how to return std::vector from function?

[zl2k]

hi, c++ user

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is called.
I can do like this:

std::vector<int > fun(){
//build the vector v;
return v;
}

int main(){
std::vector<int > a = fun();
return 0;
}

It works fine. However, I believe there is a deep copy in fun(), so the
cost is big when the array is big. Now I tried to return a pointer without
deep copy.

std::vector<int >* fun(){
//build a pointer to vector;
return *v;
}

int main(){
std::vector<int >* a = fun();
return 0;
}

This got memory leak trouble in fun() since v will be deleted after return
thus the pointer returned will be invalid.

Is there anyway that I can get a correct pointer from fun()? I also
thought to use a smart pointer, such as boost::shared_p tr:

boost::shared_p tr< std::vector<int > > getV(){
boost::shared_p tr< std::vector<int > > v;
v->push_back(1) ;
v->push_back(2) ;
return v;
}

int main(){
boost::shared_p tr< std::vector<int > > v = getV();
std::cout << v->at(0);
return 0;
}

I got the following message when run the program:
/usr/include/boost/shared_ptr.hpp: 253: T* boost::shared_p tr<T>::operator->() const [with T = std::vector<int , std::allocator< int> >]: Assertion `px != 0' failed.
Aborted

How can I get it correct? Is there any deep copy when the getV() return
the shared_ptr?

Thanks a lot.

zl2k

[Rolf Magnus]

zl2k wrote:

hi, c++ user

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is called.
I can do like this:

std::vector<int > fun(){
//build the vector v;
return v;
}

int main(){
std::vector<int > a = fun();
return 0;
}

It works fine. However, I believe there is a deep copy in fun(),
Why?
so the cost is big when the array is big. Now I tried to return a pointer
without deep copy.

std::vector<int >* fun(){
//build a pointer to vector;
return *v;
}

int main(){
std::vector<int >* a = fun();
return 0;
}

This got memory leak trouble in fun() since v will be deleted after return
thus the pointer returned will be invalid.
Your description is correct, though that is not a memory leak.
Is there anyway that I can get a correct pointer from fun()? I also
thought to use a smart pointer, such as boost::shared_p tr:

boost::shared_p tr< std::vector<int > > getV(){
boost::shared_p tr< std::vector<int > > v;
v->push_back(1) ;
v->push_back(2) ;
return v;
}

int main(){
boost::shared_p tr< std::vector<int > > v = getV();
std::cout << v->at(0);
return 0;
}

I got the following message when run the program:
/usr/include/boost/shared_ptr.hpp: 253: T*
boost::shared_p tr<T>::operator->() const [with T = std::vector<int ,
std::allocator< int> >]: Assertion `px != 0' failed. Aborted

How can I get it correct? Is there any deep copy when the getV() return
the shared_ptr?

Instead of returning a vector, your function could simply take one by
reference.

void fun(std::vector <int>& v){
//fill the vector v;
}

int main(){
std::vector<int > a;
fun(a);
return 0;
}

[BigBrian]

> std::vector<int >* fun(){

//build a pointer to vector;
return *v;
do you mean

return &v;

?
}

int main(){
std::vector<int >* a = fun();
return 0;
}

This got memory leak trouble in fun() since v will be deleted after return
thus the pointer returned will be invalid.
It's not a memory leak, you have a pointer to an object on the stack
that's not there anymore.
Is there anyway that I can get a correct pointer from fun()?

you could do something like this...

std::vector<int >* fun()
{
std::vector<int > * v = new std::vector<int >();
//build *v;
return v;
}

and then make sure the caller deletes the returned value.

or you could do something like this...

void fun( std::vector<int > & v )
{
// build v;
}

int main()
{
std::vector<int > x;
fun(x);
}

-Brian

[loufoque]

zl2k wrote :

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is called.
I can do like this:

std::vector<int > fun(){
//build the vector v;
return v;
}

int main(){
std::vector<int > a = fun();
return 0;
}

It works fine.
This is indeed the correct way to do it.

However, I believe there is a deep copy in fun(), so the
cost is big when the array is big.
There won't be any copy if the compiler is smart enough.
There are well known optimizations for return values to prevent
unnecessary copies.

Now I tried to return a pointer without
deep copy.

Using pointers here will only make it messy.

[BigBrian]

loufoque wrote:

zl2k wrote :

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is called.
I can do like this:

std::vector<int > fun(){
//build the vector v;
return v;
}

int main(){
std::vector<int > a = fun();
return 0;
}

It works fine.

This is indeed the correct way to do it.

However, I believe there is a deep copy in fun(), so the
cost is big when the array is big.

There won't be any copy if the compiler is smart enough.
There are well known optimizations for return values to prevent
unnecessary copies.

Now I tried to return a pointer without
deep copy.

Using pointers here will only make it messy.

That may be, but then if performance is an issue, you won't have to
assume that your compiler is smart enough to optimize. IMHO, passing
the array into the function in by reference makes the most since.

[zl2k]

On Mon, 20 Mar 2006 18:44:34 +0100, Rolf Magnus wrote:

zl2k wrote:

hi, c++ user

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is called.
I can do like this:

std::vector<int > fun(){
//build the vector v;
return v;
}

int main(){
std::vector<int > a = fun();
return 0;
}

It works fine. However, I believe there is a deep copy in fun(),
Why?

I am not sure, correct me if not. Is there any deep copy needed if I
return a std container from a function? I'll be very happy if not.

so the cost is big when the array is big. Now I tried to return a
pointer without deep copy.

std::vector<int >* fun(){
//build a pointer to vector;
return *v;
}
}
int main(){
std::vector<int >* a = fun();
return 0;
}
}
This got memory leak trouble in fun() since v will be deleted after
return thus the pointer returned will be invalid.
Your description is correct, though that is not a memory leak.

right, no leak but the returned pointer is invalid.

Is there anyway that I can get a correct pointer from fun()? I also
thought to use a smart pointer, such as boost::shared_p tr:

boost::shared_p tr< std::vector<int > > getV(){ boost::shared_p tr<
std::vector<int > > v; v->push_back(1) ; v->push_back(2) ; return v;
}
}
int main(){
boost::shared_p tr< std::vector<int > > v = getV(); std::cout <<
v->at(0);
return 0;
}
}
I got the following message when run the program:
/usr/include/boost/shared_ptr.hpp: 253: T*
boost::shared_p tr<T>::operator->() const [with T = std::vector<int ,
std::allocator< int> >]: Assertion `px != 0' failed. Aborted

How can I get it correct? Is there any deep copy when the getV() return
the shared_ptr?

Instead of returning a vector, your function could simply take one by
reference.

void fun(std::vector <int>& v){
//fill the vector v;
}
}
int main(){
std::vector<int > a;
fun(a);
return 0;
}

In some cases, I can't construct an empty container and pass it to the
function. I want the class which owns the member function fun to own the
container. Say,

Class A {
public:
void GenerateBigData ();
void getBigData();
private:
std::vector<int > bigData;
}

Basically, the bigData is generated within the class A. When I need it, I
just want to access the bigData by calling getBigData. I don't want a
duplicated copy of the bigData, a reference will be good. I don't know how
to implement it.

zl2k

[Matthias Kluwe]

Hi!

zl2k <kd*******@gmai l.com>:

[...] In some cases, I can't construct an empty container and pass it to the
function. I want the class which owns the member function fun to own the
container. Say,

Class A {
public:
void GenerateBigData ();
void getBigData();
private:
std::vector<int > bigData;
}

Basically, the bigData is generated within the class A. When I need it, I
just want to access the bigData by calling getBigData. I don't want a
duplicated copy of the bigData, a reference will be good. I don't know how
to implement it.

If you find a reference acceptable, why not let getBigData return a const reference to bigData?

Regards,
Matthias

[Clark S. Cox III]

On 2006-03-20 12:35:39 -0500, zl2k <kd*******@gmai l.com> said:

Is there anyway that I can get a correct pointer from fun()? I also
thought to use a smart pointer, such as boost::shared_p tr:

boost::shared_p tr< std::vector<int > > getV(){
boost::shared_p tr< std::vector<int > > v;
v->push_back(1) ;
v->push_back(2) ;
return v;
}

int main(){
boost::shared_p tr< std::vector<int > > v = getV();
std::cout << v->at(0);
return 0;
}

I got the following message when run the program:
/usr/include/boost/shared_ptr.hpp: 253: T*
boost::shared_p tr<T>::operator->() const [with T = std::vector<int ,
std::allocator< int> >]: Assertion `px != 0' failed.
Aborted

Your code is essentially right, save for one thing: You never set the
pointer to point at anything; i.e. it is a default constructed NULL
shared_ptr. Try this instead:

boost::shared_p tr< std::vector<int > > getV(){
//Note the 'new' on the next line, as it is what actually creates the vector
boost::shared_p tr< std::vector<int > > v = new std::vector<int >;
v->push_back(1) ;
v->push_back(2) ;
return v;
}

int main(){
boost::shared_p tr< std::vector<int > > v = getV();
std::cout << v->at(0);
return 0;
}

--
Clark S. Cox, III
cl*******@gmail .com

[Tomás]

Suppose I constructed a large array and put it in the std::vector in a
function and now I want to return it back to where the function is
called.

#include <vector>

template <class T>
class Unconstructed
{
private:

union UniversalAllign ment
{
char a; int b; short c; long d;

bool e;

float f; double g; long double h;

void* p;
};

UniversalAllign ment buffer[
sizeof(T) / sizeof(Universa lAllignment)
+ static_cast<boo l>( sizeof(T) % sizeof(Universa lAllignment) )
];

public:

void* ObjectAddress()
{
return &buffer;
}

T& GetProperRefere nce()
{
return *static_cast<T* >( ObjectAddress() );
}

};

void fun(void* p)
{
new(p) std::vector<int >();
}
int main()
{
Unconstructed< std::vector<uns igned> > my_vec;

fun( my_vec.ObjectAd dress() );

std::vector<uns igned>& real_vec = my_vec.GetPrope rReference();

real_vec.push_b ack( 5 );

real_vec.~vecto r();
}
-Tomás

[loufoque]

BigBrian a écrit :

That may be, but then if performance is an issue, you won't have to
assume that your compiler is smart enough to optimize.

If performance is an issue, use a performant compiler, that will indeed
optimize correctly.

It's a waste of time trying the write fast code with a compiler that
doesn't translate C/C++ code into the most efficient machine code it could.