CS 261 - Winter 2009
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.
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];
};
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.
A pointer
A value
42
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)
p
d
double * p;
double d, e;
&d
3.14159
p = & d;
*p = 3.14159;
p = & e;
*p = 2.718281;
printf(“values: %d %g %g %g\n”, p, *p, d, e);
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 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 vector vec; /* note, value, not ptr*/
vectorInit (&vec); /* pass by ref */
vectorAdd (&vec, 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]);
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);
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