CS 261 - 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 = 3.14159;p = & e;*p = 2.718281;printf(“values: %d %g %g %g\n”, p, *p, d, e);

&d 3.14159

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 = 3.14159;}

double d = 2.718281;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, 3.14159);

Arrays aways passed by ref

void foo(double * d) {

d[0] = 3.14159;

}

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

… /* 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