Multidimension vector concept C++ - c++

Question

I have a huge 3d vector where I store double values. In order to increase the performance I wanted to reserve the number of elements in advance as I know them before processing;however, I couldn't really figure it out how reserve&clear&erase work in this case.
I have implemented a small program which has 2d vector in this case, pls see the code snippet below:`
for(int counter = 0; counter < 2; counter++){
cout << "Counter-> " << counter << endl;
vector<vector<double> > vec2D;
vec2D.reserve(2);
// assign values to the vec
for(int i = 0; i < 2; i++){
vec2D[i].reserve(5);
for(int j = 0; j < 5; j++){
vec2D[i][j] = j;
}
}
// print the vector content
for(int i = 0; i < 2; i++){
for(int j = 0; j < 5; j++){
cout << vec2D[i][j] << "\t";
}
vec2D[i].clear();
cout << endl;
}
vec2D.clear();
}
When I run this code snippet it iterates thorugh the for loop just for once where it should do it twice; however, when I declare the vector outside of the for loop it does iterate twice. The output of the above snippet is:
Counter-> 0
0 1 2 3 4
0 1 2 3 4
Counter-> 1
Could you please make it clear how it actually should be in this case and how it works.
Thanks in advance.

Answer 1

You have a big problem in your code: reserve() does not change the size of the vector, only its storage capacity (to avoid system calls in the future).
What is needed in your case instead of reserve() is assign() or resize().

Answer 2

If you want any semblance of performance don't use vectors of vectors: this is terribly inefficient. This is probably the most efficient memory utilization, and faster access than vectors, although there are faster solution with some memory trade-offs:
class GridWithSmallDimensions
{
double * values;
int sizeX, sizeY, sizeZ;
public:
GridWithSmallDimensions(int x, int y, int z)
: sizeX(x), sizeY(y), sizeZ(z)
{
values = new double [x*y*z];
}
~ GridWithSmallDimensions()
{
delete [] values;
}
double get(int x, int y, int z)
{
return value[x+sizeX*(y+sizeY*z)];
}
void set(int x, int y, int z, double v)
{
value[x+sizeX*(y+sizeY)] = v;
}
};
Here's a slightly more involved implementation, aimed at reduction of index calculations:
class GridWithRowPointers
{
int sizeX, sizeY, sizeZ; // Dimensions
double * values; // Data
double ** rows; // Pointers to "rows" of data indexed by x
inline int getIndex(y, z) const // Get index of data within a row
{
return sizeZ * y + z;
}
public:
GridWithRowPointers(int x, int y, int z)
: sizeX(x), sizeY(y), sizeZ(z)
{
values = new double [x*y*z]; // Allocate data
rows = new (double*) [x]; // Allocate row pointers
for( int n = 0; n < sizeX; n++ )
{
rows[n] = values + sizeY * sizeZ;
}
}
~ GridWithRowPointers()
{
delete [] values;
delete [] rows;
}
inline double get(int x, int y, int z) const
{
// Access value via row pointer
return rows[ x ][ getIndex(y,z) ];
}
inline void set(int x, int y, int z, double v)
{
// Access value via row pointer
rows[ x ][ getIndex(y,z) ] = v;
}
};