1. Introduction to the C programming language
CS Fall 2009
Introduction to the
C programming language

2. 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

3. 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.

4. 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; }

5. 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.

6. 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

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

8. 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…)

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

10. 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

11. 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

12. 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 */

13. 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);

14. Structures and by-ref params
Very common idiom:
struct vector vec; /* note, value, not ptr*/
vectorInit (&vec); /* pass by ref */
vectorAdd (&vec, );

15. 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]);

16. 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 */

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

18. 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 */

19. 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);

20. 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

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

22. 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.

23. 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?

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