Thread: costructing a, object while pushing_back

hey

do I have a way to push_back a data sctructure into a vector without an outside copy? I mean: can I initialize the constructor of a class directly on vector im storing it?

avoiding doing this:

Code:

vector<particle> Event;
particle part(id,pz,spin);
Event.push_back(part);

tks in advance for any help I get

Edit: my obvious solution is to have an outside particle reseting but that defeats the portpuso of having multiple constructors

in C++11 they added an emplace_back() that constructs the object in place. not sure which compilers support it yet, but at least gcc 4.7 does.

something like this:

Code:

#include <iostream>
#include <string>
#include <vector>

class A
{
  public:
    A(int a) { std::cout << "A(int) called" << std::endl; }
    A(std::string a) { std::cout << "A(std::string) called" << std::endl; }
};

int main()
{
  std::vector<A> v;
  v.emplace_back(3);
  v.emplace_back("foo");
  return 0;
}

Visual C++ I know supports it. Clang more then likely not does too, seeing as it is probably the compiler closes to implementing full C++11 support. It also tend to rely on the standard library shipped with GCC.
Also, push_back isn't so bad, really, since you can move the data into the vector (but emplace_back is better). Moving is usually cheap. Example:

vector<particle> Event;
Event.push_back(particle(id,pz,spin));

or

vector<particle> Event;
particle part(id,pz,spin)
Event.push_back(std::move(part));
// Don't use part after this; its state is undefined.

the C++ standard allows the compiler to optimize away some copies. not sure if this is one of them.

Originally Posted by killme

using C++11 isn't really an option (not that I don't have a compiler for it, its just a project requirement)

this doesn't have the need to allocate temporary memory every time its called?

Yes, it does allocate a temporary. But in C++11, you would move the temporary into the vector, thereby avoiding having to create an entire new object and copy the data over.
If you can't use C++11, then you are out of luck. Your best option would be simply to store pointers and lazily construct the objects.
If you case use TR1, you still have smart pointers at your disposal. Otherwise, there's boost.
In worst case, you can make your own to manage memory for you.