CS Winter 2011 Introduction to the C programming language

Why C ? C is simple language, makes it easier to focus on important concepts Java is high level language, C is low level, important you learn both Lays groundwork for many other langauges

Comparing Java and C No classes, inheritance, or polymorphism Functions are the major mechanism for encapsulation Arrays and structures are the major data storage mechanisms Pointers!! Lots of pointers.

Function definitions Functions look a lot like methods you are used to in Java, but are not part of a class return-type function-name (arguments) { declarations; /* must come first!! */ function-body; }

Two level scope There are two levels of scope Variables declared outside of any function are global (use sparingly) Variables declared inside of function are local. Declarations must be listed first, before statements. You end up passing more inforation in arguments than you do in Java

Parameters are by-value Arguments to functions are passed by value Means the parameter is initialized with a COPY of the argument Will simulate by-reference using pointers

Structures Structures are like classes that have only public data fields and no methods: struct arrayBag { int count; EleType data[100]; };

Declaring a structure When you declare a variable you must use the struct keyword struct arrayBag foo; No constructors, no initialization, you must use explicit initialization routine

Access to data fields Access to data fields uses the same dot notation you are used to: struct arrayBag myData; myData.count = 3; (but often combined with pointers…)

Pointers Pointers in C are explicit (implicit in Java) A pointer is simply a value that can refer to another location in memory. 42 A valueA pointer

Pointer values vs. thing pointed to Important to distinguish between the value of the pointer and the value of the thing the pointer points to 42

Some syntax Use * to declare a pointer, also to get value of pointer. Use & to get address of a variable (address == pointer) double * p; double d, e; p = & d; *p = ; p = & e; *p = ; printf(“values: %d %g %g %g\n”, p, *p, d, e); &d p d

Pointers and Structures Pointers often combined with structures. Introduce some new syntax struct arrayBag * p; struct arrayBag g1; p = & g; p->count = 1; /* same as (*p).count */ p = 0; /* null pointer, doesn’t point to anything */

Pointers vs object pointed to When you declare a variable it is not initialized, true for both pointers and structures Always be clear whether you are talking about a pointer, or thing pointed to 90% of your programming errors will come from uninitialized pointers or values

Structures and arguments Remember, arguments are passed by value If you pass a structure, the ENTIRE structure is copied into the space for the actual argument value Wasteful, therefore we use pointers are arguments

Pointers and by-reference parameters A reference parameter can be simulated by passing a pointer: void foo (double * p) { *p = ; } double d = ; foo( & d); printf(“what is d now? %g\n”, d);

Structures and by-ref params Very common idiom: struct arrayBag a; /* note, value, not ptr*/ arrayBagInit (&a); /* pass by ref */ arrayBagAdd (&a, );

Arrays aways passed by ref void foo(double * d) { d[0] = ; } double data[4]; data[0] = 42; foo(data); /* note - NO ampresand */ printf(“what is data[0]? %g”, data[0]);

Notice, array has become a pointer Look carefully at the previous slide Notice the value was an array when it was passed as an argument But inside the function, we declared it as a pointer Pointers can be subscripted, just like arrays

Dynamic Memory No new operator. Use malloc(#bytes) instead. Use sizeof to figure how big something is struct gate * p = (struct arrayBag *) malloc(sizeof(struct arrayBag)); assert (p != 0); /* always a good idea */

Assert check conditions We will use assert to check all sorts of conditions. Halts program if condition not found. # include … /* assert checks condition is true */ assert(whatever-condition);

BTW, no boolean BTW, there is no boolean data type. Can use ordinary integer, test is zero or not zero. Can also use pointers, test is null or not null. int i; if (i != 0) if (i) /* same thing */ double * p; if (p != 0) if (p) /* same thing */

Separation of interface and implementation Interface files (*.h) have declarations and function prototypes Implementation files (*.c) have implementations prototype is function header but no body: int max(int a, int b);

Will often have interface given We will often give you the interface file, and you write the implementation

Preprocessor A Preprocessor scans C programs before they are compiled. Used to make symbolic constants, conditionally include code # define max 423 # if (max < 3) … # endif

Ensuring declarations seen only one /* interface file for foo.h */ # ifndef BigComplexName # define BigComplexName … # endif /* that way, 2nd time does nothing */

First Assignment Good news on first assignment - it doesn’t have any pointers, only arrays Major problem should be just figuring out how to compile a C program Pointers will start to show up with second assignment and beyond.

Will see more as we go along After class, Take a look at programming assignments 1 and 2 In some place (assignment 2 and later) I will give you an interface file, hand in only implementation file (whatever.c) (Note: there is no interface file needed for first assignment). Questions?

Now, review of Big Oh Now, a review of Big-Oh