Zero initialization of std::vector<std::array<double,10>>

Question

Consider the following code

std::vector<std::array<double,10>> a(10);

If I understand the standard correctly a will not be zero initialized, because en.cppreference.com on std::vector constructors says

Constructs the container with count default-inserted instances of T. No copies are made.

So because default initializing std::array<double, 10> does not fill it with zeros, a will also not contain zeros.

Is this true?

How can I enforce zero initialization?

Will a.data() point to 100 continuous double values?

Edit:

This is the output from godbolt on gcc 10.2 with -O2

main:
        mov     edi, 800
        sub     rsp, 8
        call    operator new(unsigned long)
        mov     rdi, rax
        lea     rdx, [rax+800]
.L2:
        mov     QWORD PTR [rax], 0x000000000
        add     rax, 80
        mov     QWORD PTR [rax-72], 0x000000000
        mov     QWORD PTR [rax-64], 0x000000000
        mov     QWORD PTR [rax-56], 0x000000000
        mov     QWORD PTR [rax-48], 0x000000000
        mov     QWORD PTR [rax-40], 0x000000000
        mov     QWORD PTR [rax-32], 0x000000000
        mov     QWORD PTR [rax-24], 0x000000000
        mov     QWORD PTR [rax-16], 0x000000000
        mov     QWORD PTR [rax-8], 0x000000000
        cmp     rdx, rax
        jne     .L2
        mov     esi, 800
        call    operator delete(void*, unsigned long)
        xor     eax, eax
        add     rsp, 8
        ret

So it does seems to be zero initialized. Then the question remains why.

std::vector<std::array<double,10>> a(10, {0}); should zero-initialize, I think. Treating a.data() as an array of 100 doubles would exhibit undefined behavior, I believe. — Igor Tandetnik
– Igor Tandetnik, Commented Mar 30, 2021 at 17:27
Maybe not the most convenient way of doing it, but couldn't you just give an initializer list as default value for the vector constructor? Such that the array are then all initialized with it: std::vector<std::array<double,10>> a(10, {0,0,0,0,0,0,0,0,0,0});? — Nano Byte
– Nano Byte, Commented Mar 30, 2021 at 17:29

Some programmer dude · Accepted Answer · 2021-03-30 17:30:46Z

8

It's correct that the overload will default insert elements.

But you have to keep on reading, as default insertion means that the values inserted will be value initialized, and value-initializing an aggregate (like std::array) will value-initialize all elements in the aggregate.

And value initialization of double values will be the same as zero-initialization.

So all elements in each array of the vector will be initialized to zero.

answered Mar 30, 2021 at 17:30

Some programmer dude

411k36 gold badges420 silver badges655 bronze badges

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

6 Comments

benjamin-lieser Over a year ago

Thanks, this makes sense. Is using a.data() as a pointer to 100 double undefined behavior?

Some programmer dude Over a year ago

@Unlikus a.data() returns a pointer to the first element of the vector, which is a std::array<double, 10>*, not a double*. So no a.data() can't be used like that.

Adrian Mole Over a year ago

Nice answer! But this cppreference page is a bit confusing: note that default initialization may result in indeterminate values for non-class T.

Remy Lebeau Over a year ago

@Unlikus std::array<double, 10> is a wrapper for a double[10], with no other data members (since std::array is an aggregate), so sizeof(std::array<double, 10>) is guaranteed to be at least sizeof(double)*10. std::vector is a contiguous buffer of elements, where each element in this case is a std::array<double, 10>. So the only guarantee is that a(10) would effectively be an array of 10 contiguous std:arrays. But not guaranteed to be a contiguous buffer of 100 doubles, because std::array may add extra padding after its inner array.

Adrian Mole Over a year ago

@Unlikus I'm not sure you will. The Dude's answer seems comprehensive - I'm just confused about what cppreference means.

|

Adrian Mole · Accepted Answer · 2021-03-30 17:35:29Z

1

To be sure that your arrays are zero-initialized, you can add a 1-element initializer list as a second argument to the a constructor call:

std::vector<std::array<double, 10>> a(10, { 0.0, });

This will initialize each element (array) using that list, as it will be using constructor version #3 described here in cppreference.

The 'value' argument used to initialize each array will use aggregate initialization (see here), which will zero-initialize any 'missing' values in the list.

answered Mar 30, 2021 at 17:35

Adrian Mole

52.1k193 gold badges61 silver badges101 bronze badges

Comments

halfer · Accepted Answer · 2021-03-30 21:05:35Z

0

You can do this as it is shown in the demonstrative program below:

#include <iostream>
#include <array>
#include <vector>

int main() 
{
    std::vector<std::array<double,10>> v(10, { {} } );
    
    for ( const auto &a : v )
    {
        for ( const auto &item : a )
        {
            std::cout << item << ' ';
        }
        std::cout << '\n';
    }
    
    
    return 0;
}

The program output is

0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0

edited Mar 30, 2021 at 21:05

halfer

20.2k20 gold badges110 silver badges207 bronze badges

answered Mar 30, 2021 at 17:33

Vlad from Moscow

313k27 gold badges204 silver badges358 bronze badges

Collectives™ on Stack Overflow

Zero initialization of std::vector<std::array<double,10>>

3 Answers 3

6 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

6 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related