access violation in 3-dimensional array c++(using malloc) - c++

Question

I am trying to make a 3-d integer array where I know the number of columns is 2.
I am initializing the array sequentially using malloc. Please suggest what could be wrong?
int **output_vertex[2];
for(int j=0;j<4;j++)
output_vertex[j]= (int **)malloc(sizeof(int **));
output_vertex[1][0]==(int*)malloc(2*sizeof(int));
output_vertex[1][0][0] =11;
//also tried *output_vertex[1][0] =11;

Answer 1

I'm having a bit of trouble understanding what your error is (or which one you'd be referring to). Firstly I don't know why you're statically creating an array and then using malloc. Secondly, I don't understand why you're iterating through your for loop four times (0, 1, 2, 3). Shouldn't your allocation be something like this:
int **output_vertex;
output_vertex = (int **)malloc(2*(sizeof(int **)));

Answer 2

The array declaration you have is not what you intended. You have a two-element array of pointers to pointers to int. This page is a good guide to reading those declarations.
Personally, I prefer to use typedefs and build a complex type like this from the ground up:
typedef int[2] element_type; // this is the 2-element array of ints
typedef element_type* inner_type; // this is the array of unknown size
typedef inner_type[5] outer_type; // this is the actual type we want to use
outer_type output_vertex; // we now have an array of 5 inner_type variables on the stack
// The output_vertex is *uninitialized* so we have to initialize each of its elements
for (int i=0; i < 5; ++i) {
output_vertex[i] = new inner_type[SOME_SIZE];
}
// do stuff with output_vertex now that it's initialized
// then, to prevent memory leaks, delete the memory you allocated
for (int i=0; i < 5; ++i) {
delete[] output_vertex[i];
}
There are probably ways to simplify, but that should be a start.
If you want the inner_type to be appendable, I would strongly recommend using std::vector instead of raw arrays. There is far much bookkeeping to be done with raw arrays, so I won't give an example of that; however, here's more-or-less what you would do with std::vector:
typedef std::pair<int,int> element_type; // this is the 2-element array of ints as a pair
typedef std::vector<element_type> inner_type; // dynamic vector this time
inner_type output_vertex[5]; // we now have an array of 5 inner_type variables on the stack
// do stuff with output_vertex
std::vector is just as fast as a dynamically-allocated array, but you don't have to do any of the bookkeeping yourself. You also have the benefit of not needing to manage as many heap-allocated objects.
Note that raw arrays aren't compatible with containers (e.g. std::vector), so I use std::pair here instead.
If you're able to use C++11 (or boost) and you need a fixed-size array of greater than two items that can fit into a standard container, use std::array.