Transcript C introduction

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