Creating an uninitialized array of items which have default constructors?

Question

Given a class Foo which has some value-initializing default constructor:

class Foo {
private:
    uint32_t x;

public:
    constexpr Foo()
        : x { 3 }
    {}
    // ... and some other constructors
};

I need to allocate an array of these Foo's. I don't want the array's elements' default constructors to run, because later I'm going to initialize each element explicitly anyway. Something like this:

Foo foos[20000];

for (int i = 0; i < 20000; ++i) {
    foos[i] = init(i);
}

Is there a way to obtain such an uninitialized array of Foo's given that we're not allowed to change the default constructor of Foo into a non-initializing one?

By the way, this is how you'd create an uninitialized array in D:

Foo[20000] foos = void;

...and here's the same in Rust:

let mut foos: [Foo; 20000] = unsafe { std::mem::uninitialized() };

Actually, cppreference has an example that deals with similar problem en.cppreference.com/w/cpp/types/aligned_storage — zch
– zch, Commented Mar 12, 2015 at 1:51
@zch char may be used to alias other types, but other type may not be used to alias char — M.M
– M.M, Commented Mar 12, 2015 at 1:54

yizzlez · Accepted Answer · 2015-03-12 01:40:46Z

2

If you using C++11, you can use std::vector and emplace_back()

vector<Foo> foos;
for(int i = 0; i < 20000; ++i)
    foos.emplace_back( /* arguments here */);

answered Mar 12, 2015 at 1:40

yizzlez

8,7854 gold badges33 silver badges44 bronze badges

Sign up to request clarification or add additional context in comments.

10 Comments

Neil Kirk Over a year ago

This works but if the purpose of using a C-style array and avoiding the use of default constructors was performance (why else?) using a vector may be slower.

M.M Over a year ago

@NeilKirk profile before assuming... The vector could initially reserve(20000); to avoid unnecessary allocations. Anyway I don't see a better option than this.

Neil Kirk Over a year ago

@MattMcNabb I agree with you, however given the context of the question, I assumed he was looking for micro-optimizations given some profiling already. Also is a compiler allowed to do that by the standard?

kmky Over a year ago

What if I'd like to allocate the array on stack instead of heap. Is it possible to do the same kind of magic that std::vector does under the hood (with reserve and emplace_back) with a stack-allocated blob of uninitialized memory?

kmky Over a year ago

@NeilKirk: I don't have any specific issue at hand. My goal is to learn to do this just in case I ever encounter a performance issue which could be alleviated by not initializing each element twice.

|

kmky · Accepted Answer · 2015-03-12 03:11:35Z

2

Perhaps this answers the question at hand more accurately?

#include <type_traits>

class Foo {
private:
    uint32_t x;

public:
    constexpr Foo()
        : x { 3 }
    {}

    constexpr Foo(uint32_t n)
        : x { n * n }
    {}
};

    // ...and then in some function:

    typename std::aligned_storage<sizeof(Foo), alignof(Foo)>::type foos[20000];

    for (int i = 0; i < 20000; ++i) {
        new (foos + i) Foo(i);
    }

The drawback seems to be that you can use only a constructor to initialize those elements, and not a free function or anything else.

Question: Can I then access those Foo's like this:

    Foo* ptr = reinterpret_cast<Foo*>(foos);
    ptr[50] = Foo();

edited Mar 12, 2015 at 3:11

answered Mar 12, 2015 at 3:00

kmky

7991 gold badge7 silver badges18 bronze badges

1 Comment

M.M Over a year ago

Objects can only be constructed via their constructor, it's not a "drawback" so much as "working as intended". Your access code seems correct, so long as you do it after the construction loop of course.

Vaughn Cato · Accepted Answer · 2015-03-12 02:38:41Z

1

What you might be looking for is std::get_temporary_buffer:

int main()
{
  size_t n = 20000;
  auto buf = std::get_temporary_buffer<Foo>(n);
  if (buf.second<n) {
    std::cerr << "Couldn't allocate enough memory\n";
    return EXIT_FAILURE;
  }

  // ...

  std::raw_storage_iterator<Foo*,Foo> iter(buf.first);
  for (int i = 0; i < n; ++i) {
    *iter++ = Foo();
  }

  // ...

  std::return_temporary_buffer(buf.first);
}

answered Mar 12, 2015 at 2:38

Vaughn Cato

64.6k5 gold badges87 silver badges135 bronze badges

2 Comments

Neil Kirk Over a year ago

It's implementation-defined just how efficient those temporary buffers are. I checked on one of the Visual Studios and it just secretly called new.

mariusm Over a year ago

Interesting, but deprecated in C++17 and removed in C++20.

Collectives™ on Stack Overflow

Creating an uninitialized array of items which have default constructors?

3 Answers 3

10 Comments

1 Comment

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

10 Comments

1 Comment

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related