IT 252Computer Organizationand Architecture

Introduction to the C Programming Language

Richard Helps (developed from slides from C. Teng and textbook site)

Administrivia : You have a question?

• Tips on getting an answer to your question:• Ask a classmate• Catch me after or before lecture• Ask TA in lab or IM• Ask me in lecture (if relevant to lecture)• Send your TA email• Send me email• Office hours or by appointment

Basic Skills

•Linux Shell

•Text Editor: gedit, vi, emacs, …

•Basic Shell Scripts

•Compiler: gcc, Visual C, …

•Debugger: gdb, DDD, Eclipse, …

•Useful tool: codepad.org

Background in C?

•Raise hands please• Took CS 142 in C++

• Used C in CS 124?

• Written > 500 lines C (or C++) source?

Introduction to C

Has there been an update to ANSI C?• Yes! It’s called the “C99” or “C9x” std

• You need “gcc -std=c99” to compile

• Referenceshttp://en.wikipedia.org/wiki/C99

http://home.tiscalinet.ch/t_wolf/tw/c/c9x_changes.html

• Highlights• Declarations anywhere, like Java

• Java-like // comments (to end of line)

• Variable-length non-global arrays•<inttypes.h>: explicit integer types•<stdbool.h> for boolean logic def’s•restrict keyword for optimizations

Disclaimer

• Important: You will not learn how to fully code in C in these lectures! You’ll still need your C reference for this course.

• K&R is the basic reference Check online for more sources

• “JAVA in a Nutshell,” O’Reilly. Chapter 2, “How Java Differs from C”

Compilation : Overview

C compilers take C and convert it into an architecture specific machine code (string of 1s and 0s).

• Unlike Java which converts to architecture independent bytecode.

• Unlike JavaScript environments which interpret the code.

• These differ mainly in when your program is converted to machine instructions.

• For C, generally a 2 part process of compiling .c files to .o files, then linking the .o files into executables

Compilation : Advantages•Great run-time performance: generally much faster than Java or JavaScript for comparable code (because it optimizes for a given architecture)

•OK compilation time: enhancements in compilation procedure (Makefile) allow only modified files to be recompiled

Compilation : Disadvantages•All compiled files (including the executable) are architecture specific, depending on both the CPU type AND the operating system.

•Executable must be rebuilt on each new system.

• Called “porting your code” to a new architecture.

•The “changecompilerun [repeat]” iteration cycle is slow

Key C Topics

• Pass-by value/reference• Pass-by ptr is efficient (esp large arrays)(slide 51, 52)

• Bugs (slide 36)

• Pointers: Contains an address• Array variable v. similar to ptrs (char=array, \0)

• Arrays Size w. constant once (slide 32)

• Bounds unchecked-vulnerable (slide 33, 53)

• Ptrs know size to increment

• Ptr arith (slide 40, 41)

• Variable scoping

C Syntax: main

•To get the main function to accept arguments, use this:int main (int argc, char *argv[])

•What does this mean?•argc will contain the number of strings on the command line (the executable counts as one, plus one for each argument). Here argc is 2:unix% sort myFile

•argv is a pointer to an array containing the arguments as strings (more on pointers later).

C Syntax: Variable Declarations

• Very similar to Java, but with a few minor but important differences

• All variable declarations must go before they are used (at the beginning of the block)*

• A variable may be initialized in its declaration; if not, it holds garbage!

• Examples of declarations:• correct: {

int a = 0, b = 10;

...• Incorrect:* for (int i = 0; i < 10; i++)

*C99 overcomes these limitations

Address vs. Value•Consider memory to be a single huge array:

• Each cell of the array has an address associated with it.

• Each cell also stores some value.

• Do you think they use signed or unsigned numbers? Negative address?!

•Don’t confuse the address referring to a memory location with the value stored in that location.

23 42 ... ...101 102 103 104 105 ...

Pointers

•An address refers to a particular memory location. In other words, it points to a memory location.

•Pointer: A variable that contains the address of a variable.

23 42 ... ...101 102 103 104 105 ...

x y

Location (address)

name

p104

Pointers•How to create a pointer:& operator: get address of a variable

int *p, x; p ? x ?

x = 23; p ? x 23

p =&x; p x 23

•How get a value pointed to? * “dereference operator”: get value pointed to

printf(“p points to %d\n”,*p);

printf(”address is %X or %X”,p,&x);

Note the “*” gets used 2 different ways in this example. In the declaration to indicate that p is going to be a pointer, and in the printf to get the value pointed to by p.

Pointers•How to change a variable pointed to?

• Use dereference * operator on left of =

p x 5*p = 5;

p x 23

Pointers and Parameter Passing (1/4)•Java and C pass parameters “by value”

• procedure/function/method gets a copy of the parameter, so changing the copy cannot change the original

void addOne (int x) { x = x + 1;

}

int y = 3;

addOne(y); // what is y?

y is still = 3

Pointers and Parameter Passing (2/4)•How to get a function to change a value? void addOne (int *p) {

*p = *p + 1;}

int y = 3;

addOne(&y); // what is y?

y is now = 4

Pointers and Parameter Passing (3/4)

•But what if what you want changed is a pointer?

•What gets printed?

void IncrementPtr(int *p){ p = p + 1; }

int A[3] = {50, 60, 70};int *q = A;IncrementPtr( q);printf(“*q = %d\n”, *q);

*q = 50

50 60 70

A q

Pointers and Parameter Passing (4/4)

•Solution! Pass a pointer to a pointer, declared as **h

•Now what gets printed?

void IncrementPtr(int **h){ *h = *h + 1; }

int A[3] = {50, 60, 70};int *q = A;IncrementPtr(&q);printf(“*q = %d\n”, *q);

*q = 60

50 60 70

A q q

Pointers

•Pointers are used to point to any data type (int, char, a struct, etc.).

•Normally a pointer can only point to one type (int, char, a struct, etc.).•void * is a type that can point to anything (generic pointer)

• Use sparingly to help avoid program bugs… and security issues… and a lot of other bad things!

C Pointer Dangers

•Declaring a pointer just allocates space to hold the pointer – it does not allocate something to be pointed to!

•Local variables in C are not initialized, they may contain anything.

•What does the following code do?

void f(){ int *ptr; *ptr = 5;}

Arrays (1/5)

•Declaration:

int ar[2];

declares a 2-element integer array. An array is really just a block of memory.

int ar[] = {795, 635};

declares and fills a 2-elt integer array.

•Accessing elements:

ar[num] returns the numth element.

What is ar[1]?

Arrays (2/5)

•Arrays are (almost) identical to pointers•char *string and char string[] are nearly identical declarations

• They differ in very subtle ways: incrementing, declaration of filled arrays

•Key Concept: An array variable is a “pointer” to the first element.

Arrays (3/5)

•Consequences:•ar is an array variable but looks like a pointer in many respects (though not all)•ar[0] is the same as *ar•ar[2] is the same as *(ar+2)• We can use pointer arithmetic to access arrays more conveniently.

•Declared arrays are only allocated while the scope is valid

char *foo() { char string[32]; ...; return string;}

Is this correct? Why?

Arrays (4/5)

•Array size n; want to access from 0 to n-1, so you should use counter AND utilize a constant for declaration & incr

• Badint i, ar[10];for(i = 0; i < 10; i++){ ... }

• Good#define ARRAY_SIZE 10int i, a[ARRAY_SIZE];for(i = 0; i < ARRAY_SIZE; i++){ ... }

•Why? SINGLE SOURCE OF TRUTH• You’re utilizing indirection and avoiding maintaining two copies of the number 10

Arrays (5/5)

•Pitfall: Unlike Java, an array in C does not know its own length, & bounds not checked!

• Consequence: We can accidentally access off the end of an array.

• Consequence: We must pass the array and its size to a procedure which is going to traverse it.

•Buffer overflow (internet worm)

•Segmentation faults and bus errors:• These are difficult to find; be careful! (You’ll learn how to debug these later on …)

Pointer Arithmetic (1/2)

•Since a pointer is just a memory address, we can add to it to traverse an array.

•p+1 returns a ptr to the next array elemnt.

•*p++ vs (*p)++ ?• x = *p++ x = *p ; p = p + 1;• x = (*p)++ x = *p ; *p = *p + 1;

•What if we have an array of large structs (objects)?

• C takes care of it: In reality, p+1 doesn’t add 1 to the memory address, it adds the size of the array element.

•C knows the size of the thing a pointer points to – every addition or subtraction moves that many bytes.

• 1 byte for a char, 4 bytes for an int, etc.

•So array[n]and *(array + n) are equivalent:

int* p;...p = 100;p++; // what is p now?

Pointer Arithmetic (2/2)

Pointers in C•Why use pointers?

• If we want to pass a huge struct or array, it’s easier to pass a pointer than the whole thing.

• In general, pointers allow cleaner, faster, more compact code.

•So what are the drawbacks?• Pointers are probably the single largest source of bugs in C/C++ software, so be careful anytime you deal with them.

• Dangling reference (premature free)

• Memory leaks (tardy free)

C Strings•A string in C is just an array of characters.

char string[] = "abc";

•How do you tell how long a string is?• Last character is followed by a 0 byte (null terminator)int strlen(char s[]){ int n = 0; while (s[n] != 0) n++; return n;}

Peer Instruction Question

void main(); { int *p, x=5, y; // init y = *(p = &x) + 10; int z; flip-sign(p); printf("x=%d,y=%d,*p=%d\n",x,y,p);}flip-sign(int *n){*n = -(*n)}

How many syntax/logic errors in this C99 code?

#Errors 0 1 2 3 4 5 6 7

Peer Instruction Answer

void main(); { int *p, x=5, y; // init y = *(p = &x) + 10; int z; flip-sign(p); printf("x=%d,y=%d,*p=%d\n",x,y,*p);}flip-sign(int *n){*n = -(*n);}

How many syntax/logic errors? I get 5. (signed printing of pointer is logical error)

#Errors 0 1 2 3 4 5 6 7

Pointer Arithmetic Peer Instruction Q

How many of the following are invalid (logically)?

I. pointer + integerII. integer + pointerIII. pointer + pointerIV. pointer – integerV. integer – pointerVI. pointer – pointerVII. compare pointer to pointerVIII. compare pointer to none-zero integerIX. compare pointer to 0X. compare pointer to NULL

#invalid 1 2 3 4 5 6 7 8 9 10

• How many of the following are invalid?I. pointer + integerII. integer + pointerIII. pointer + pointerIV. pointer – integerV. integer – pointerVI. pointer – pointerVII. compare pointer to pointerVIII. compare pointer to integerIX. compare pointer to 0X. compare pointer to NULL

Pointer Arithmetic Peer Instruction Ans

ptr + 11 + ptr

ptr + ptrptr - 11 - ptr

ptr - ptrptr1 == ptr2

ptr == 1ptr == NULLptr == NULL

#invalid 1 2 3 4 5 6 7 8 9 10

int main(void){int A[2] = {5,10};int *p = A;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);p = p + 1;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);*p = *p + 1;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);

}

If the first printf outputs 100 5 5 10, what will the other two printf output?

1: 101 10 5 10 then 101 11 5 112: 104 10 5 10 then 104 11 5 113: 101 11 5 10 then 101 11 6 114: 104 11 5 10 then 104 11 6 115: One of the two printfs causes an ERROR 6: I surrender!

Peer Instruction

A[1]5 10

A[0]

p

int main(void){int A[2] = {5,10};int *p = A;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);p = p + 1;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);*p = *p + 1;printf(“%u %d %d %d\n”, p, *p, A[0], A[1]);

}

If the first printf outputs 100 5 5 10, what will the other two printf output?

1: 101 10 5 10 then 101 11 5 112: 104 10 5 10 then 104 11 5 113: 101 11 5 10 then 101 11 6 114: 104 11 5 10 then 104 11 6 115: One of the two printfs causes an ERROR 6: I surrender!

Peer Instruction

A[1]5 10

A[0]

p

Lifetime & Scope

•Every variable has scope

• Where can the variable be used?

•At run-time, every variable needs space

• When is the space allocated and deallocated?

•Global vs local variable

Variable scope (1/2)

•Global variables allocated before main, deallocated after main. Scope is entire program

• Usually bad style, similar to public static Java fields.

•Static global variables like global var but scope is just that file.

• Similar to private static Java fields.

• Related: static functions cannot be called from another file.

Variable scope (2/2)

•Static local variables like global variables, but scope is just that function.

•Local variables allocated “when reached” & deallocated “after the block”, scope is that block.

• So with recursion, multiple instances/spaces for same variable. One per function call (stack frame.)

• Like local variables in Java.

Code Block

int f(int x) {

int i = 0;

if (x) {

int i = 10 * x; // does this compile?

}

printf(“%d %d”, i, x); // what is i?

return i;

}

A typical file layout

• No rules on this order, but good conventional style// includes for functions, types defined elsewhere (just prototypes)

#include <stdio.h>

#include ...

// global variables (usually avoid them)

int some_global;

static int this_file_arr[7] = { 0, 2, 4, 5, 9, -4, 6 };

// function prototypes for forward-references (to get around

// uses-follow-definition rule)

void some_later_fun(char, int); // argument names optional

// functions

void f() { ... }

void some_later_fun(char x, int y) {...}

int main(int argc, char**argv) {...}

Use Follows Definition

•No forward references

• A function must be defined or declared before it is used.

• Linker error if something is declared and used but not defined.

Misc

• Silly almost-obsolete ANSI C syntax restriction (not in Java/C99/C++): declarations only at the beginning of a “block”.

• Just create a block by adding { }

• Or use –std=c99 gcc compiler option

• (Local or global) variables holding arrays must have a constant size

• So the compiler knows how much space to give

• So for arrays whose size depends on run-time information, dynamically allocate them in heap and point to them (more on this later)

Function Arguments

•Storage and scope of arguments is like for local variables.

• Initialized by caller (“copy” the value)

•Modifying an argument has no affect on the caller. Use pointer if needed.

void f() { int g(int x) {

int i=10; x=x+1;

int j=g(i); return x;

printf(“%d %d, i,j); }

}

Function Arguments

•Storage and scope of arguments is like for local variables.

• Initialized by caller (“copy” the value)

•Modifying an argument has no affect on the caller. Use pointer if needed.

void f() { int g(int* x) {

int i=10; *x = *x + 1;

int j=g(&i); return *x;

printf(“%d %d, i,j); }

}

Dangling Pointers

int* f(int x) { // Where are the problems?

int* p;

if (x) {

int y = 3;

p = &y; // OK

}

y = 4;

*p = 7;

return p;

}

void g() {

int* p = f(7);

*p = 123;

}

// this does not compile

// p is invalid, could crash but probably not

// returning a bad pointer, but no crash yet

// hopefully you crash, but maybe not

C Syntax: True or False?•What evaluates to FALSE in C?

• 0 (integer)

• NULL (pointer: more on this later)

• no such thing as a Boolean*

•What evaluates to TRUE in C?• everything else…

• (same idea as in scheme: only #f is false, everything else is true!)

*Boolean types provided by C99’s stdbool.h

C syntax : flow control• Within a function, remarkably close to Java constructs in methods (shows its legacy) in terms of flow control•if-else•switch•while and for•do-while

And in conclusion…•All declarations go at the beginning of each function except if you use C99.

•Only 0 and NULL evaluate to FALSE.

•All data is in memory. Each memory location has an address to use to refer to it and a value stored in it.

•A pointer is a C version of the address.* “follows” a pointer to its value

& gets the address of a value

Reference slides

You ARE responsible for the material on these slides (they’re

just taken from the reading anyway) ; we’ve moved them to

the end and off-stage to give more breathing room to lecture!

C vs. Java™ Overview (1/2)

Java• Object-oriented(OOP)

• “Methods”• Class libraries of data structures

• Automatic memory management

C• No built-in object

abstraction. Data separate from methods.

• “Functions”• C libraries are lower-level

• Manualmemory management

• Pointers

C vs. Java™ Overview (2/2)

Java• High memory overhead from class libraries

• Relatively Slow

• Arrays initialize to zero

• Syntax: /* comment */ // commentSystem.out.print

C• Low memory overhead

• Relatively Fast

• Arrays initialize to garbage

• Syntax: * /* comment */// comment printf

* You need newer C compilers to allow Java stylecomments, or just use C99

Pointers & Allocation (1/2)•After declaring a pointer:

int *ptr;

ptr doesn’t actually point to anything yet (it actually points somewhere - but don’t know where!). We can either:

• make it point to something that already exists, or

• allocate room in memory for something new that it will point to… (next time)

Pointers & Allocation (2/2)•Pointing to something that already exists:int *ptr, var1, var2;var1 = 5;

ptr = &var1;var2 = *ptr;

•var1 and var2 have room implicitly allocated for them.

ptr var1 ? var2 ?5 5? 

Pointer Arithmetic•So what’s valid pointer arithmetic?

• Add an integer to a pointer.

• Subtract 2 pointers (in the same array).

• Compare pointers (<, <=, ==, !=, >, >=)

• Compare pointer to NULL (indicates that the pointer points to nothing).

•Everything else is illegal since it makes no sense:

• adding two pointers

• multiplying pointers

• subtract pointer from integer

Pointer Arithmetic to Copy memory•We can use pointer arithmetic to “walk” through memory:

void copy(int *from, int *to, int n) { int i; for (i=0; i<n; i++) { *to++ = *from++; }}•Note we had to pass size (n) to copy

Arrays vs. Pointers

•An array name is a read-only pointer to the 0th element of the array.

•An array parameter can be declared as an array or a pointer; an array argument can be passed as a pointer.

int strlen(char s[]){ int n = 0; while (s[n] != 0) n++; return n;}

int strlen(char *s){ int n = 0; while (s[n] != 0) n++; return n;}

Could be written:while (s[n])

Pointer Arithmetic Summary• x = *(p+1) ?

x = *(p+1) ;

• x = *p+1 ? x = (*p) + 1 ;

• x = (*p)++ ? x = *p ; *p = *p + 1;

• x = *p++ ? (*p++) ? *(p)++ ? *(p++) ? x = *p ; p = p + 1;

• x = *++p ? p = p + 1 ; x = *p ;

• Lesson?• Using anything but the standard *p++ , (*p)++

causes more problems than it solves!

Segmentation Fault vs Bus Error?• http://www.hyperdictionary.com/

• Bus Error• A fatal failure in the execution of a machine

language instruction resulting from the processor detecting an anomalous condition on its bus. Such conditions include invalid address alignment (accessing a multi-byte number at an odd address), accessing a physical address that does not correspond to any device, or some other device-specific hardware error. A bus error triggers a processor-level exception which Unix translates into a “SIGBUS” signal which, if not caught, will terminate the current process.

• Segmentation Fault• An error in which a running Unix program

attempts to access memory not allocated to it and terminates with a segmentation violation error and usually a core dump.

C Pointer Dangers•Unlike Java, C lets you cast a value of any type to any other type without performing any checking.

int x = 1000;

int *p = x; /* invalid */

int *q = (int *) x; /* valid */

•The first pointer declaration is invalid since the types do not match.

•The second declaration is valid C but is almost certainly wrong

• Is it ever correct?

C Strings Headaches

•One common mistake is to forget to allocate an extra byte for the null terminator.

•More generally, C requires the programmer to manage memory manually (unlike Java or C++).

• When creating a long string by concatenating several smaller strings, the programmer must insure there is enough space to store the full string!

• What if you don’t know ahead of time how big your string will be?

• Buffer overrun security holes!

Common C Error•There is a difference between assignment and equality

a = b  is assignment

a == b is an equality test

•This is one of the most common errors for beginning C programmers!

• One solution (when comparing with constant) is to put the var on the right! If you happen to use =, it won’t compile.if (3 == a) { ...

C String Standard Functions• int strlen(char *string);

• compute the length of string

• int strcmp(char *str1, char *str2);• return 0 if str1 and str2 are identical (how is

this different from str1 == str2?)

• char *strcpy(char *dst, char *src);• copy the contents of string src to the memory

at dst. The caller must ensure that dst has enough memory to hold the data to be copied.