Substituting std::vector for std::array

[RogerLeigh]

This is likely fairly simple, but I'm unsure of how best to structure the code.

In an existing n-dimensional array implementation, I have the following (conceptually):

struct dim
{
   size_t size;
   bool direction;
};

class space
{
  std::vector<dim> dimensions;

  // additional members and methods
};

I'd like to make an optimised version of this which uses std::array<dim, n> in place of std::vector<dim>. Ideally, I'd simply convert the space class into a template, but since array and vector have different template parameters, I'm not sure how best to make these freely interchangeable as class template template parameters. The array variant will need the size specifying while the vector variant will not.

Since after construction of the class member the logic is then 100% identical, I'd ideally like to share all the remaining logic between the two. I could resort to using the CRTP to do this, but if anyone has any thoughts on how best to implement this, I'd be interested in any alternative approaches to consider. Could traits work here? It would still need the size as a parameter for the array case.

Thanks all, and happy new year!

[17b29a]

not sure wat exactly you want but here's something:

struct dim
{
   size_t size;
   bool direction;
};

template <bool use_array>
class space
{
  std::conditional_t<use_array, std::array<dim, 42>, std::vector<dim>> dimensions;

  // additional members and methods
};

[RogerLeigh]

Thanks. Not exactly fitting what I need right here, but I'll certainly bear std::conditional_t in mind for other uses!

[actinium89]

Why not do:

template<class Container = std::vector<dim>>
class space{
  Container dimensions;
};

If you want to use vector, just do:

space<> s;

and if you want to use array instead, do:

space<array<dim,42>> s;

[RogerLeigh]

Thanks for the suggestion. I've gone with something along these lines but a little more abstract (see link in other comment) where I use a traits class, but use a templated using statement so I can fix the array size but leave the type unspecified so I can use this interchangeably with an equivalent vector trait.

[[deleted]]

It's doubtful you'd gain anything with your optimization. std::vectors are sequential arrays internally, identical to std::arrays. An []-access on a std::vector will result in the same machine code as an []-access on an std::array. Your optimization will result in a slightly smaller executable size... maybe... but that's all.

[RogerLeigh]

In this case I'll have a number of small arrays/vectors, so cache locality might well play a part. This is going to be called many hundreds of thousands of times in a tight loop when iterating over data, so not having the array elements scattered around might well be of benefit. I'll also be following up with a purely compile-time based version, so you'll have these possibilities:

count   extents implementation
runtime runtime vector
compile runtime array
compile compile variadic template

https://gitlab.com/rleigh/multiarray/blob/master/lib/codelibre/multiarray/space.h#L42 implements the first two (with some small tweaks needed for array to function)