CareerCup

Approach 2 (using malloc only once):

void *temp = (void *) malloc((r+r*c)*sizeof(void *));
int **arr = (int **)temp;
arr[0] = (int *)(temp+r);
arr[1] = (int *)(temp+r+c);
arr[2] = (int *)(temp+r+2c);
.
.
arr[r-1] = (int *)(temp+r+(r-1)c);

R,C defined ;
int** arr=(int**)malloc(sizeof(int*)*R);

for(i=0;i<R;i++)
arr[i]=(int*)malloc(sizeof(int)*C );


Approach -2 :

int**arr=(int**)malloc(sizeof(int)*R*C);
int*ptr=*arr;

for(i=0;i<R;i++)
{
*(arr+i)=( ptr+i*C ) ;
}

Assuming r,c is defined.

Approach 1 (using malloc 2 times):
int **arr = (int *) malloc(r*sizeof(int *));
int *temp = (int) malloc(r*c*sizeof(int));
arr[0] = temp;
arr[1] = temp+c;
arr[2] = temp+2c;
..
..
arr[r-1] = temp+(r-1)c;

second approach the allocation is correct, just only when accessing the array, the element at i, j postion will need to be accessed as
a[i*m+j] where m is the number of columns, while in the first approach the element at i, j could be accessed as
a[i][j]

//creates a two D array of m*n

nt **a = (int**)( malloc( m * sizeof( int* ) ));
for( int i=0;i<m; i++ )
{
a[i] = (int*)( malloc( n * sizeof( int ) ) );
}

Well... If the question is to allot space for a 2D array of say 10*10 we can do something of this sort as well

int* p= (int *)malloc(sizeof(int)*10*10);

Does this satisfy the constraints ?

www . ics . uci . edu / ~ dan / class /165 /notes /memory . html

char** My2DAlloc(int row, int col)
{
char **r = NULL;
int i = 0;

if((row == 0) || (col == 0))
return NULL;

/* Allocate memory for row pointers */
r = (char**)malloc(row*sizeof(char*));
assert(r != NULL);

for(i=0; i<row; i++)
{
*(r+i) = (char*)malloc(col);
assert((char*)(*(r+i)) != NULL);
}
return r;
}

char** My2DAlloc_twice(int row, int col)
{
char **r = NULL;
char *c = NULL;
int i = 0;

if((row == 0) || (col == 0))
return NULL;

/* Allocate memory for row pointers */
r = (char**)malloc(row*sizeof(char*));
assert(r != NULL);
c = (char*)malloc(row*col);
assert(c != NULL);

for(i=0; i<row; i++)
{
*(r+i) = (char*)(c + i*col);
}
return r;
}

char** My2DAlloc_once(int row, int col)
{
char **r = NULL;
char *loc = NULL;
int i = 0;

if((row == 0) || (col == 0))
return NULL;

/* Allocate memory for row pointers */
r = (char**)malloc(row*sizeof(int*)+ row*col);
assert(r != NULL);

loc = r + row; //Addition of pointers advances bytes = num*sizeof(data type)

for(i=0; i<row; i++)
{
*(r+i) = (char*)(loc + i*col);
}
return r;
}

char** My2DAlloc(int row, int col)
{
	char **r = NULL;
	int i = 0;
	
	if((row == 0) || (col == 0))
		return NULL;
	
	/* Allocate memory for row pointers */
	r = (char**)malloc(row*sizeof(char*));
	assert(r != NULL);

	for(i=0; i<row; i++)
	{
		*(r+i) = (char*)malloc(col);
		assert((char*)(*(r+i)) != NULL);
	}
	return r;
}

char** My2DAlloc_twice(int row, int col)
{
	char **r = NULL;
	char *c = NULL;
	int i = 0;
	
	if((row == 0) || (col == 0))
		return NULL;
	
	/* Allocate memory for row pointers */
	r = (char**)malloc(row*sizeof(char*));
	assert(r != NULL);
	c = (char*)malloc(row*col);
	assert(c != NULL);

	for(i=0; i<row; i++)
	{
		*(r+i) = (char*)(c + i*col);
	}
	return r;
}

char** My2DAlloc_once(int row, int col)
{
	char **r = NULL;
	char *loc = NULL;
	int i = 0;
	
	if((row == 0) || (col == 0))
		return NULL;
	
	/* Allocate memory for row pointers */
	r = (char**)malloc(row*sizeof(int*)+ row*col);
	assert(r != NULL);
	
	loc = r + row; //Addition of pointers advances bytes = num*sizeof(data type)

	for(i=0; i<row; i++)
	{
		*(r+i) = (char*)(loc + i*col);
	}
	return r;
}

itn **p=(int **)malloc(sizeof(int *)*r);
for(i=0;i<r;i++)
{
p[i]=(int *)mallco(sizeof(int)*c);
}

I have one question about these solutions. They all require more memory than the standard array. If one placed the following in a function

int array[20[3];
sizeof(array)

the 'sizeof' function would return the value 24. If one were then to add the following

printf ("testArray[0]= %x\n", &(testArray[0]) );
printf ("testArray[0][0]= %x\n", &(testArray[0][0]) );
printf ("testArray[1]= %x\n", &(testArray[1]) );
printf ("testArray[1][0]= %x\n", &(testArray[1][0]) );

one would find that the following two conditions to be true:

&(testArray[0]) == &(testArray[0][0])
&(testArray[1]) == &(testArray[1][0])

I cannot, however find a way to make these two conditions true when using the algorithms described here to setup an array in a segment of malloc'ed memory.

typedef int twodptr[2][2];

void func()
{
int *ptr = (int*)calloc(1, sizeof(int) * (2 * 2));
ptr[0] = 0; ptr[1] = 1; ptr[2] = 2; ptr[3] = 3;

twodptr *ptr2 = (twodptr*)ptr;

(*ptr2)[0][0] = 10;
(*ptr2)[0][1] = 11;
(*ptr2)[1][0] = 12;
(*ptr2)[1][1] = 13;

free (ptr);
}

This contains too many hard-coded values ... need a better alternative !!

typedef int arr[2][4];

int main(){
arr *ptr;
ptr=(arr *)malloc(sizeof(arr));
// now you can access the elements as
(*ptr)[0][1]=10;
// etc
return 0;
}

2d array:
1. using 2 malloc

int **p = (int**)malloc(sizeof(int*) * ROWS);
for(int i = 0;i<ROWS; i++)
  p[i] = (int*)malloc(sizeof(int) * COLS);

p[i][j] = p[i][j]
2. using 1 malloc

int *p = (int*)malloc(sizeof(int) * ROWS * COLS);

p[i][j] = *(p+i*COL+j);


for 3d array:

int ***p = (int***)malloc(sizeof(int**) * SET);
for(int i=0;i<SET;i++)
{
   p[i] = (int**)malloc(sizeof(int*) * ROWS);
   for(int j=0;j<ROWS;j++)
      p[i][j] = (int*)malloc(sizeof(int) * COL);
}

int **m=malloc(row*col*sizeof(int)+row*sizeof(int *);
for(i=0;i<row;i++)
m[i]=(int *)&m[row]+i*col;