Thread: 2D array and pointer( crash exe)

You are not correctly allocating your 2d pointer. Why are you trying to implement this anyway? Look the easiest way to do this in one shot is to use malloc(row*column*sizeof(int)). Additionally, this is C not C++. You do not need to cast the return of malloc, read about it here.

You are using a very old programming style. For this program you should be using stdio.h and stdlib.h I suggest you read some tutorials.

My guess is you're trying to allocate a 2d array so that you can access it using: array[i][j] ?

If you want to do this you can try the following:

Code:

Ex) 
 
  int i, j;
  int rows = 7;
  int columns = 7;
  int ** array = NULL;

  array = malloc( rows * sizeof( int *) );

  if( array != NULL){
    for(i=0; i< rows; i++){
      array[i] = malloc( columns * sizeof( int ) );
    }
  }
  else{
    printf("Array couldn't be allocated.");
  }

First, you declare array, a pointer capable of pointing to an int pointer. Then you malloc such that array points to rows int pointers. Using the for loop, each of these int pointers points to columns integers.

Note that the first malloc call uses sizeof(int * ) and the subsequent calls use sizeof( int ).

It's more code to set it up this way, but you can access elements via array[i][j] if that's what you want. It need not be a square array for this to work, meaning rows need not equal columns as it does in the example.

You might find the graphic here useful:

http://c-faq.com/~scs/cclass/int/sx9b.html

If you do use the double pointer method, make sure you follow the instructions for free() at the above link. If you do it wrong, you'll lose reference to memory that is not actually freed.

Also, as AH said this can be done with a 1D array, and accessing the "i,j th" entry using a single index is a simple relationship. Though sometimes, it is nice to be able to access elements using i,j notation as we would in linear algebra.

1. You first malloc call needs to be of int* not int. Additionally the way you are describing is overly complicated since each column would have to be freed individually to prevent a memory leak. The only reason to implement it this way is if you do not know the size until runtime. However for this case it is better to simply make an extremely large array that is capable of holding whatever you may need, e.g. max case scenario.

2. You can access any array via array[i][j] by one malloc call malloc(rows*columns*sizeof(int)) as I stated above. This has the advantage of only requiring one free call.

Thank you for expanding on that tabstop.

Originally Posted by AndrewHunter

2. You can access any array via array[i][j] by one malloc call malloc(rows*columns*sizeof(int)) as I stated above. This has the advantage of only requiring one free call.

I'm with you on the free() advantages, but I just want to clarify one thing. Maybe i'm misunderstanding you, but when I use the declaration

Code:

int * ptrArray = malloc( 3 * 3 * sizeof( int) );

any attempt to reference its contents by ptrArray[][] (that is using two separate indices) results in a compilation error. Of course one could use ptrArray[rows*i + j]. Is this what you meant?

EDIT: I guess maybe tabstop can help clarify

Tabstop , when you wrote

[NOTE for the pedantic: it is possible to get two sets of brackets out of one malloc call, but the row lengths have to be the same and known at compile time.]

Do you mean that columns = rows, or that each row must be of the same length ( ie not a jagged array)? Do you perhaps have a code snippet using only one malloc call followed by array[i][j] use?

I misspoke and tabstop was pointing that out. You are correct on the way to access the array. The topic is explained quite clearly in C-FAQ 6.16