allocating space for an array of integers

[Gattaca]

I would like to create a matrix[i][j] of integers by allocating memory
dynamically (malloc or calloc) because i and j are defined during
execution of the program.

I have got not problem to do this in the static way. For instance, if I
want to declare a matrix 20x10 of integers and then to access
matrix[15,8] element:
int matrix[20][10];
int a;

a=matrix[15][8];

But I havn't the clue to do it dynamically in case of i=20 and j=10.
int i,j,a;
i=20;j=10;

Thanks for your help,

Gattaca

[Case]

Gattaca wrote:

I would like to create a matrix[i][j] of integers by allocating memory
dynamically (malloc or calloc) because i and j are defined during
execution of the program.

I have got not problem to do this in the static way. For instance, if I
want to declare a matrix 20x10 of integers and then to access
matrix[15,8] element:
int matrix[20][10];
int a;

a=matrix[15][8];

But I havn't the clue to do it dynamically in case of i=20 and j=10.
int i,j,a;
i=20;j=10;

That would be:

int **matrix;

matrix = (int **)calloc(i * j, sizeof int);

a = matrix[15][8];

The C-FAQ, K&R and many other sources give more details
about other ways to this and other things related to multi-
dimentional arrays.

Case

[Pieter Droogendijk]

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

That would be:
Not in my book.
int **matrix;

matrix = (int **)calloc(i * j, sizeof int);
Besides the fact that you shouldn't cast here, and that sizeof int is a
syntax error (you must mean sizeof (int)), this allocates a continuous
block of memory i*j*sizeof(int) long, all pointers to pointers to int.
a = matrix[15][8];
matrix[15] may exist, but it's NULL.

#include <stdlib.h>
#include <stdio.h>

int main (void)
{
int i=20, j=10;
int count;
int **matrix;
matrix = malloc (sizeof*matrix* i);
if (matrix == NULL)
return EXIT_FAILURE;
for (count=0; count < i; count++) {
matrix[count] = malloc (sizeof*matrix[count]*j);
if (matrix[count] == NULL)
return EXIT_FAILURE;
}
matrix[15][8] = 10;
printf ("%d\n", matrix[15][8]);

for (count=0; count < i; count++)
free (matrix[count]);
free (matrix);
return 0;
}
The C-FAQ, K&R and many other sources give more details
about other ways to this and other things related to multi-
dimentional arrays.

Indeed.

--
int main(void){int putchar(int),i= 0;unsigned long t=500555079,n[]={t
,159418370,8892 1539,286883974, 80500161,0};whi le(n[i])putchar(*(!(t& 1
)+!(t||!++i)+"# \n")),(t&&1+(t> >=i-~-i))||(t=n[i]^n[i-1]);return 0;}

[Richard Bos]

Pieter Droogendijk <gi*@binky.home unix.org> wrote:

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

That would be:
Not in my book.

Nor in mine, but not entirely for the reasons you mention.

int **matrix;

matrix = (int **)calloc(i * j, sizeof int);

Besides the fact that you shouldn't cast here, and that sizeof int is a
syntax error (you must mean sizeof (int)), this allocates a continuous
block of memory i*j*sizeof(int) long, all pointers to pointers to int.

You were right up to the size of the block, but where do you get the
impression that a just allocated block of memory has a type of "all
pointers to pointers to int"? It's bytes, and how those bytes are
interpreted depends on the pointer you use to access it.
In this case, matrix is an int **. That means that *matrix is seen as an
int *, not as an int **. You could just as easily have assigned the
result of the calloc() call to an unsigned char *, and treated all bytes
as unsigned chars.

a = matrix[15][8];

matrix[15] may exist, but it's NULL.

No - it's all bits zero, which is not necessarily the same thing. This
is one reason why calloc() is less useful than malloc() - you can't
reliably use it for anything but integer types. For pointers and
floating point types, all bits zero is not necessarily an interesting
value.
#include <stdlib.h>
#include <stdio.h>

int main (void)
{
int i=20, j=10;
int count;
int **matrix;
matrix = malloc (sizeof*matrix* i);

Rather obfuscatory use of whitespace there, I think. It'd be clearer as

matrix=malloc(s izeof *matrix * i);

or even better

matrix=malloc(i * sizeof *matrix);

No more comments on your code, except that in a non-toy program, you
need to be more careful about what happens on malloc() error.

Richard

[Pieter Droogendijk]

On Mon, 24 May 2004 11:17:38 +0000, Richard Bos wrote:
7> Pieter Droogendijk <gi*@binky.home unix.org> wrote:

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

You were right up to the size of the block, but where do you get the
impression that a just allocated block of memory has a type of "all
pointers to pointers to int"? It's bytes, and how those bytes are
interpreted depends on the pointer you use to access it.
Pardon the odd wording. I was indeed referring to the way the memory just
allocated is going to be used.
matrix[15] may exist, but it's NULL.

No - it's all bits zero, which is not necessarily the same thing. This
is one reason why calloc() is less useful than malloc() - you can't
reliably use it for anything but integer types. For pointers and
floating point types, all bits zero is not necessarily an interesting
value.

Agreed. This hit me after pressing send, regrettably.

matrix = malloc (sizeof*matrix* i);

Rather obfuscatory use of whitespace there, I think. It'd be clearer as

matrix=malloc(s izeof *matrix * i);

or even better

matrix=malloc(i * sizeof *matrix);

Agreed as well, heh. Bad habit.
No more comments on your code, except that in a non-toy program, you
need to be more careful about what happens on malloc() error.

Naturally. But since this is not a non-toy program... :P

--
int main(void){int putchar(int),i= 0;unsigned long t=500555079,n[]={t
,159418370,8892 1539,286883974, 80500161,0};whi le(n[i])putchar(*(!(t& 1
)+!(t||!++i)+"# \n")),(t&&1+(t> >=i-~-i))||(t=n[i]^n[i-1]);return 0;}

[Case]

Pieter Droogendijk wrote:

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

That would be:

Not in my book.

int **matrix;

matrix = (int **)calloc(i * j, sizeof int);

Besides the fact that you shouldn't cast here, and that sizeof int is a
syntax error (you must mean sizeof (int)), this allocates a continuous
block of memory i*j*sizeof(int) long, all pointers to pointers to int.

You are right! I acted as if answering this question was a no-brainer
and seemingly it's been too long ago I worked with MD arrays or read the
FAQ.

BTW, the FAQ (Q6.16) does use a cast:

int **array1 = (int **)malloc(nrows * sizeof(int *));

Why do you think there should be none?

I'll think a bit longer next time when I answer a question right before
running off for lunch. Oops.

Case

[Pieter Droogendijk]

On Mon, 24 May 2004 13:33:50 +0200, Case wrote:

Pieter Droogendijk wrote:

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

You are right! I acted as if answering this question was a no-brainer
and seemingly it's been too long ago I worked with MD arrays or read the
FAQ.
No worries ;)
BTW, the FAQ (Q6.16) does use a cast:

int **array1 = (int **)malloc(nrows * sizeof(int *));

Why do you think there should be none?

Because it may mask undefined behaviour if you forget to include stdlib.h.
If that's the case, malloc() will be implicitly declared to return int,
but you tell your compiler "No, it's (int**), I know what I'm doing better
than you", so even if it was going to produce a diagnostic, it won't.

--
int main(void){int putchar(int),i= 0;unsigned long t=500555079,n[]={t
,159418370,8892 1539,286883974, 80500161,0};whi le(n[i])putchar(*(!(t& 1
)+!(t||!++i)+"# \n")),(t&&1+(t> >=i-~-i))||(t=n[i]^n[i-1]);return 0;}

[Case]

Pieter Droogendijk wrote:

On Mon, 24 May 2004 13:33:50 +0200, Case wrote:

Pieter Droogendijk wrote:

On Mon, 24 May 2004 12:41:57 +0200, Case wrote:

You are right! I acted as if answering this question was a no-brainer
and seemingly it's been too long ago I worked with MD arrays or read the
FAQ.

No worries ;)

BTW, the FAQ (Q6.16) does use a cast:

int **array1 = (int **)malloc(nrows * sizeof(int *));

Why do you think there should be none?

Because it may mask undefined behaviour if you forget to include stdlib.h.
If that's the case, malloc() will be implicitly declared to return int,
but you tell your compiler "No, it's (int**), I know what I'm doing better
than you", so even if it was going to produce a diagnostic, it won't.

Good point. Any ideas why the FAQ still uses a cast?

Kees

[Pieter Droogendijk]

On Mon, 24 May 2004 13:45:25 +0200, Case wrote:

Pieter Droogendijk wrote: Good point. Any ideas why the FAQ still uses a cast?

Good question, and not one I can answer.

--
int main(void){int putchar(int),i= 0;unsigned long t=500555079,n[]={t
,159418370,8892 1539,286883974, 80500161,0};whi le(n[i])putchar(*(!(t& 1
)+!(t||!++i)+"# \n")),(t&&1+(t> >=i-~-i))||(t=n[i]^n[i-1]);return 0;}

[Al Bowers]

Gattaca wrote:

I would like to create a matrix[i][j] of integers by allocating memory
dynamically (malloc or calloc) because i and j are defined during
execution of the program.

I have got not problem to do this in the static way. For instance, if I
want to declare a matrix 20x10 of integers and then to access
matrix[15,8] element:
int matrix[20][10];
int a;

a=matrix[15][8];

But I havn't the clue to do it dynamically in case of i=20 and j=10.
int i,j,a;
i=20;j=10;

I take that you want to dymanically allocate a matrix and then
possibly later in the program modify the dimensions. Do do this
you can use one of the 2d allocation routines mentioned in the
faq. On reallocation, I presume you want to keep all the values
in the previous allocation that are possible. I would create
a struct datatype that has as members, pointer to the matrix array,
size of the columns and size of the rows. Write functions to
manipulate this datatype.

Example (untested)

#include <stdio.h>
#include <stdlib.h>

typedef struct MATRIX
{
int **matrix;
unsigned row;
unsigned col;
} MATRIX;

void FreeMatrix(MATR IX *p);
int ReallocMatrix(M ATRIX *p, unsigned rows, unsigned cols);
void PrintMatrix(MAT RIX *p);
void ExitMatrix(MATR IX *p, const char *remarks);

int main(void)
{
MATRIX mymatrix = {NULL};
unsigned i, j;

if(!ReallocMatr ix(&mymatrix,2, 3))
ExitMatrix(&mym atrix,"Allocati on failure, Exiting...");
for(i = 0; i < mymatrix.row;i+ +)
for(j = 0; j < mymatrix.col; j++)
mymatrix.matrix[i][j] = i+j*10;
puts("Matrix 2x3");
PrintMatrix(&my matrix);
puts("\nEnlargi ng to 3x3");
if(!ReallocMatr ix(&mymatrix,3, 3))
ExitMatrix(&mym atrix,"Allocati on failure, Exiting...");
PrintMatrix(&my matrix);
puts("\nReducin g to 1x2");
if(!ReallocMatr ix(&mymatrix,1, 2))
ExitMatrix(&mym atrix,"Allocati on failure, Exiting...");
PrintMatrix(&my matrix);
if(!ReallocMatr ix(&mymatrix,23 000,23000)) /* Attempt failure */
ExitMatrix(&mym atrix,"Allocati on failure, Exiting...");
FreeMatrix(&mym atrix);
return 0;
}

void FreeMatrix(MATR IX *p)
{
free(p->matrix[0]);
free(p->matrix);
p->matrix = NULL;
p->row = p->col = 0;
return;
}

int ReallocMatrix(M ATRIX *p, unsigned rows, unsigned cols)
{
int **tmp;
unsigned i,j;

if(p == NULL || rows == 0 || cols == 0) return 0;
if((tmp = malloc(rows * (sizeof *tmp))) == NULL) return 0;
if((tmp[0] = malloc(rows * cols * (sizeof **tmp))) == NULL)
{
free(tmp);
return 0;
}
for(i = 0; i < rows; i++)
{
tmp[i] = tmp[0] + i * cols;
for(j = 0;j < cols;j++)
if(i < p->row && j < p->col)
tmp[i][j] = p->matrix[i][j];
else tmp[i][j] = 0;
}
free(p->matrix);
p->matrix = tmp;
p->row = rows;
p->col = cols;
return 1;
}

void PrintMatrix(MAT RIX *p)
{
unsigned i,j;

for(i = 0;i < p->row;i++)
{
for(j = 0; j < p->col;j++)
printf("%-4d",p->matrix[i][j]);
putchar('\n');
}
putchar('\n');
return;
}

void ExitMatrix(MATR IX *p, const char *remarks)
{
FreeMatrix(p);
if(remarks) puts(remarks);
exit(EXIT_FAILU RE);
}


--
Al Bowers
Tampa, Fl USA
mailto: xa******@myrapi dsys.com (remove the x to send email)
http://www.geocities.com/abowers822/