Computer Programming (12) - C Preprocessor, Memory Allocation

administrivia

the C Preprocessor

• a translation applied before the compiler
  • preprocessor, compiler, linker
• textual substitution
  • file inclusion - inserting the contents of another file into your source file, as if you had typed it all in there
  • macro substitution - replacing instances of one piece of text with another.
  • conditional compilation - depending on various circumstances, certain parts of your source code are seen or not seen by the compiler

the C Preprocessor syntax

• line based - must begin at the beginning of a line, and each ends at the end of the line
  • you can break long lines with the '\' character at the end of the line
    • useful especially for text substitution directives
• begin with the # character
• knows nothing about C statements or expressions
  • playing tricky and outrageous games with the preprocessor is considered sporting in some circles

file inclusion

• K&R Sec. 4.11.1
• a line of the form

  #include <filename.h>

  or

  #include "filename.h"

• the contents of the file filename.h is read, parsed, and compiled at that point.
• after filename.h is processed, compilation continues on the line following the #include line
• example
  place the prototypes of several related function in a header file myio.h

  extern int getline(char [], int);

  
  at the top of each source file add the line

  #include "myio.h"

• stdio.h - a collection of declarations (including external function prototype declarations)

the difference between the <> and ""

• where the preprocessor searches for filename.h?
  • files enclosed in <> - in central, standard directories
  • files enclosed in "" - in the current directory or the directory containing the the including source file
• what do they contain?
  • "" - usually used for header files you've written,
  • <> - usually used for headers which are provided for you

what should you put in header files?

• external declarations of global variables and functions commonly used
• a global variable
  • must have exactly one defining instance,
  • can have external declarations in many places
• common declarations and definitions
  • if they ever change, they only have to be changed in one place
  • it is an error to declare a variable of one type externaly in one place and define its instance with another type
    • if the two places are two source files, separately compiled, only the linker will catch the discrepancy
  • ensures consistent declarations.
    • include the header in the source file where the defining instance appears, too
      • the compiler can check that the declaration and definition match

what should you put in header files?

• common declarations and definitions
  • preprocessor macro definitions
  • structure definitions (which we haven't seen yet)
  • typedef declarations (which we have hardly seen).
• however, there are a few things not to put in header files:
  • defining instances of global variables.
  • function bodies (which are also defining instances)
    • it's much better to learn how to use your compiler or linker to combine together separately-compiled object files

using a third-party library

• two-step process
  • you must #include the header in the files where you call the library functions,
  • you must tell the linker to read in the functions from the library itself

macro definition and substitution

• K&R Sec. 4.11.2
• a preprocessor line of the form

  #define name text

  • name - the given macro name
  • text - the given replacement text.
• name is replaced with text
  • after that for the rest of the current source file, or
  • until name is undefined

    #undef name

macro name and replacement text

• follows the same rules as ordinary identifiers
  • can contain only letters, digits, and underscores
  • may not begin with a digit
• since macros behave quite differently from normal variables (or functions), it is customary to give them names which are all capital letters
• the replacement text can be absolutely anything

macro use

• propagate constants around
• make them more self-documenting.
• example

  char line[100]; ... getline(line, 100);

  if we ever decide that 100 is too smal, we'll have to remember to change the number in two (or more) places.

  #define MAXLINE 100 char line[MAXLINE]; ... getline(line, MAXLINE);

macro definition and substitution syntax

• there does not have to be (and in fact there usually is not) a semicolon at the end of a #define line
• if you accidentally type

  #define MAXLINE 100; /* WRONG */

  then when you later declare

  char line[MAXLINE];

  the preprocessor will expand it to

  char line[100;]; /* WRONG */

macro evaluation

• evaluation not performed when the macro is defined
• suppose that you write something meaningless like

  #define A 2 #define B 3 #define C A + B int x = C * 2;

  you'd expect x to end up with the value 10, but
  • the preprocessor substitutes text for macros exactly as you have written it,
  • first, C is substituted

    int x = A + B * 2;

  • then, the macros A and B are substituted

    int x = 2 + 3 * 2;

  • using the normal precedence of multiplication over addition x is intialized with the value 8
• it is always a good idea to include explicit parentheses

  #define C (A + B)

macros which look like little functions

• macros like MAXLINE act like constant expressions
• macros can look like little functions
  • they expand to replacement text which is a function of the actual arguments they are invoked with
  • this is as far as we go here

conditional compilation

• K&R Sec. 4.11.3
• controls which parts of your program get compiled

  #ifdef name program text #else more program text #endif

• if name is defined, "program text" is compiled and "more program text" is ignored. Otherwise, the opposite
• different then if statement
  • controls which statements are executed at run time
• the #else is optional

other directives

• #ifndef name - compiles code if the macro is not defined
• #if expresion - compiles code if expression is true

  #if 0 program text #endif

• #if defined(name) - like #ifdef name, but can be augmented
  • #if defined(name1) && defined(name2)

conditional compilation is useful

• you are writing a portable program that depends on
  • compiler
  • operating system
  • computer
• different versions of code, one for each situation, between suitable #ifdef directives
• compilers have ways of letting you define macros from
  • the invocation command line

    cl.exe -Dname

  • in a configuration file
  • many predefine certain macro names related to the operating system, processor, or compiler in use.

example

• in ANSI C, the function to delete a file is remove
• on older Unix systems, the function was called unlink

  #ifdef unix unlink(filename); #else remove(filename); #endif

• you could place the line

  #define unix

  at the top of the file when compiling under an old Unix system
  • no need to give it any replacement text
  • any definition for a macro, even if the replacement text is empty, causes an #ifdef to succeed
• C compilers on old Unix systems tend to predefine it for you
  • no need to define the macro unix at all

conditional compilation is useful

• building different versions from the same source code
• compiling different versions with different features present in the different versions
• turn debugging statements on or off

  #ifdef DEBUG printf("x is %d\n", x); #endif

• define the macro DEBUG from the compiler invocatin line
  • use a compiler flag such as -DDEBUG

allocating memory with malloc

• parts of K&R Secs. 5.4, 5.6, 6.5, and 7.8.5
• so far we used fixed-size arrays that may or may not be big enough
• if we're lucky, the relevant parts of the program
  • checks how much of an array they've used, and
  • prints an error message, or
  • gracefully aborts
• if we're not so lucky, the program overflows the array and crashes
• in either case, the user doesn't get his job done

memory allocation

• malloc - C's dynamic memory allocation function
• malloc returns a pointer to the memory it gives us
• read a line of input into a dynamic array

  #include char *line; int linelen = 100; line = (char *) malloc(linelen); /* check malloc's return value */ getline(line, linelen);

managing allocated memory

• dynamically allocated regions of storage are like arrays
  • use array-like subscripting notation on them
• often you need to manage the memory in your program
  • keep track of the memory which malloc has given you
• it is easy to accidentally use a pointer which points "nowhere"
  • actually it can point "somewhere", just not where you wanted it to

  *p = 0;

  the 0 gets written "somewhere"

allocating memory for charcters

• all strings have a terminating \0 character
• you must add one to the count that strlen return when calling malloc

  char *somestring, *copy; ... copy = (char *) malloc(strlen(somestring) + 1); /* +1 for \0 */ /* check malloc's return value */ strcpy(copy, somestring);

allocating memory for integers

• we want to allocate 100 ints
• it's much safer and more portable to let C compute the size for us
• C has a sizeof operator, which computes the size, in bytes, of a variable or type

  int *ip = (int *) malloc(100 * sizeof(int));

  • sizeof() is an operator, and it is evaluated at compile time

accesing allocated memory

• we can use array indexing syntax on pointers
• we can treat a pointer variable returned by malloc almost exactly as if it were an array

• int *ip = (int *) malloc(100 * sizeof(int));

  we can access ip[0], ip[1], ... up to ip[99]
• get the effect of an array even if you don't know until run time how big the array should be

verifying allocated memory

• no real computer has an infinite amount of memory available
• no guarantee that malloc will be able to give us as much memory as we ask for
• we're probably going to run out of memory if
  • we call malloc(100000000), or
  • we call malloc(10) 10,000,000 times
• malloc returns a null pointer upon failure
• it's vital to check the returned pointer before using it

  int *ip = (int *) malloc(100 * sizeof(int)); if(ip == NULL) { printf("out of memory\n"); exit or return }

freeing memory

memory allocated with malloc does not automatically disappear when a function returns, as automatic-duration variables do,
• but it does not have to remain for the entire duration of your program
• memory is not inexhaustible
• control when you deallocate (release) memory

  free(p);

• p contains a pointer previously returned by malloc

recycling memory

• freeing memory is recycling
• it costs you almost nothing
• the memory you give back is immediately usable by other parts of your program. (Theoretically, it may even be usable by other programs.)
• freeing unused memory is a good idea, but it's not mandatory
  • allocated memory is automatically released upon exit by the operating system

avoid misusing pointer to dealocated memory

• once you've freed some memory you must remember not to use it any more
• after calling

  free(p);

  p still points at the same memory
• record the fact that it's not to be used any more

  free(p); p = NULL;

keeping track

• there is a big difference between a pointer and what it points to
• you need at least one pointer to the memory to use it or free it
• suppose
  • you store the pointer that malloc gives you in a local pointer variable
  • then, the function containing the local pointer variable returns
    • local variables have automatic duration
• the pointer disappears when the function returns, but the memory remains allocated
  • there is no way to use it or free it, if it contained the only copy of the pointer

reallocating memory blocks

• accepts an old pointer and a new size
• returns contiguous space of the new size

  ip = realloc(ip, 200 * sizeof(int));

  • if the old block can be made bigger, it returns the same pointer
  • otherwise, it
    • attempts to allocate new memory
    • if successful
      • copies old data to new memory
      • frees old memory block
      • returns new pointer
    • otherwise, returns NULL

example

• reads lines of text from the user, treats each line as an integer by calling atoi, and stores each integer in a dynamically-allocated "array"

  #define MAXLINE 100 char line[MAXLINE]; int *ip; int nalloc, nitems; nalloc = 100; ip = (int *) malloc(nalloc * sizeof(int)); /* initial allocation */ if (ip == NULL) { printf("out of memory\n"); exit(1); } nitems = 0; while (getline(line, MAXLINE) != EOF) { if (nitems >= nalloc) { /* increase allocation */ int *newp; nalloc += 100; newp = realloc(ip, nalloc * sizeof(int)); if (newp == NULL) { printf("out of memory\n"); exit(1); } ip = newp; } ip[nitems++] = atoi(line); }

prototype

• malloc, free, and realloc are declared in <stdlib.h>
• malloc and realloc return type is void *
  • a pointer to void
• a "generic" pointer type, which may be any pointer type
  • assigned to or from

pointer safety

• ensuring that the memory pointers point to is valid
• when a pointer doesn't point where you think it does, if you inadvertently access or modify the memory it points to, you can damage other parts of your program, or (in some cases) other programs or the operating system itself!

be careful when pointing to arrays

• ensure that the pointers always stay within the bounds of the array(s)
• when passing pointers to and returning them from functions
  • the code using the pointer may be far removed from the code that owns or allocated the memory
• strstr function returns either
  • a null pointer, or
  • a pointer that points into the input caller-supplied string
• never return a pointer to one of its own, local, automatic-duration arrays
  • automatic-duration variables are deallocated and disappear when the function returns

be most careful when allocating memory dynamically

• doing dynamic memory allocation with malloc, realloc, and free cab be dangerous
  • dynamic allocation gives a lot more flexibility in how our programs use memory
• reduce damaging possibilities by ensuring
  • that pointers are used correctly, and
  • that memory is always allocated and deallocated correctly