Intro to Memory and Arrays in C

I wrote a C language tutorial for Cocoa Dev Central a ways back, but I didn't get into arrays or memory to keep the tutorial approachable. I'll write a formal follow-up soon, but I decided to post has some raw materials in the meantime, if just to get corrections in early. So here's a whirlwind tour of arrays and basic C memory. The next entry will discuss more advanced memory techniques.

If you're not already comfortable with basic C syntax, I strongly recommend reading the C Language Tutorial for Cocoa at Cocoa Dev Central first.

Basic Memory
  
The common unit of measurement for memory is the byte. Each type of variable in C consumes a certain number of bytes. For example, a standard int variable generally needs 4 bytes of memory. This can, however, vary by OS, processor, and so on. Anyway, let's say I declare a simple int variable:

int monstersUnderBed;

On a G4 running Tiger, this variable uses 4 bytes of memory. This memory can come from one of two places: the data segment or the stack. These terms aren't exactly intuitive, but the difference is incredibly simple.

If a variable is declared outside of a function, it is typically considered "global," meaning that any function can access it. Global variables are stored in a special area in the program's memory called the data segment. This memory is in use for as long as the program is running.

The stack is used to store variables that are only used inside of a function. Stack memory is temporary. Once a function finishes running, all of the memory for its variables is freed. This cycle happens each time the function is called. There is an exception to this, but we're not there quite yet.

Here's a simple program that uses both a global variable and a stack variable (I need something to count and I just watched Monsters, Inc. the other night, thus the monsters):

#include <stdio.h>
  
// this global variable resides in the data segment
int globalMonsters = 2;

void addFourMonsters ()
{
  // this variable uses memory in the stack
  int stackMonsters = 4;

  // we add the value of the stack variable
  // to the global variable
  globalMonsters += stackMonsters;  
}

main ()
{
  printf ("Global monsters: %i\n", globalMonsters);
  addFourMonsters();  
  printf ("Global monsters: %i\n", globalMonsters);
  addFourMonsters();  
  printf ("Global monsters: %i\n", globalMonsters);
}

This gives us some output like this:

Global monsters: 2
Global monsters: 6
Global monsters: 10

All that's going on here is we're creating a stackMonsters variable and adding the value of it to the globalMonsters variable. Not rocket science.

Simple values like ints, floats and single char variables don't need any special management. They'll automatically be cleaned up at the end of the function or when the program exits.

Arrays

If you're used to Cocoa's NSArray class or arrays in a scripting language like JavaScript, you'll be amazed at how primitive C's arrays are. They're literally just a series of individual values. In a basic case, you create an array of a fixed size, like this:

int myIntArray[5];

This declares an array which holds five integer values, so it takes as much memory as five individual ints:

int (4 bytes) x 5 = 20 bytes

The C language doesn't provide any way to resize basic arrays. You can do it manually, but it requires a slightly more advanced understanding of C memory management that we haven't touched on yet.

There are libraries that will do array management for you (and C++ has its own solution), but the basic C array is the one that's used most widely. Setting values in an array is dead simple:

int myArray[5];
myArray[0] = 99;
myArray[1] = 120;
myArray[2] = 22;
myArray[3] = 8287;
myArray[4] = 0;

Although you can't change the size of the array, you can change the values of arrays element at any time, in any order. It doesn't have to be sequential as shown above.

Loops for Processing Arrays

Once you have an array, you can use a loop to easily process it. The following code creates a five-element array in stack memory, and sets a random value for each slot.

#include <stdio.h>
#include <time.h>

#define COUNT 5

main ()
{
  // seed the random number generator with the
  // current time to get the ball rolling
  
  srand( time(NULL) );
  
  // this array uses stack memory because it's
  // declared inside of a function. The array
  // size is set by the COUNT constant
  
  int stackArray[COUNT];
  int i;
  
  // loop through and insert a random value
  // returned from the rand() function
    
  for ( i = 0; i < COUNT; i ++ ) {
    stackArray[i] = rand();
  }
  
  // loop through and print out the values at
  // each slot in the array
  
  for ( i = 0; i < COUNT; i ++ ) {
    printf ("Value %i: %i\n", i, stackArray[i]);
  }
}

This gives us output similar to following (remember, the values are random):

Value 0: 204319905
Value 1: 178291782
Value 2: 810292509
Value 3: 1392393136
Value 4: 822135393

The stackArray variable uses stack memory, so the cleanup is automatic. The memory will be freed when the function ends.

An array doesn't have to be of a predetermined size. A relatively recent advancement in common C programming is the "variable length array." I haven't run any statistics, but my guess is that a number of C books on the shelves today probably don't actually mention this technique.

The basic idea behind variable length arrays is that the size of the array can be determined on the fly. For example, here's a simple program that creates an array of a random size:

#include <stdio.h>
#include <time.h>

main ()
{
  // seed the random number generator with the
  // current time, then get a random number
  
  srand(time(NULL));
  int randomNumber = rand() % 100;

  // create an array of a random size
  
  int myArray[randomNumber];  
  printf("Array size: %i slots\n", randomNumber);
}

The output is something like this:

Array size: 63 slots

This may seem like no big deal if you're used to scripting languages, but given that C is a lower-level language, this is pretty cool.

C Strings Are Arrays

In C, a string is an array of char values. As a result, it has to follow all the rules of an array. Here's a simple example:

char siteName[10] = "Theocacao";

What might be surprising here is that I made a ten element array, even though the word "Theocacao" is only nine characters. In C, a string has to be "capped" with a special null character: '\0'. This is known as a "null-terminated string". If you build up the string one character at a time, it looks like this:

// declare the array
char siteName[10];

// add the characters
siteName[0]  = 'T';
siteName[1]  = 'h';
siteName[2]  = 'e';
siteName[3]  = 'o';
siteName[4]  = 'c';
siteName[5]  = 'a';
siteName[6]  = 'c';
siteName[7]  = 'a';
siteName[8]  = 'o';

// add the null terminator to complete the string
// display string using %s in printf()

siteName[9]  = '\0';
printf ("Site name: %s", siteName);
                              
So an array for a C string always needs to be at least as long as the character count, plus one additional slot for the null terminator. That's why "Theocacao" needs ten slots, not nine.

If you hardcode the string in the program, you can leave both the element count and the null terminator out, so this is fine as well:

char siteName[] = "Theocacao";

The compiler will fill in the correct size at build time.

There are quite a few built-in functions that C provides for dealing with strings, but we'll leave that for another post. You can check out /usr/include/string.h in the meantime if you feel adventurous.


Note: "Sven-S. Porst" points out in the comments that saying a string is "just an array of chars" is an oversimplification. What he says is true, but the goal here is to reduce the basic concepts down to their simplest levels, then build on them later.

Wrap Up

This was a very quick introduction to some intermediate concepts in C programming. So now you should know a thing or two about arrays, as well as the difference between global and stack variables. The follow-up to this post will discuss pointers and dynamic memory management.

[Update: A terminology issue was fixed thanks to a gdb tutorial by Peter Jay Salzman.]

Comments Feed