2 dimensional step array in c++ - c++

Question

I'm new to c++ and I've spent a night thinking about this. I want to create a 2 dimensional array, length of first dimensional is given. Length of second dimensional, is increased from 1. e.g. for 2d array a[][], a[0][] has 1 element, a[1][] has 2 elements, a[2][] has 3 elements, etc.
It doesn't sound like a hard structure, but I can't find a two to create it - all I can do is to create a x * x array which means half of the space is wasted for me.
Anyone has any idea? Thanks in advance.

Answer 1

std::vector solution:
vector< vector<int> > stairs;
for(int i = 0; i < n; i++) // n is size of your array
stairs[i].resize(i+1);
You can also do this using plain pointers:
int * stairs[n];
for(int i = 0; i < n ; i++)
stairs[i] = new int[i+1];
But this time you will have to worry about deleting this structure when it is no longer needed.

Answer 2

Try considering dynamic allocation for your array.
Dynamic array allocation
Another way to make multi dimensional arrays is using a concept known
as pointer to pointers. Like Ron was saying on thursday, most of think
of a 2D array like a spreadsheet with rows and columns (which is just
fine), but 'under the hood', C++ is using ptr to ptrs. First, you
start off with creating a base pointer. Next, allocate an array of row
pointers and assign the address of the first one to the base pointer.
Next, allocate memory to hold each rows column data and assign the
address in the row pointer array
But if you're new to CPP, I assume that you won't be dealing with a large number of data so don't worry about memory !

Answer 3

One solution is to define a class that holds a single dimensional data array of size x*(x+1)/2, and overload type & operator()(int r, int c) to do the right type of indexing.
template<class datatype, int size>
class strange2dArray {
datatype data[size*(size+1)/2];
datatype & operator()(int r, int c) {
// assert if the indexes are correct
return data[r*(r+1)/2+c];
}
};
BTW, unless you're doing this for learning C++, you should probably use some kind of math library (or whatever) to provide you with such elementary data structures. They'll implement it much more efficiently and safely.

Answer 4

First let's see a test of Python:
>>> a=[]
>>> a[0]=3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a={}
>>> a[0]=3
Oops, looks like array, does't means it is array. If you want dynamic size of "array", you can use mapping.
Yes, it is the first solution:
#include <map>
#include <iostream>
using namespace std;
typedef std::map<int, int> array_d2; //length of second dimensional is increased
array_d2 myArray[10] ; //length of first dimensional is given
int main()
{
myArray[0][1] = 3;
myArray[0][2] = 311;
//following are tests
cout << myArray[0][1] << endl;
cout << myArray[0][2] << endl;
return 0;
}
(output is:)
$ ./test
3
311
My second solution is to use , something more like a array , but have the resize capability, you should override the opertation [] to make it automatically for user.
#include <vector>
#include <iostream>
using namespace std;
//length of second dimensional is increased
class array_d2 {
int m_size;
vector<int> m_vector;
public:
array_d2 (int size=10) {
m_size = size;
m_vector.resize(m_size);
};
int& operator[] ( int index ) {
if (index >= m_size) {
m_size = index + 1;
m_vector.resize(m_size);
}
return m_vector[index];
};
};
array_d2 myArray[10] ; //length of first dimensional is given
int main()
{
myArray[0][1] = 3;
myArray[0][20] = 311;
myArray[1][11] = 4;
myArray[1][12] = 411;
//following are tests
cout << myArray[0][1] << endl;
cout << myArray[0][20] << endl;
cout << myArray[1][11] << endl;
cout << myArray[1][12] << endl;
return 0;
}
(output is)
$ ./test1
3
311
4
411