calling constructor for each element of array

Question

class K {
public:

    K(int a, int n) : n(n) {
    }


    static void allocate(unsigned number, unsigned n) {
        K* w = reinterpret_cast<K*> (::operator new( sizeof (K) * number)); 

        for (int i = 0; i < number; i++) {
            new( (void*) (w + i))K(24, n);
            //(w)->K::K(24,n);

        }
    }
private:


    const int n;

};

Why the first way ( new( (void*) (w + i))K(24, n);) don't make error and the second way ((w)->K::K(24,n);) make error? Eventually, how repair it?
Tha allocate is static, so why I have access to n which is private?

Why do you keep doing crazy things with reinterpret_cast and calls to operator new? — Lightness Races in Orbit
– Lightness Races in Orbit, Commented Mar 16, 2014 at 23:08

VoidStar · Accepted Answer · 2014-03-16 23:46:03Z

I'm going to state my understanding of what you're trying to do, which is not 100% clear to the respondents. Since you don't have a default constructor for your class, you cannot allocate them in an array using new[]. Your recourse is to invoke the constructors manually using placement new.

In general, try to make a default constructor for classes that need to be allocated with new[]. Then you can just go update them after you've allocated them. This is simpler and easier to read. For example, w = new K[number]; and delete[] w; handles everything for you, but it can only call the default constructor. So you must do "post construction initialization" with your own function to set them up the way you want.

If you really want to call the individual constructors using placement new, you can and it is safe. It's not my recommended design, but neither is it as evil as some might assume. Your code works, but you don't do anything with w after you're done, so it's a leak... but examining it in the debugger, it has called the constructor on each one, just like you wanted. You should note that you are reusing n in different scopes, which is confusing. You should disambiguate that. The n from allocate is being fed into each constructor.

One other important note though, and this is the disadvantage of the design of using placement new here. You must:

Manually invoke the destructor on each element when you are done. Therefore, you must track the length of the array manually until freeing.
Free w the matching way it was allocated. Do not use delete[] if you didn't use new[].

Lightness Races in Orbit · Accepted Answer · 2014-03-16 23:09:07Z

0

static members may access the private data of any instance of its type. Dem's da rules.

However, here, you're using the function argument.

I'm not even going to comment on your mental memory allocations.

answered Mar 16, 2014 at 23:09

Lightness Races in Orbit

387k77 gold badges670 silver badges1.1k bronze badges

4 Comments

thumbmunkeys Over a year ago

isnt n hidden by the n passed to the function?

Lightness Races in Orbit Over a year ago

@thumbmunkeys: That is also true :)

user3425832 Over a year ago

"I'm not going to comment on your mental memory allocations." Help :)

Lightness Races in Orbit Over a year ago

@user3425832: Don't do them

Collectives™ on Stack Overflow

calling constructor for each element of array

2 Answers 2

Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related