Adding new element to STL Vecotr - Efficiently

[Shimon.Sofer]

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

Thanks
Shimon

[Kai-Uwe Bux]

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

You might try

V.resize( V.size()+1 );
Best

Kai-Uwe Bux

[Christian Meier]

"Kai-Uwe Bux" <jk********@gmx.net> schrieb im Newsbeitrag
news:dj**********@murdoch.acc.Virginia.EDU...

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

You might try

V.resize( V.size()+1 );
Best

Kai-Uwe Bux

Isn't this the same?

U my_u;
V.push_back(U);
U& RU = V.back();

One constructor and one copy constructor.

V.resize( V.size()+1 );

One constructor and one copy constructor, too....
The constructor is called because the default argument is "T x = T()".

But I can't think of a solution because the containers always copy the
objects. The function push_back is not overloaded.... if it were overloaded,
we could call it perhaps without argument and it would add a
default-constructed object at the end. And it could return an iterator to
the inserted element. Then we would not have to call "back()".

Greetings Chris

[mlimber]

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

How about a vector of (smart) pointers to U objects? Then, although a
copy is still done, it's trivial because it's only copying a pointer
and you control when and how construction is done:

class U {};

void Foo( std::vector<U*>& v )
{
v.push_back( new U );
}

Cheers! --M

[ben]

mlimber wrote:

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

How about a vector of (smart) pointers to U objects? Then, although a
copy is still done, it's trivial because it's only copying a pointer
and you control when and how construction is done:

class U {};

void Foo( std::vector<U*>& v )
{
v.push_back( new U );
}

Cheers! --M

This way you add another layer to element access. smart pointers usually
have house keeping tasks for every access (for example, check for
emptiness, reference counting, etc) and this can be expensive.

So this might end up incurring more overhead than just a copy
constructor call.

Ben

[mlimber]

ben wrote:

mlimber wrote:

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

How about a vector of (smart) pointers to U objects? Then, although a
copy is still done, it's trivial because it's only copying a pointer
and you control when and how construction is done:

class U {};

void Foo( std::vector<U*>& v )
{
v.push_back( new U );
}

Cheers! --M

This way you add another layer to element access. smart pointers usually
have house keeping tasks for every access (for example, check for
emptiness, reference counting, etc) and this can be expensive.

So this might end up incurring more overhead than just a copy
constructor call.

Ben

True, but that is entirely dependent on the type of smart pointer
(boost::shared_ptr doesn't do any extra work for normal access by * and
-> if BOOST_ASSERTs are disabled, and std::auto_ptr, for instance,
incurs no run-time overhead, though, of course, it can't be used in
standard containers), and if worst came to worst, one could use raw
pointers, as I did in the example above.

The bigger question here, of course, is about premature optimization --
both in the OP and in the case of smart pointers vs. raw pointers.

Cheers! --M

[Mirek Fidler]

Sh**********@gmail.com wrote:

Hi

I want to increase my vector by one without supplying
any object as parameter (I want stl to use default constructor)

e.g.

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

I need something like that :

void f()
{
V.push_back();
U& RU = V.back();
}

Can I do it somehow ?

Yes.

Vector<U> v;
U& r = v.Add();

see

http://upp.sf.net
http://upp.sourceforge.net/src$Vector$en-us.html

Actually, this was the exact problem that forced me to avoid using STL
(other being the copy-constructible requirement).

Mirek

[int2str]

Sh**********@gmail.com wrote:

// defined outside
vector<U> V;

void f()
{
U my_u;
V.push_back(U);
U& RU = V.back();
}

In the above example the default contructor of U was called
and later copy constructor ! this is inefficient !

Can't help you with your actual question, but another thing to keep in
mind is this:

Make sure the vector has some room to grow by using v.reserve(n); at
some point (where n>1). That way push_back() is not going to cause even
more overhead than you actually see already.

Cheers,
Andre

[Kai-Uwe Bux]

mlimber wrote:

ben wrote:

mlimber wrote:

> Sh**********@gmail.com wrote:
>
>>Hi
>>
>>I want to increase my vector by one without supplying
>>any object as parameter (I want stl to use default constructor)
>>
>>e.g.
>>
>>// defined outside
>>vector<U> V;
>>
>>void f()
>>{
>>U my_u;
>>V.push_back(U);
>>U& RU = V.back();
>>}
>>
>>In the above example the default contructor of U was called
>>and later copy constructor ! this is inefficient !
>>
>>I need something like that :
>>
>>void f()
>>{
>>V.push_back();
>>U& RU = V.back();
>>}
>>
>>Can I do it somehow ?
>
>
> How about a vector of (smart) pointers to U objects? Then, although a
> copy is still done, it's trivial because it's only copying a pointer
> and you control when and how construction is done:
>
> class U {};
>
> void Foo( std::vector<U*>& v )
> {
> v.push_back( new U );
> }
>
> Cheers! --M
>

This way you add another layer to element access. smart pointers usually
have house keeping tasks for every access (for example, check for
emptiness, reference counting, etc) and this can be expensive.

So this might end up incurring more overhead than just a copy
constructor call.

Ben

True, but that is entirely dependent on the type of smart pointer
(boost::shared_ptr doesn't do any extra work for normal access by * and
-> if BOOST_ASSERTs are disabled, and std::auto_ptr, for instance,
incurs no run-time overhead, though, of course, it can't be used in
standard containers), and if worst came to worst, one could use raw
pointers, as I did in the example above.

The bigger question here, of course, is about premature optimization --
both in the OP and in the case of smart pointers vs. raw pointers.

Actually, the biggest question should be whether the OP needs/wants copy or
reference semantics for the objects in the container. Changing
std::vector<T> to std::vector<T*> or std::vector<boost::shared_ptr<T>>
changes the semantics of the container quite dramatically.

Should profiling show that copy constructor and assignment calls for a class
are too expensive, one could reimplement the class so that it uses a copy
on write optimization internally without changing the public interface at
all. That would also reduce copy costs at other places in the program.
Best

Kai-Uwe Bux