如何在标准向量中推送数组

Question

I am doing some height map in OpenGL. The only z of each vertex is stored in a file, and I have to store as well the x and y value in a vector :

#include <vector>
#include <fstream>
#include <sstream>

int main(void)
{
    std::vector<float>      _data;
    float constexpr         triangle_side(1.118033989);
    std::ifstream           ifs("mymap");
    std::string             line;

    if (not ifs.is_open())
        return -1;
    for (float y(0) ; std::getline(ifs, line) ; --y)
    {
        std::istringstream  iss(line);

        for (float x(static_cast<int>(y) % 2 ? 0 : triangle_side / 2), z ; iss >> z ; x += triangle_side)
            _data.push_back({x, y, z}); // does not compile
    }
    ifs.close();
    return 0;
}

In my opinion, it is a bad thing to do : _data.push_back(x); _data.push_back(y); _data.push_back(z); _data.push_back(x); _data.push_back(y); _data.push_back(z); because the vector perhaps will reallocate the array at each call.

What is the best way to do it ?

If I do :

std::vector< std::array<float, 3> > _data;
//...
_data.push_back({x, y, z});

is it guaranteed the values will all be contiguous ?

Answer 1

std::array<float, 3> is laid out like a C array in memory, so the float s will be contiguous. You could also just use insert :

_data.insert(_data.cend(), {x, y, z});

Answer 2

Use std::vector::reserve(size_type n) to reserve that the backing array contain at least n elements. If it does not, it will be reallocated once. On an existing vector, if you need not just '3' but 'at least 3 more' elements, you just call it with (std::vector::size + 3). After that you can push back safely with the guarantee the array won't be reallocated inside the vector.

A vector of std::array is forced to be contiguous by the standard, as is std::vector. A std::vector of std::arrays thus has all the elements in contiguous order. Source

@cin_cout: C++03 (23.2.4.1):

The elements of a vector are stored contiguously, meaning that if v is a vector where T is some type other than bool, then it obeys the identity &v[n] == &v[0] + n for all 0 <= n < v.size().