3

I have a class Bullet that takes several arguments for its construction. However, I am using a dynamic memory array to store them. I am using C++ so i want to conform to it's standard by using the new operator to allocate the memory. The problem is that the new operator is asking for the constructor arguments when I'm allocating the array, which I don't have at that time. I can accomplish this using malloc to get the right size then fill in form there, but that's not what i want to use :) any ideas?

pBulletArray = (Bullet*) malloc(iBulletArraySize * sizeof(Bullet)); // Works
pBulletArray = new Bullet[iBulletArraySize]; // Requires constructor arguments

Thanks.

Trent
  • 1,275
  • 7
  • 17
  • 22
  • Why not wait until you're ready to construct the object? Until you've constructed a `Bullet`, your `Bullet*` has no `Bullet` to point to. – David Schwartz Mar 14 '12 at 15:03
  • I don't want to be requesting new memory 20 times a second possibly. – Trent Mar 14 '12 at 15:03
  • 1
    How does when you call the constructor affect how many times you have to allocate memory? It sounds like there's some incorrect assumption underlying your question. (Also, 20 allocations per second is nothing on modern PCs. Thousands of allocations per second are typical of modern software. Consider opening a web page like this one on a browser!) – David Schwartz Mar 14 '12 at 15:29
  • 1
    @DavidSchwartz - I think that the OP is creating a pool of bullets, (a magazine?), to allow the bullets to be re-used and so avoid memory-management calls during the app run. OK, 20 calls/sec is not that many, but maybe the memory-manager is already heavily loaded, (and it's not just the time spent in the mm call, it's also any time wasted on lock contention). Also, construction may, in itself, be expensive in other ways than just memory allocation, (though this doesn't seem to be the case here). – Martin James Mar 14 '12 at 15:44
  • @Trent: You have to hold them somewhere before you are ready to use them, right? So why not just have the allocator do that, since its purpose is to hold unused memory until you're ready to use it. It sounds like a grossly overcomplicated solution to a non-problem. When you need memory, allocate it. When you're done with it, free it. You have to track it somewhere, why not use the device intended for this purpose? – David Schwartz Mar 14 '12 at 16:58
  • There are good reasons to use object pools. Whether this app can make good use of them to track only 20 POD bullets is more open to debate/investigation. – Martin James Mar 14 '12 at 17:58

6 Answers6

6

You can't.

And if you truly want to conform to C++ standards, you should use std::vector.

FYI, it would probably be even more expensive than what you're trying to achieve. If you could do this, new would call a constructor. But since you'll modify the object later on anyway, the initial construction is useless.

Luchian Grigore
  • 253,575
  • 64
  • 457
  • 625
  • I give the bullet all its properties(position,heading etc) when it is fired, all i am doing now is setting up some memory for the bullets to be put in. – Trent Mar 14 '12 at 15:06
  • So this kind of thing with new isn't possible ? – Trent Mar 14 '12 at 15:07
  • Thanks for your help, I'm avoiding vectors, I'll do it with malloc. – Trent Mar 14 '12 at 15:09
  • @Trent ok. I edited my answer, you probably wouldn't want that anyway. – Luchian Grigore Mar 14 '12 at 15:11
  • I suppose it isn't possible to provide a default ctor for allocation purposes and construct Bullets in place via assignment (RVO; see answer to http://stackoverflow.com/q/2323225/1214731)? – tmpearce Mar 14 '12 at 15:30
  • @Trent Why are you avoiding std::vector? – Edward Loper Mar 14 '12 at 15:33
  • @tmpearce a default constructor will construct some of your members, which is more costly than requesting memory. If you have class members, they will also be constructed. – Luchian Grigore Mar 14 '12 at 15:34
  • @Luchiangrigore True, but since this is a one-time initialization, that cost (should) be less important; it seemed from the question that avoiding memory allocation later, on the fly, was the goal. You're correct though that a pure memory allocation is much cheaper. – tmpearce Mar 14 '12 at 15:37
  • I would not use std::vector for pools either - I would use a ConcurrentQueue or BlockingCollection. – Martin James Mar 14 '12 at 15:48
  • @LuchianGrigore depending on the members a default constructor can avoid initializing anything and basically work out to a no-op. – bames53 Mar 14 '12 at 16:23
5

1) std::vector

A std::vector really is the proper C++ way to do this.

std::vector<Bullet> bullets;
bullets.reserve(10); // allocate memory for bullets without constructing any

bullets.push_back(Bullet(10.2,"Bang")); // put a Bullet in the vector.
bullets.emplace_back(10.2,"Bang"); // (C++11 only) construct a Bullet in the vector without copying.

2) new [] operator

It is also possible to do this with new, but you really shouldn't. Manually managing resources with new/delete is an advanced task, similar to template meta-programming in that it's best left to library builders, who'll use these features to build efficient, high level libraries for you. In fact to do this correctly you'll basically be implementing the internals of std::vector.

When you use the new operator to allocate an array, every element in the array is default initialized. Your code could work if you added a default constructor to Bullet:

class Bullet {
public:
    Bullet() {} // default constructor
    Bullet(double,std::string const &) {}
};

std::unique_ptr<Bullet[]> b = new Bullet[10]; // default construct 10 bullets

Then, when you have the real data for a Bullet you can assign it to one of the elements of the array:

b[3] = Bullet(20.3,"Bang");

Note the use of unique_ptr to ensure that proper clean-up occurs, and that it's exception safe. Doing these things manually is difficult and error prone.

3) operator new

The new operator initializes its objects in addition to allocating space for them. If you want to simply allocate space, you can use operator new.

std::unique_ptr<Bullet,void(*)(Bullet*)> bullets(
    static_cast<Bullet*>(::operator new(10 * sizeof(Bullet))),
    [](Bullet *b){::operator delete(b);});

(Note that the unique_ptr ensures that the storage will be deallocated but no more. Specifically, if we construct any objects in this storage we have to manually destruct them and do so in an exception safe way.)

bullets now points to storage sufficient for an array of Bullets. You can construct an array in this storage:

new (bullets.get()) Bullet[10];

However the array construction again uses default initialization for each element, which we're trying to avoid.

AFAIK C++ doesn't specify any well defined method of constructing an array without constructing the elements. I imagine this is largely because doing so would be a no-op for most (all?) C++ implementations. So while the following is technically undefined, in practice it's pretty well defined.

bool constructed[10] = {}; // a place to mark which elements are constructed

// construct some elements of the array
for(int i=0;i<10;i+=2) {
    try {
        // pretend bullets points to the first element of a valid array. Otherwise 'bullets.get()+i' is undefined
        new (bullets.get()+i) Bullet(10.2,"Bang");
        constructed = true;
    } catch(...) {}
}

That will construct elements of the array without using the default constructor. You don't have to construct every element, just the ones you want to use. However when destroying the elements you have to remember to destroy only the elements that were constructed.

// destruct the elements of the array that we constructed before
for(int i=0;i<10;++i) {
    if(constructed[i]) {
        bullets[i].~Bullet();
    }
}

// unique_ptr destructor will take care of deallocating the storage

The above is a pretty simple case. Making non-trivial uses of this method exception safe without wrapping it all up in a class is more difficult. Wrapping it up in a class basically amounts to implementing std::vector.

4) std::vector

So just use std::vector.

bames53
  • 86,085
  • 15
  • 179
  • 244
1

It's possible to do what you want -- search for "operator new" if you really want to know how. But it's almost certainly a bad idea. Instead, use std::vector, which will take care of all the annoying details for you. You can use std::vector::reserve to allocate all the memory you'll use ahead of time.

Edward Loper
  • 15,374
  • 7
  • 43
  • 52
0
Bullet** pBulletArray = new Bullet*[iBulletArraySize];

Then populate pBulletArray:

for(int i = 0; i < iBulletArraySize; i++)
{
   pBulletArray[i] = new Bullet(arg0, arg1);
}

Just don't forget to free the memory using delete afterwards.

TVOHM
  • 2,740
  • 1
  • 19
  • 29
0

The way C++ new normally works is allocating the memory for the class instance and then calling the constructor for that instance. You basically have already allocated the memory for your instances.

You can call only the constructor for the first instance like this:

new((void*)pBulletArray) Bullet(int foo);

Calling the constructor of the second one would look like this (and so on)

new((void*)pBulletArray+1) Bullet(int bar);

if the Bullet constructor takes an int.

Daniel Schlößer
  • 758
  • 5
  • 16
0

If what you're really after here is just fast allocation/deallocation, then you should look into "memory pools." I'd recommend using boost's implementation, rather than trying to roll your own. In particular, you would probably want to use an "object_pool".

Edward Loper
  • 15,374
  • 7
  • 43
  • 52