Outline

• C Program Structure
• Struct's, Union's, Enum's
• In-Class Exercise
• Memory Allocation
• File I/O
• Buffering
• make

Introduction

• Last Wednesday, we finsished our overview of how compilation works and had begun looking at programming syntax in more depth.
• We talked about regular expressions as a method that programming language designers can use to specify what constitutes a legal keyword, identifier, symbol, or constants in the language they are designing.
• After giving some examples, we switched gears to talk about the C language - the programming language we will program in for the first assignment.
• Today, we will continue talking about C.
• Next week, after mastering C, we will resume our syntax story and be able to use C when providing examples.

Where we were in our C Intro

• Recall, for C we had described how to write a "hello world" program, similarities between C and Java in declaring simple type, assignment, switch/case, while, and for loops.
• We said for ANSI C, but not anything after C99, you have to be careful to have all variable declarations at the top of a function body.
• In terms of compiling coding, this makes it easier to know the space used by the stack before outputting generating code for the function itself.
• Finally, we gave the example below of declaring functions in C:

  #include <stdio.h>
  char foo();
  void bar()
  {
       printf("%c", foo());
  }
  char foo( )
  {
       return 'a';
  }
  int main()
  {
     bar();
     return 0;
  }
  
  

• The first char foo(); is a function prototype. We must either have a function prototype or a whole function definition before the first time we use a function in C otherwise the compiler will complain. Doing makes the job of compiling easier, because we know the signature of functions, and so how to call in machine code them, before we use them.

Program structure

Generally, for each module (say .c file) of your program, you put all its function prototypes, struct definitions, #define's, global variable declarations, etc. into a header file (a .h file) for that program and then include it with the line like:

#include "foo.h" /* double quotes unlike <foo.h>, also searches current directory */

Since, you might use the same header file for several modules, the header file might have at its start some preprocessor code like:

#ifndef FOO_H
#define FOO_H
//header file code
#endif // this prevents the header from being included more than once.

Pointers

Roughly, pointers allow us to refer to a memory address.

Example:

 
   int a, *b; /* b is declared as a pointer to an int memory address, 
        (what * means when declaring a variable) */
   a = 5;
   b = &a; /* now b points at where a is stored in memory 
       (what & on a non-pointer means) */
   printf("%d", *b); //prints 5.
   *b = 6; /* this changes the value of what's stored at the address b points to */
   printf("%d", a); // prints 6.

More Pointers

• We'll see pointers can be used very much like arrays.
• You can have pointers to pointers (handles):

  char **p; // sorta like a 2d array.
  

• You can also have pointers to functions (useful for doing things like to simulate strategy pattern):

  int add(int a, int b) { return a+b; }
  int (* p) (int, int);
  p = &add;
  printf("sum:%d", (*p)(3,4) ); //output 7.
  

In-Class Exercise

• On job interview questions, one is often asked to write code to reverse a string.
• Consider:

  //main.c
  #include <stdio.h> //for printf statement
  #include <string.h> //has strlen
  #include "reverse.h"
  
  int main()
  {
     char hw[] = "hello world"; /* how to assign string literals in C
             Could also have done: char hw[12] = "hello world";
             The notation hw[some_num] can be used to access some_num char.
             i.e., hw[3] == 'l'
          */
     reverse(hw);
     printf("%s", hw);
     // want to output dlrow olleh
     return 0;
  }
  

• Give possible code for reverse.h to get the above code to work as intended. If you want the implementation of the reverse function to be separated from the prototype, you could put it in a separate file reverse.c. To compile you can do:

  gcc main.c reverse.c -o my_reverse
  

• Please post your solution to the Sep 8 In-Class Exercise Thread.

Struct's

C has a mechanism for collecting together a bunch of existing data types into a new one using struct's. These can be thought of as classes without member functions.

struct Person
{
     char name[12];
     int age;
}; //notice the ;
struct Person p, *ptr;
strcpy(p.name, "Bob"); //in string.h. Note p.name[3] = '\0' after
// many useful string functions like strlen, strcmp, etc are in string.h
p.age = 5;
ptr = &p;
printf("%d %s %s", p.age, (*ptr).name, ptr->name);

More on struct's

You can also declare:

struct
{
   int a,b;
} test;
test.a = 5; /* so have declared a variable test but have not given the kind of struct it is a name */

The syntax struct Person p; of the last slide is sometimes awkward. To simplify it you can write:

typedef struct Person person_type;
person_type a,b,c;

Using structs and pointers you can create recursive data structures:

struct mylist
{
   int a;
   struct mylist *next, *prev;
} test;

Remark: You can fake classes by using struct's which have function pointers as members.

Union's and Enum's

• Union's and Enum's are C constructs which have a syntax similar to structs.
• Union's are used when you know that you need to store one object but you are not sure of the type in advance. For example, on the homework, we might store an int or an Operation type.

  union int_or_char
  {
     int my_int; //can hold either an int or a char but not both at the same time
     char my_char; // union allocates enough memory for the larger of the two possibilities 
  } test;
  
  test.my_int = 8;
  typedef union int_or_char IntOrChar;
  IntOrChar test2;
  

• Enum's are used to create a new type which consists of a fixed number of elements that you explicitly enumerate:

  enum suit {CLUBS, DIAMONDS, HEARTS, SPADES} suit_test;
  suit_test = DIAMONDS;
  typedef enum suit CardSuit;
  CardSuit suit_test2 = SPADES;
  
  

Memory Allocation

• Sometimes we don't know how much memory we need for a job at compile time. For instance, we might not know how big a list will grow or how big an array we need to hold a string.
• C has a runtime heap and supports allocating/deallocating memory from it at runtime:

  #include <stdio.h>
  #include <stdlib.h> //for malloc and free
  int main()
  { 
     int *p;
     p = (int *)malloc(10*sizeof(int)); 
        /*sizeof returns number of bytes an int takes (could do sizeof(person_type) for person_type of a couple slides back) */
     if( p == NULL)
     {
        return 1; //bail out
     }
     /* do stuff. To refer to the location of ith int can do (p + i), its value is *(p + i) or p[i]
     */
     free(p); // got to free or create a memory leak -- unlike Java no garbage collection
     return 0;
  }
  

  Notice we cast the result of malloc to be of type int rather than void*.

File I/O

• The usual C File I/O is tightly connected to the Unix notion of a stream.
• We have already been using streams: namely printf sends its data to the default output stream, stdout.
• Functions for I/O are all mainly in stdio.h. To see what are available functions look in Wikipedia.
• There is a also a stdin and and a stderr. For example,

  int a;
  scanf("%d", &a); //reads from stdin one int into a.
  

• Functions like printf, scanf, getc, etc which operate on the standard streams all have analogs which operate on files: fprintf, fscanf, fgetc, etc.

Example Reading From a File in C

#include <stdio.h>
int main(int argc, char * argv[]) //notice getting command-line args
{
   int c;
   FILE *fp;
   if(argc < 2)
   {
       return 1; //bail if no file specified

   }
   fp = fopen(argv[1], "r"); // r is for reading, w for write, rb for binary, etc
   while ((c = fgetc(fp)) != EOF) 
   {
       printf("%c", (char)c );
   }
   fclose(fp);
   return 0;
}

Buffering

• As an example of how the language and the platform are connected, consider input in C on Unix:

      printf("Hit a key to continue");
      c= getchar();
  

• Although we are only requesting a single character from stdin, since in Unix stdin is line-buffered, we have to wait till someone hits enter to get our character.
• In Dos C which has a different default buffering, we wouldn't have to hit enter.
• We can make OS calls to change the buffering in Unix, but this just shows, how we program is influenced by the platform we are on:

      #include <termios.h>
     //...
         struct termios tio;
         tcgetattr( 0, &tio );
         tio.c_lflag &= ~ICANON;
         tcsetattr( 0, TCSANOW, &tio ); 
         printf("Hit a key to continue");
         c= getchar();
  

make

• make is a build utility -- a utility to compile and link large software projects -- developed by Stuart Feldman at Bell Labs in 1977.
• It heavily influenced many later build tools such as ant, and it also has been ported to many platforms. For example, Microsoft OS's use nmake.
• make is very similar in some ways to Prolog, and can be viewed as perhaps the most commonly used declarative language.
• Typically, make is run from the command-line with a line like:

  make target
  

  The make utility would then search the current directory for a file called Makefile and then tries to satisfy the target goal.

Makefile Structure

A Makefile consists of rules of the form:

target1: depends_on1 depends_on2 ...
<tab>command1
<tab>command2
...
<blankline>
target2: depends_on1 depends_on2 ... #etc
# is used for a single-line comment

Notice the use of tabs is important!

Some example targets

myprog: myprog.o
	cc -o $@ $<
 
myprog.o: myprog.c
	cc -c -o $@ $<
# $@ refers to the target $< refers to the first dependency
clean:
	rm -f myprog myprog.o

More on Makefiles

You can declare variables in a Makefile using the format varname = value like:

   CC = gcc
   SUBDIRS = io linkedlist

These variables could then be used:

all : $(SUBDIRS)
   $(CC) historylesson.c -o historylesson

An example of a multi-line make rule might be something like:

io :
   @echo "Making io..."
   cd io
   make all

• Make uses the file modification dates to figure out what needs to be re-compiled.
• If the timestamp of the target is less that any dependency then the target is made; typically, it only performs incremental compiles.
• There are various shortcuts you can use for rules that I won't go into very much. For example, if one had the target hello.o . It would match the rule:

  %.o : %.c