4 Answers
4

If you can characterize the maximum amount of memory needed for a set of these arrays that will be used for any particular 'frame' (whatever that is), and if you will be dealing with only a single frame at a time (in other words, you'll be performing work on a single set of arrays, then dumping all of those arrays before performing another round of work on another set of arrays) then you'll likely get the best performance by allocating your arrays from a block of static memory that you've size appropriate for your largest possible work set.

Then your array allocation can be a simple pool allocator that carves out memory for an array from the front of the block and adjusts the block pointer to just past that allocation to be ready for the next array allocation. When you're done with the work on that set of arrays, everything can be freed by 'cleaning the pool' - simply resetting the block pointer to the start of the static memory pool.

Of course, since you haven't given much in the way of details for how your work must be done, this technique might not fit at all (that's probably why you haven't found a definitive answer yet - such an answer depends on the specific characteristics of the work you're performing).

std::vectors are typically as good as C-arrays, but if you want ultimate bare-bone speed and you know what you are doing, nothing can match managing C-array yourself.

There are trade-offs you have to consider.
- How much of time you are willing to spend debugging custom code?
- How much of custom code you are willing to write?

Also array/vector libraries are very well tested and optimized for speed and memory consumption, you might want to benchmark them using various compiler settings before deciding (in case if you do please share the results).

You give us too little information about your problem to give you a good answer. Is your program supposed to run only on one platform, or should it be platform independent? Is time-efficiency critical for your project? If so, perhaps using 'new' and 'delete' will be too slow for you and you need to resort to some platform specific or third party allocator. Then, the choice between a dynamically allocated array and an std::vector shouldn't make a difference.
Or do you want to allocate the arrays on the stack? But there is a limit to the size of the array you can create on the stack. What are the sizes of matrices?

If you want to represent a matrix, one unidimensionnal array is already better than a multidimensional array. An array is already the simplest structure you have at your disposition, so it is more appropriate.

The purpose of Vector is to implement a dynamic array, and you may not need this feature as a matrix has a fixed size.