C型数组比std :: array和std :: vector更好的容器，用于从移动语义中受益的固定大小数据？

Question

I am creating a new implementation of an N-dimensional vector (we'll call it VectorND ) to replace some old code in a bigger system. The vector size will be known at compile time, hence c-style arrays, std::array and std::vector are all viable candidates for the underlying data structure of the VectorND class.

I noticed that the vectors get passed around a lot, and think the system would benefit greatly if the new VectorND class could efficiently be moved. (I realize that a lot of the 'passing around' won't be able to use move's, but the vectors occur as rvalue's quite often too)

The std::vector class supports move semantics and as the c-style array is just a pointer both of these allow for trivial a move constructors/assignment operator in the VectorND class. The std::array class however needs O(n) time to be moved, which to me sounds like this "most obvious choice" is in fact the worst in this case.

For the remaining two, the c-style array can be allocated as a single chunk of memory and hence really use the fact that we know the size at compile time.

Am I missing something or is the c-style array indeed the best underlying container for my VectorND class?

(it sounds strange that the newer stl classes would be a worse choice)

EDIT: After reading through my post again, I realize that a std::unique_ptr to an std::array might give me the best of both worlds?

Answer 1

I decided to follow juanchopanza's advice and go for the std::vector . As I already mentioned in the question it can be moved (in O(1)) and as juanchopanza pointed out, the overhead is very small.

Furthermore I like that it gives me the option to declare the move operations as default, increasing code readability. (I wanted to add a virtual destructor so I needed to add them as the compiler won't generate them when a destructor is specified)

For those interested, the relevant declarations:

/// Copy constructor
VectorND(const VectorND &) = default;
/// Move constructor
VectorND(VectorND &&) = default;
/// Copy assignment
VectorND& operator=(const VectorND &) = default;
/// Move assignment
VectorND& operator=(VectorND &&) = default;
/// Destructor
virtual ~VectorND() = default;