C Tutor... C Tutorial....: November 2008

There are times when it is convenient to allocate memory at run time using malloc(), calloc(), or other allocation functions. Using this approach permits postponing the decision on the size of the memory block need to store an array, for example, until run time. Or it permits using a section of memory for the storage of an array of integers at one point in time, and then when that memory is no longer needed it can be freed up for other uses, such as the storage of an array of structures.

When memory is allocated, the allocating function (such as malloc(), calloc(), etc.) returns a pointer. The type of this pointer depends on whether you are using an older K&R compiler or the newer ANSI type compiler. With the older compiler the type of the returned pointer is char, with the ANSI compiler it is void.

If you are using an older compiler, and you want to allocate memory for an array of integers you will have to cast the char pointer returned to an integer pointer. For example, to allocate space for 10 integers we might write:

    int *iptr;
   iptr = (int *)malloc(10 * sizeof(int));
   if (iptr == NULL)

   { .. ERROR ROUTINE GOES HERE .. }

If you are using an ANSI compliant compiler, malloc() returns a void pointer and since a void pointer can be assigned to a pointer variable of any object type, the (int *) cast shown above is not needed. The array dimension can be determined at run time and is not needed at compile time. That is, the 10 above could be a variable read in from a data file or keyboard, or calculated based on some need, at run time.

Because of the equivalence between array and pointer notation, once iptr has been assigned as above, one can use the array notation. For example, one could write:

    int k;
   for (k = 0; k < 10; k++)
      iptr[k] = 2;

to set the values of all elements to 2.

Even with a reasonably good understanding of pointers and arrays, one place the newcomer to C is likely to stumble at first is in the dynamic allocation of multi-dimensional arrays. In general, we would like to be able to access elements of such arrays using array notation, not pointer notation, wherever possible. Depending on the application we may or may not know both dimensions at compile time. This leads to a variety of ways to go about our task.

As we have seen, when dynamically allocating a one dimensional array its dimension can be determined at run time. Now, when using dynamic allocation of higher order arrays, we never need to know the first dimension at compile time. Whether we need to know the higher dimensions depends on how we go about writing the code. Here I will discuss various methods of dynamically allocating room for 2 dimensional arrays of integers.

First we will consider cases where the 2nd dimension is known at compile time.

METHOD 1:

One way of dealing with the problem is through the use of the typedef keyword. To allocate a 2 dimensional array of integers recall that the following two notations result in the same object code being generated:

    multi[row][col] = 1;     *(*(multi + row) + col) = 1;

It is also true that the following two notations generate the same code:

    multi[row]            *(multi + row)

Since the one on the right must evaluate to a pointer, the array notation on the left must also evaluate to a pointer. In fact multi[0] will return a pointer to the first integer in the first row, multi[1] a pointer to the first integer of the second row, etc. Actually, multi[n] evaluates to a pointer to that array of integers that make up the n-th row of our 2 dimensional array. That is, multi can be thought of as an array of arrays and multi[n] as a pointer to the n-th array of this array of arrays. Here the word pointer is being used to represent an address value. While such usage is common in the literature, when reading such statements one must be careful to distinguish between the constant address of an array and a variable pointer which is a data object in itself.

Consider now:

--------------- Program  --------------------------------


#include 
#include 

#define COLS 5

typedef int RowArray[COLS];
RowArray *rptr;

int main(void)
{
   int nrows = 10;
   int row, col;
   rptr = malloc(nrows * COLS * sizeof(int));
   for (row = 0; row < nrows; row++)
   {
       for (col = 0; col < COLS; col++)
       {
           rptr[row][col] = 17;
       }
   }

   return 0;
}
------------- End of Prog. --------------------------------

Here I have assumed an ANSI compiler so a cast on the void pointer returned by malloc() is not required. If you are using an older K&R compiler you will have to cast using:

    rptr = (RowArray *)malloc(.... etc.

Using this approach, rptr has all the characteristics of an array name name, (except that rptr is modifiable), and array notation may be used throughout the rest of the program. That also means that if you intend to write a function to modify the array contents, you must use COLS as a part of the formal parameter in that function, just as we did when discussing the passing of two dimensional arrays to a function.

METHOD 2:

In the METHOD 1 above, rptr turned out to be a pointer to type "one dimensional array of COLS integers". It turns out that there is syntax which can be used for this type without the need of typedef. If we write:

    int (*xptr)[COLS];

the variable xptr will have all the same characteristics as the variable rptr in METHOD 1 above, and we need not use the typedef keyword. Here xptr is a pointer to an array of integers and the size of that array is given by the #defined COLS. The parenthesis placement makes the pointer notation predominate, even though the array notation has higher precedence. i.e. had we written

    int *xptr[COLS];

we would have defined xptr as an array of pointers holding the number of pointers equal to that #defined by COLS. That is not the same thing at all. However, arrays of pointers have their use in the dynamic allocation of two dimensional arrays, as will be seen in the next 2 methods.

METHOD 3:

Consider the case where we do not know the number of elements in each row at compile time, i.e. both the number of rows and number of columns must be determined at run time. One way of doing this would be to create an array of pointers to type int and then allocate space for each row and point these pointers at each row. Consider:

-------------- Program  ------------------------------------



#include 
#include 

int main(void)
{
   int nrows = 5;     /* Both nrows and ncols could be evaluated */
   int ncols = 10;    /* or read in at run time */
   int row;
   int **rowptr;
   rowptr = malloc(nrows * sizeof(int *));
   if (rowptr == NULL)
   {
       puts("\nFailure to allocate room for row pointers.\n");
       exit(0);
   }

   printf("\n\n\nIndex   Pointer(hex)   Pointer(dec)   Diff.(dec)");

   for (row = 0; row < nrows; row++)
   {
       rowptr[row] = malloc(ncols * sizeof(int));
       if (rowptr[row] == NULL)
       {
           printf("\nFailure to allocate for row[%d]\n",row);
           exit(0);
       }
       printf("\n%d         %p         %d", row, rowptr[row], rowptr[row]);
       if (row > 0)
       printf("              %d",(int)(rowptr[row] - rowptr[row-1]));
   }

   return 0;
}

--------------- End  ------------------------------------

In the above code rowptr is a pointer to pointer to type int. In this case it points to the first element of an array of pointers to type int. Consider the number of calls to malloc():

    To get the array of pointers             1     call
   To get space for the rows                5     calls
                                         -----
                    Total                   6     calls

If you choose to use this approach note that while you can use the array notation to access individual elements of the array, e.g. rowptr[row][col] = 17;, it does not mean that the data in the "two dimensional array" is contiguous in memory.

You can, however, use the array notation just as if it were a continuous block of memory. For example, you can write:

    rowptr[row][col] = 176;

just as if rowptr were the name of a two dimensional array created at compile time. Of course row and col must be within the bounds of the array you have created, just as with an array created at compile time.

If you want to have a contiguous block of memory dedicated to the storage of the elements in the array you can do it as follows:

METHOD 4:

In this method we allocate a block of memory to hold the whole array first. We then create an array of pointers to point to each row. Thus even though the array of pointers is being used, the actual array in memory is contiguous. The code looks like this:

----------------- Program -----------------------------------


#include 
#include 

int main(void)
{
   int **rptr;
   int *aptr;
   int *testptr;
   int k;
   int nrows = 5;     /* Both nrows and ncols could be evaluated */
   int ncols = 8;    /* or read in at run time */
   int row, col;

   /* we now allocate the memory for the array */

   aptr = malloc(nrows * ncols * sizeof(int));
   if (aptr == NULL)
   {
       puts("\nFailure to allocate room for the array");
       exit(0);
   }

   /* next we allocate room for the pointers to the rows */

   rptr = malloc(nrows * sizeof(int *));
   if (rptr == NULL)
   {
       puts("\nFailure to allocate room for pointers");
       exit(0);
   }

   /* and now we 'point' the pointers */

   for (k = 0; k < nrows; k++)
   {
       rptr[k] = aptr + (k * ncols);
   }

   /* Now we illustrate how the row pointers are incremented */
   printf("\n\nIllustrating how row pointers are incremented");
   printf("\n\nIndex   Pointer(hex)  Diff.(dec)");

   for (row = 0; row < nrows; row++)
   {
       printf("\n%d         %p", row, rptr[row]);
       if (row > 0)
       printf("              %d",(rptr[row] - rptr[row-1]));
   }
   printf("\n\nAnd now we print out the array\n");
   for (row = 0; row < nrows; row++)
   {
       for (col = 0; col < ncols; col++)
       {
           rptr[row][col] = row + col;
           printf("%d ", rptr[row][col]);
       }
       putchar('\n');
   }

   puts("\n");

   /* and here we illustrate that we are, in fact, dealing with
      a 2 dimensional array in a contiguous block of memory. */
   printf("And now we demonstrate that they are contiguous in memory\n");

   testptr = aptr;
   for (row = 0; row < nrows; row++)
   {
       for (col = 0; col < ncols; col++)
       {
           printf("%d ", *(testptr++));
       }
       putchar('\n');
   }

   return 0;
}




------------- End Program -----------------

Consider again, the number of calls to malloc()

    To get room for the array itself      1      call
   To get room for the array of ptrs     1      call
                                       ----
                        Total            2      calls

Now, each call to malloc() creates additional space overhead since malloc() is generally implemented by the operating system forming a linked list which contains data concerning the size of the block. But, more importantly, with large arrays (several hundred rows) keeping track of what needs to be freed when the time comes can be more cumbersome. This, combined with the contiguousness of the data block that permits initialization to all zeroes using memset() would seem to make the second alternative the preferred one.

As a final example on multidimensional arrays we will illustrate the dynamic allocation of a three dimensional array. This example will illustrate one more thing to watch when doing this kind of allocation. For reasons cited above we will use the approach outlined in alternative two. Consider the following code:

------------------- Program -------------------------------------

/* Program */

#include 
#include 
#include 

int X_DIM=16;
int Y_DIM=5;
int Z_DIM=3;

int main(void)
{
   char *space;
   char ***Arr3D;
   int y, z;
   ptrdiff_t diff;

   /* first we set aside space for the array itself */

   space = malloc(X_DIM * Y_DIM * Z_DIM * sizeof(char));

   /* next we allocate space of an array of pointers, each
      to eventually point to the first element of a
      2 dimensional array of pointers to pointers */

   Arr3D = malloc(Z_DIM * sizeof(char **));

   /* and for each of these we assign a pointer to a newly
      allocated array of pointers to a row */

   for (z = 0; z < Z_DIM; z++)
   {
       Arr3D[z] = malloc(Y_DIM * sizeof(char *));

       /* and for each space in this array we put a pointer to
          the first element of each row in the array space
          originally allocated */

       for (y = 0; y < Y_DIM; y++)
       {
           Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM);
       }
   }

   /* And, now we check each address in our 3D array to see if
      the indexing of the Arr3d pointer leads through in a
      continuous manner */

   for (z = 0; z < Z_DIM; z++)
   {
       printf("Location of array %d is %p\n", z, *Arr3D[z]);
       for ( y = 0; y < Y_DIM; y++)
       {
           printf("  Array %d and Row %d starts at %p", z, y, Arr3D[z][y]);
           diff = Arr3D[z][y] - space;
           printf("    diff = %d  ",diff);
           printf(" z = %d  y = %d\n", z, y);
       }
   }
   return 0;
}

------------------- End of Prog.----------------------------

If you have followed this tutorial up to this point you should have no problem deciphering the above on the basis of the comments alone. There are a couple of points that should be made however. Let's start with the line which reads:

    Arr3D[z][y] = space + (z*(X_DIM * Y_DIM) + y*X_DIM);

Note that here space is a character pointer, which is the same type as Arr3D[z][y]. It is important that when adding an integer, such as that obtained by evaluation of the expression (z*(X_DIM * Y_DIM) + y*X_DIM), to a pointer, the result is a new pointer value. And when assigning pointer values to pointer variables the data types of the value and variable must match.

Related Links :

Pointers and Strings

The study of strings is useful to further tie in the relationship between pointers and arrays. It also makes it easy to illustrate how some of the standard C string functions can be implemented. Finally it illustrates how and when pointers can and should be passed to functions.

In C, strings are arrays of characters. This is not necessarily true in other languages. In BASIC, Pascal, Fortran and various other languages, a string has its own data type. But in C it does not. In C a string is an array of characters terminated with a binary zero character (written as '\0'). To start off our discussion we will write some code which, while preferred for illustrative purposes, you would probably never write in an actual program. Consider, for example:

    char my_string[40];

   my_string[0] = 'T';
   my_string[1] = 'e';
   my_string[2] = 'd':
   my_string[3] = '\0';

While one would never build a string like this, the end result is a string in that it is an array of characters terminated with a nul character. By definition, in C, a string is an array of characters terminated with the nul character. Be aware that "nul" is not the same as "NULL". The nul refers to a zero as defined by the escape sequence '\0'. That is it occupies one byte of memory. NULL, on the other hand, is the name of the macro used to initialize null pointers. NULL is #defined in a header file in your C compiler, nul may not be #defined at all.

Since writing the above code would be very time consuming, C permits two alternate ways of achieving the same thing. First, one might write:

    char my_string[40] = {'T', 'e', 'd', '\0',};

But this also takes more typing than is convenient. So, C permits:

    char my_string[40] = "Ted";

When the double quotes are used, instead of the single quotes as was done in the previous examples, the nul character ( '\0' ) is automatically appended to the end of the string.

In all of the above cases, the same thing happens. The compiler sets aside an contiguous block of memory 40 bytes long to hold characters and initialized it such that the first 4 characters are Ted\0.

Now, consider the following program:

------------------program 3.1-------------------------------------

/* Program 3.1 from PTRTUT10.HTM   6/13/97 */

#include 

char strA[80] = "A string to be used for demonstration purposes";
char strB[80];

int main(void)
{

   char *pA;     /* a pointer to type character */
   char *pB;     /* another pointer to type character */
   puts(strA);   /* show string A */
   pA = strA;    /* point pA at string A */
   puts(pA);     /* show what pA is pointing to */
   pB = strB;    /* point pB at string B */
   putchar('\n');       /* move down one line on the screen */
   while(*pA != '\0')   /* line A (see text) */
   {
       *pB++ = *pA++;   /* line B (see text) */
   }
   *pB = '\0';          /* line C (see text) */
   puts(strB);          /* show strB on screen */
   return 0;
}

--------- end program 3.1 -------------------------------------

In the above we start out by defining two character arrays of 80 characters each. Since these are globally defined, they are initialized to all '\0's first. Then, strA has the first 42 characters initialized to the string in quotes.

Now, moving into the code, we declare two character pointers and show the string on the screen. We then "point" the pointer pA at strA. That is, by means of the assignment statement we copy the address of strA[0] into our variable pA. We now use puts() to show that which is pointed to by pA on the screen. Consider here that the function prototype for puts() is:

    int puts(const char *s);

For the moment, ignore the const. The parameter passed to puts() is a pointer, that is the value of a pointer (since all parameters in C are passed by value), and the value of a pointer is the address to which it points, or, simply, an address. Thus when we write puts(strA); as we have seen, we are passing the address of strA[0].

Similarly, when we write puts(pA); we are passing the same address, since we have set pA = strA;

Given that, follow the code down to the while() statement on line A. Line A states:

While the character pointed to by pA (i.e. *pA) is not a nul character (i.e. the terminating '\0'), do the following:

Line B states: copy the character pointed to by pA to the space pointed to by pB, then increment pA so it points to the next character and pB so it points to the next space.

When we have copied the last character, pA now points to the terminating nul character and the loop ends. However, we have not copied the nul character. And, by definition a string in C must be nul terminated. So, we add the nul character with line C.

It is very educational to run this program with your debugger while watching strA, strB, pA and pB and single stepping through the program. It is even more educational if instead of simply defining strB[] as has been done above, initialize it also with something like:

    strB[80] = "12345678901234567890123456789012345678901234567890"

where the number of digits used is greater than the length of strA and then repeat the single stepping procedure while watching the above variables. Give these things a try!

Getting back to the prototype for puts() for a moment, the "const" used as a parameter modifier informs the user that the function will not modify the string pointed to by s, i.e. it will treat that string as a constant.

Of course, what the above program illustrates is a simple way of copying a string. After playing with the above until you have a good understanding of what is happening, we can proceed to creating our own replacement for the standard strcpy() that comes with C. It might look like:

   char *my_strcpy(char *destination, char *source)
  {
      char *p = destination;
      while (*source != '\0')
      {
          *p++ = *source++;
      }
      *p = '\0';
      return destination;
  }

In this case, I have followed the practice used in the standard routine of returning a pointer to the destination.

Again, the function is designed to accept the values of two character pointers, i.e. addresses, and thus in the previous program we could write:

    int main(void)
   {
       my_strcpy(strB, strA);
       puts(strB);
   }

I have deviated slightly from the form used in standard C which would have the prototype:

    char *my_strcpy(char *destination, const char *source);

Here the "const" modifier is used to assure the user that the function will not modify the contents pointed to by the source pointer. You can prove this by modifying the function above, and its prototype, to include the "const" modifier as shown. Then, within the function you can add a statement which attempts to change the contents of that which is pointed to by source, such as:

    *source = 'X';

which would normally change the first character of the string to an X. The const modifier should cause your compiler to catch this as an error. Try it and see.

Now, let's consider some of the things the above examples have shown us. First off, consider the fact that *ptr++ is to be interpreted as returning the value pointed to by ptr and then incrementing the pointer value. This has to do with the precedence of the operators. Were we to write (*ptr)++ we would increment, not the pointer, but that which the pointer points to! i.e. if used on the first character of the above example string the 'T' would be incremented to a 'U'. You can write some simple example code to illustrate this.

Recall again that a string is nothing more than an array of characters, with the last character being a '\0'. What we have done above is deal with copying an array. It happens to be an array of characters but the technique could be applied to an array of integers, doubles, etc. In those cases, however, we would not be dealing with strings and hence the end of the array would not be marked with a special value like the nul character. We could implement a version that relied on a special value to identify the end. For example, we could copy an array of positive integers by marking the end with a negative integer. On the other hand, it is more usual that when we write a function to copy an array of items other than strings we pass the function the number of items to be copied as well as the address of the array, e.g. something like the following prototype might indicate:

    void int_copy(int *ptrA, int *ptrB, int nbr);

where nbr is the number of integers to be copied. You might want to play with this idea and create an array of integers and see if you can write the function int_copy() and make it work.

This permits using functions to manipulate large arrays. For example, if we have an array of 5000 integers that we want to manipulate with a function, we need only pass to that function the address of the array (and any auxiliary information such as nbr above, depending on what we are doing). The array itself does not get passed, i.e. the whole array is not copied and put on the stack before calling the function, only its address is sent.

This is different from passing, say an integer, to a function. When we pass an integer we make a copy of the integer, i.e. get its value and put it on the stack. Within the function any manipulation of the value passed can in no way effect the original integer. But, with arrays and pointers we can pass the address of the variable and hence manipulate the values of the original variables.

History Of C..

In the beginning was Charles Babbage and his Analytical Engine, a machine
he built in 1822 that could be programmed to carry out different computations.
Move forward more than 100 years, where the U.S. government in
1942 used concepts from Babbage’s engine to create the ENIAC, the first
modern computer.
Meanwhile, over at the AT&T Bell Labs, in 1972 Dennis Ritchie was working
with two languages: B (for Bell) and BCPL (Basic Combined Programming
Language). Inspired by Pascal, Mr. Ritchie developed the C programming
language.

METHOD 1:

METHOD 2:

METHOD 3:

METHOD 4:

Related Links :

Multi-Dimensional Arrays

Related Links :

Pointers and Strings

Related Links :

Bubble sort [linked list]

Related Links :

convert upper case to lower case or lower case

Related Links :

Finding LCM and GCD In C

Related Links :

INTERVIEW QUESTIONS C

Related Links :

Bubble Sorting Algorithm

Related Links :

All types of Linked List Operations

Related Links :

History Of C..

My 1st Program...

Next Step...

Hits!!!

Follow Us..Lets Create World Of Programming...

Get Programs & Updates By Mail...Just Enter Your Email ID...

More Programs...

Share This Blog With Your Friends.

About Us..

More On C

Latest Updates