The C Programming Language Intro to C #include

• C is a high-level language — structured int main() { int i; • C is a low-level language — machine access extern int gcd(int x, int y); for (i = 0; i < 20; i++) • C is a small language, extendable with libraries printf("gcd of 12 and %d is %d\n", i, gcd(12,i)); • C is permissive: assumes you know what return (0); } you’re doing int gcd(int x, int y) { • Good: efficient, powerful, portable, flexible int t; while (y) { • Bad: easy to make errors, obfuscation, t = x; x = y; y = t % y; little support for modularization } return (x); 1 } 2

About C Basic Control Structures

• Similar to Java - Java took best of C • Functions - can omit extern declaration • #include - use declarations of functions • for loop - like Java • main() returns int, the exit status – body is one statement • Functions must be – braces { } enclose blocks – declared - tells compiler how to use function – blocks introduce scope level – defined - creates the item – can't mix declarations and non-declarations • for (int i … - illegal in ANSI C • Declarations must appear before code

3 4 More about C C data types • basic types and literals (King: Ch 7) • Uninitialized variables have no default value! int i = 38; long el = 38L; int hex = 0x2a; int oct = 033; • No run-time checking! printf("i = %d, el = %ld, hex = %d, oct = %d\n", i, el, hex, oct); • No polymorphism (printf format strings) i = 38, el = 38, hex = 42, oct = 27

• No objects (C predates object-oriented) double d1 = 0.3; double d2 = 3.0; double d3 = 6.02e23; printf("d1 = %f, d2 = %f, d3 = %e\n", d1, d2, d3) Compile: gcc -Wall -g -o gcd gcd.c d1 = 0.300000, d2 = 3.000000, d3 = 6.020000e+23

5 6

Data Type Conversion Data Type Capacity

• The expression on the right side is converted to the • What happens when the following code is type of the variable on the left. char c; executed? int i = c; /* c is converted to int */ double d = i; /* i is converted to double */ char c = 127; int d; • This is no problem as long as the variable’s type is printf("c = %d\n", c); at least as “wide” as the expression. c++; char c = 500; /* compiler warning */ d = 512 / c; int k = d1; printf("c = %d, d = %d\n", c, d); printf("c = %c, k = %d\n", c, k); c = , k = 0 7 8 Logical 0 address Mixed Mode Arithmetic Memory model Code double m = 5/6; /* int / int = int */ printf("Result of 5/6 is %f\n", m); Static Data Result of 5/6 is 0.000000 • Memory is just a sequence of bytes double n = (double)5/6; /* double / int = double */ Dynamic Data printf("Result of (double)5/6 is %f\n", n); • A memory location is Result of (double)5/6 is 0.833333 identified by an address. double o = 5.0/6; /* double / int = double */ Unused Logical printf("Result of 5.0/6 is %f\n", o); Address Space Result of 5.0/6 is 0.833333

int p = 5.0/6; /* double / int = double but then converted to int */ Stack printf("Result of 5.0/6 is %d\n", p); Result of 5.0/6 is 0 232 -1 9 10

0 Example Code Arrays x int x = 10; 0x8049430 10 int y; • Arrays in C are a contiguous chunk of 0x8049528 y ??? int f(int p, int q) { memory that contain a list of items of the int j = 5; return p * q + j; Dynamic Data same type. } int main() { Unused Logical • If an array of ints contains 10 ints, then Address Space the array is 40 bytes. There is nothing int i = x; j y = f(i, i); 0xffff3a30 5 extra. return 0; f 0xffff3a34 p 10 } 0xffff3a38 q 10 • In particular, the size of the array is not stored with the array. There is no i main 0xffff8910 10 runtime checking.

Stack 11 12 Arrays Initializing arrays x[0] 0x88681140 The sizeof operator is x[1] 0x88681144 int x[5]; Declaration/Definition evaluated by the x[2] 0x88681148 for (i = 0; i <= 5; i++) { int a[10]; /*declare 'a' as an compiler x[i] = i*i; 0x8868114c } x[3] array of 10 ints*/ 0x88681150 x[4] sizeof(a) == 10 * sizeof(int) == 40; ? 0x88681154 Static initialization: char letters[4] = {'a', 'q', 'e', 'r'}; z No runtime checking of array bounds z Behaviour of exceeding array bounds is “undefined” Æ program might appear to work Initialization loop: Æ program might crash for(i = 0; i < N; i++) { Æ program might do something apparently random a[i] = 0; } 13 14

Arrays Pointers

• Warning: It is the programmer's • A pointer is a higher-level version of an address. responsibility to keep track of the size of • A pointer has type information. an array! • Often define a maximum size. int i; int *p; /* declare p to point to type int */ • Pre-processor directives are used for *p = i; /* dereference p – set what p points to*/ constants: p = &i /* Give p the value of the address of i*/ char *c = p; /* Warning: initialization from – E. g., #define MAXSIZE 30 incompatible pointer type */

15 16 Important! A picture int i = 19; 0x80493e0 19 • int *p; int *p; int *q; • Memory is allocated to store the pointer *p = i; /*error*/ q = &i • No memory is allocated to store what the 0x80494dc ? pointer points to! 0x80494e0 0x80493? e0 • Also, p is not initialized to a valid address Symbol Table or null. i 0x80493e0 • I.e., *p = 10; is wrong unless memory p 0x80494dc has been allocated and p set to point to it. q 0x80494e0

17 18

A picture 0x80493e0 19 int i = 19; int *p; int *q; q = &i 0x80494dc 0x8049530 p = (int *)malloc(sizeof(int)); *p = i; 0x80494e0 0x80493e0 Symbol Table i 0x80493e0 0x8049530 19 p 0x80494dc q 0x80494e0

19