Class 07: Headers and Makefiles

Held Monday, February 7, 2000

Overview

Today we consider two important practical issues for the development of C programs: header files, which provide specifications for C libraries, and make, which supports some forms of automatic recompilation.

Notes

• A few of you have asked me about compilers for the Wintel platform. I would suggest using some form of GCC.
  • You can find out more about GCC at http://www.gnu.org/
  • The Wintel platform seems to be Cygwinn, which you can find at http://sourceware.cygnus.com/cygwin/.
• Assigned:
  • Assignment 2: Linked lists (Due next Monday)

Contents

• Header Files
• Make
• Exercises

Summary

• Header files
• Unix make
• Due:
  • Homework 1: A Simple Chat Program

Header Files

• As you may recall, one of the great goals of modern programming language design is to ``separate specification from implementation''.
• That is, we want to document what a program does in one place and how it does it in another place.
• In C, you can express specifications and other common code in header files.
• A header file is simply some C code stored in a file that ends in .h.
• What goes in a header file? Most typically:
  • Function declarations (but not definitions)
  • Constant declarations
  • Type declarations and definitions (so the definitions aren't usually hidden).
• Header files are particularly useful for instances similar to those of our server and client, in which important constants must be shared between files.

Make

• As many of you learned when programming in Java, Java is somewhat nice about choosing files to recompile when you make changes.
• If you compile file X.java and it depends on class Y, and class Y has changed, then the Java compiler will also recompile Y.
• However, if you change and recompile Y, Java does not know to recompile X.
• C isn't nearly so nice.
• Fortunately, Unix is nice, and provides a wonderful tool for selective recompilation.
• That tool is make
• To use make, you must create a command file for make (typically called Makefile)
• Makefiles primarily contain entries of the form

  thing-to-make: things it depends on
  	instructions for making the thing
  

• For example, consider an application called chat that we plan to build from three files: server.c, client.c and chat.h.
  • We'd like to build the .o files first.
• Here we go ...

  chat: server.o client.o
  	gcc -o chat server.o client.o
  server.o: server.c chat.h
  	gcc -c server.c
  client.o: client.c chat.h
  	gcc -c client.c
  

• You run make by typing make at the Unix command line.

Exercises

• Create a file, weekdays.h that defines an enumerated type, weekday.
• Create a file, weekdays.c that provides appropriate utilities for weekday, such as a function to convert a weekday to the corresponding string.
• Create a file, printdays.c that prints the days of the week in order (both the code and the name), using a for loop.
• Write a Makefile to help generate the executable.
• Generate the execuatable using make.
• Touch weekdays.c (using the touch command) to update the ``last changed'' attribute.
• Type make to see what happens.
• Touch weekdays.h and make again.