在初始化时预先填充std :: vector？

Question

我想创建一个double向量的向量向量，并希望它已经有（32,32,16）个元素，而无需手动推回所有这些元素。 在初始化期间有没有办法做到这一点？ （我不在乎推送什么价值）

谢谢

我想要一个三维数组，第一维有32，第二维有32，第三维有16个元素

Answer 1

一个班轮：

std::vector< std::vector< std::vector<double> > > values(32, std::vector< std::vector<double> >(32, std::vector<double>(16, 0.0)));

或打破线条：

typedef std::vector<double> v_type;
typedef std::vector<v_type> vv_type;
typedef std::vector<vv_type> vvv_type;

vvv_type values(32, vv_type(32, v_type(16, 0.0)));

我会说这会分配很多对象（32 * 32 * 16）。

单个矢量会起作用吗？

std::vector<double> values(32*32*16, 0.0)

这将是32 * 32 * 16-1少new 。

Answer 2

向量的其中一个ctors允许您指定要复制到向量元素的大小和值。 我不太确定“（32,32,16）”元素的意思，但你可以这样做：

// create a vector containing 16 elements set to 2
std::vector<int> temp(16, 2);   

// create a vector of 32 vectors, each with 16 elements set to 2
std::vector<std::vector<int> > values(32, temp);

Answer 3

干得好：

    vector<vector<vector<int> > > k(32, vector<vector<int> >(32, vector<int>(16,0)));

我甚至不会问为什么你会想要这样的怪物而不只是使用你自己的索引方案的单个vector 。

Answer 4

由于大小是事先知道的，你需要将整个数组转换为1D数组（对于OpenGL）为什么不为它创建一个类？ 我已经创建了一个基于模板的3D数组实现，希望对您有用。

用法：

typedef Array3D<double, 3, 3, 3> DoubleArray333;
DoubleArray333 array;
Double val = 0.0;
for (size_t i = 0; i < DoubleArray333::SizeX; ++i)
{
 for (size_t j = 0; j < DoubleArray333::SizeY; ++j)
 {
  for (size_t k = 0; k < DoubleArray333::SizeZ; ++k)
  {
   array(i, j, k) = val++;
  }
 }
}
for (size_t i = 0; i < DoubleArray333::ArraySize; ++i)
{
 std::cout<<array[i]<<" ";
}

Array3D头文件：

#pragma once

#include <exception>
#include <sstream>
#include <utility>
#include <memory>

/**
 * \brief   A 3D array of variable type and size.
 * \author  Vite Falcon
 * \date    08/06/2010
**/
template <typename T, int x, int y, int z>
class Array3D
{
private:
    T* m_array;

    /**
     * \brief   Validate the index range of different dimensions.
     * \remarks Vite Falcon, 08/06/2010.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \exception   std::out_of_range   Thrown when one of the indices is out-of-range.
     * \param   x   The width index.
     * \param   y   The height index.
     * \param   z   The depth index.
    **/
    inline void validateRange(size_t x, size_t y, size_t z)
    {
        if (x >= SizeX || y >= SizeY || z >= SizeZ)
        {
            std::stringstream ss;
            ss<<"Index out of range when accessing ("<<x<<", "<<y<<", "<<z<<
                ") when total size is ("<<SizeX<<", "<<SizeY<<", "<<SizeZ<<").";
            throw std::out_of_range(ss.str());
        }
    }

    /**
     * \brief   Validates the given array index.
     * \remarks Vite Falcon, 08/06/2010.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \exception   std::out_of_range   Thrown when the index is out-of-range.
     * \param   index   Zero-based index of the array.
    **/
    inline void validateIndex(size_t index)
    {
        if (index >= ArraySize)
        {
            std::stringstream ss;
            ss<<"Index out of range when accessing array by index "<<index<<
                " when total array size is "<<ArraySize<<".";
            throw std::out_of_range(ss.str());
        }
    }
public:
    static const size_t SizeX;
    static const size_t SizeY;
    static const size_t SizeZ;
    static const size_t ArraySize;

    typedef Array3D<T,x,y,z> MyType;

    /**
     * \brief   Default constructor. 
     * \author  Vite Falcon
     * \date    08/06/2010
    **/
    Array3D(void)
        :m_array(new T[ArraySize])
    {
    }

    /**
     * \brief   Copy constructor.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   other   The other.
    **/
    Array3D(const MyType& other)
        :m_array(new T[ArraySize])
    {
        memcpy_s(m_array, sizeof(T)*ArraySize, other.m_array, sizeof(T)*ArraySize);
    }

    /**
     * \brief   Destructor.
     * \author  Vite Falcon
     * \date    08/06/2010
    **/
    ~Array3D(void)
    {
        delete[] m_array;
        m_array = 0;
    }

    /**
     * \brief   Gets the value at a particular array index.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   array_index Zero-based index of the array.
     * \return  The value at the given index.
    **/
    inline T& at(size_t array_index)
    {
        return (*this)[array_index];
    }

    /**
     * \brief   Gets the value at a particular array index (const version)
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   array_index Zero-based index of the array.
     * \return  The value at the given index.
    **/
    inline const T& at(size_t array_index) const
    {
        return (*this)[array_index];
    }

    /**
     * \brief   Gets the value in the array from the given 3D indices.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   x   The width index.
     * \param   y   The height index.
     * \param   z   The depth index.
     * \return  The value at the given indices.
    **/
    inline T& at(size_t x, size_t y, size_t z)
    {
        return (*this)(x, y, z);
    }

    /**
    * \brief    Gets the value in the array from the given 3D indices (const version).
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   x   The width index.
     * \param   y   The height index.
     * \param   z   The depth index.
     * \return  The value at the given indices.
    **/
    inline const T& at(size_t x, size_t y, size_t z) const
    {
        return (*this)(x, y, z);
    }

    /**
     * \brief   The '()' operator to access the values as a 3D array.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \return  The value at the given indices.
     *
     * \param   x   The width index.
     * \param   y   The height index.
     * \param   z   The depth index.
    **/
    inline T& operator ()(size_t x, size_t y, size_t z)
    {
        validateRange(x, y, z);
        return m_array[x*SizeY*SizeZ + y*SizeZ + z];
    }

    /**
     * \brief   The '()' operator to access the values as a 3D array (const version).
     * \author  Vite Falcon
     * \date    08/06/2010
     * \return  The value at the given indices.
     *
     * \param   x   The width index.
     * \param   y   The height index.
     * \param   z   The depth index.
    **/
    inline const T& operator()(size_t x, size_t y, size_t z) const
    {
        validateRange(x, y, z);
        return m_array[x*SizeY*SizeZ + y*SizeZ + z];
    }

    /**
     * \brief   The '[]' operator to access the values as a 1D array.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   array_index Zero-based index of the array.
     * \return  Value at the given index.
    **/
    inline T& operator[](size_t array_index)
    {
        validateIndex(array_index);
        return m_array[array_index];
    }

    /**
     * \brief   The '[]' operator to access the values as a 1D array.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   array_index Zero-based index of the array.
     * \return  Value at the given index.
    **/
    inline const T& operator[](size_t array_index) const
    {
        validateIndex(array_index);
        return m_array[array_index];
    }

    /**
     * \brief   Fills the array with the given value.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   val The value to fill the array.
    **/
    void fill(const T& val)
    {
        for (size_t i = 0; i < ArraySize; ++i)
        {
            m_array[i] = val;
        }
    }

    /**
     * \brief   Gets the raw array.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \return  The 1D array.
    **/
    T* getArray()
    {
        return m_array;
    }

    /**
     * \brief   Swaps the current array with the given one.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param [in,out]  other   The other.
    **/
    void swap(MyType& other)
    {
        std::swap(m_array, other.m_array);
    }

    /**
     * \brief   Copy operator.
     * \author  Vite Falcon
     * \date    08/06/2010
     * \param   other   The other.
     * \return  A shallow copy of this object.
    **/
    MyType& operator = (const MyType& other)
    {
        MyType temp(other);
        swap(temp);
        return *this;
    }
};

template <typename T, int x, int y, int z>
const size_t Array3D<T, x, y, z>::SizeX = x;

template <typename T, int x, int y, int z>
const size_t Array3D<T, x, y, z>::SizeY = y;

template <typename T, int x, int y, int z>
const size_t Array3D<T, x, y, z>::SizeZ = z;

template <typename T, int x, int y, int z>
const size_t Array3D<T, x, y, z>::ArraySize = x*y*z;

您还可以使用以下函数将指向数组的指针作为1D：
double* double_array = array.getArray();

编辑：更改用法以使用double而不是int来显示它。