CS222

1. Week 5 - Monday CS222

2. Last time • What did we talk about last time? • Processes • Lab 4

3. Questions?

4. Project 2

5. Quotes A C program is like a fast dance on a newly waxed dance floor by people carrying razors. WaldiRavens

6. Arrays

7. Declaration of an array • To declare an array of a specified type with a given nameand a given size: • Example with a list of type int: type name[ size ]; int list[ 100 ];

8. Differences from Java • When you declare an array, you are creating the whole array • There is no second instantiation step • It is possible to create dynamic arrays using pointers and malloc(), but we haven't talked about it yet • You must give a fixed size (literal integer or a #define constant) for the array • These arrays sit on the stack in C • Creating them is fast, but inflexible • You have to guess the maximum amount of space you'll need ahead of time

9. Accessing elements of an array • You can access an element of an array by indexing into it, using square brackets and a number • Once you have indexed into an array, that variable behaves exactly like any other variable of that type • You can read values from it and store values into it • Indexing starts at 0 and stops at 1 less than the length • Just like Java list[9] = 142; printf("%d",list[9]);

10. Length of an array • The length of the array must be known at compile time • There is no length member or length() method • It is possible to find out how many bytes an array uses with sizeof intlist[100]; int size = sizeof(list);//400 • intlength = size/sizeof(int);//100

11. Arrays start filled with garbage • When you create an array, it is not automatically filled with any particular value • Inside the array (like any variable in C) is garbage • With regular variables, you might get a warning if you use a variable before you initialize it • With an array, you won't

12. Explicit initialization • Explicit initialization can be done with a list: • You can omit the size if you use an explicit initialization because the compiler can figure it out int primes[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 }; char grades[] = { 'A', 'B', 'C', 'D', 'F'};

13. memset() • The C standard library has a function called memset() that can set all the bytes in a chunk of memory to a particular value • Using it is guaranteed to be no slower than using a loop to initialize all the values in your array • It usually uses special instructions to set big chunks of memory at the same time intvalues[100]; memset(values, 0, sizeof(int)*100); //zeroes out array char letters[26]; • memset(letters, 'A', sizeof(char)*26); • //sets array to all 'A's

14. memcpy() • memset() is mostly useful for initialization (and usually only for zeroing things out) • memcpy() is a fast way to copy values from one array to another • Again, it's at least as fast as using your own loop • Again, it's somewhat dangerous since it lets you write memory places en masse intcubes[100]; int copy[100]; inti = 0; for( i = 0; i < 100; i++) cubes[i] = i*i*i; • memcpy(copy, cubes, sizeof(cubes));

15. Passing arrays to functions • Using an array in a function where it wasn't created is a little different • You have to pass in the length • The function receiving the array has no other way to know what the length is • sizeof will not work because it is based on what is known at compile time • The function should list an array parameter with empty square brackets on the right of the variable • No brackets should be used on the argument when the function is called • Like Java, arguments are passed by value, but the contents of the array are passed by reference • Changes made to an array in a function are seen by the caller

16. Array to function example • Calling code: • Function: intvalues[100]; inti = 0; for( i = 0; i < 100; i++ ) values[i] = i + 1; reverse(values, 100); void reverse(int array[], intlength) { intstart = 0; intend = length – 1; inttemp = 0; while( start < end ) { temp = array[start]; array[start++] = array[end]; array[end--] = temp; } }

17. Returning arrays • In C, you can't return the kind of arrays we're talking about • Why? • They are allocated on the stack • When a function returns, all its memory disappears • If you dynamically allocate an array with malloc(), you can return a pointer to it

18. Array Memory

19. Memory • An array takes up the size of each element times the length of the array • Each array starts at some point in computer memory • The index used for the array is actually an offset from that starting point • That’s why the first element is at index 0

20. A look at memory • We can imagine that we have an array of type int of length 10 • Let’s say the array starts at address 524 524 528 532 536 540 544 548 552 556 560 12 43 -9 6 789 0 -23 23 10 6 0 1 2 3 4 5 6 7 8 9 Addresses Indexes

21. Multidimensional arrays • It is legal to declare multidimensional arrays in C • They'll work just as you would expect • Except! You have to give the second dimension when passing to a function (otherwise, it won't know how big of a step to take when going from row to row) char board[8][8]; void clearBoard( char board[][8]) { inti = 0; intj = 0; for( i = 0; i < 8; i++ ) for( j = 0; j < 8; j++ ) board[i][j] = ' '; }

22. Array example • Write a program that reads an integer from the user saying how many values will be in a list • Assume no more than 100 • If the user enters a value larger than 100, tell them to try a smaller value • Read these values into an array • Find • Maximum • Minimum • Mean • Variance • Median • Mode

23. Compiling Multiple Files

24. Components • C files • All the sources files that contain executable code • Should end with .c • Header files • Files containing extern declarations and function prototypes • Should end with .h • Makefile • File used by Unix make utility • Should be named either makefile or Makefile

25. C files • You can have any number of .c files forming a program • Only one of them should have a main() function • If the functions in a .c file will be used in other files, you should have a corresponding .h file with all the prototypes for those functions • whatever.c should have a matching whatever.h • Both the .c file that defines the functions and any that use them should include the header

26. Header files • Sometimes header files include other header files • For this reason, it is wise to use conditional compilation directives to avoid multiple inclusion of the contents of a header file • For a header file called wombat.h, one convention is the following: #ifndef WOMBAT_H #define WOMBAT_H //maybe some #includes of other headers //lots of function prototypes #endif

27. Compiling • When compiling multiple files, you can do it all on one line: • Alternatively, you can compile files individually and then link them together at the end gccmain.cutility.cwombat.c –o program gcc –c main.c gcc –c utility.c gcc –c wombat.c gccmain.outility.owombat.o –o program

28. Makefile • Compiling files separately is more efficient if you are only changing one or two of them • But it's a pain to type the commands that recompile only the updated files • That's why makefiles were invented • program: main.outility.owombat.o • gccmain.outility.owombat.o –o program • main.o: main.cutility.hwombat.h • gcc–c main.c • utility.o: utility.cutility.h • gcc–c utility.c • wombat.o: wombat.cwombat.h • gcc–c wombat.c • clean: • rm –f *.o program

29. Systems Programming

30. Kernel • When people say OS, they might mean: • The whole thing, including GUI managers, utilities, command line tools, editors and so on • Only the central software that manages and allocates resources like the CPU, RAM, and devices • For clarity, people use the term kernel for the second meaning • Modern CPUs often operate in kernel mode and user mode • Certain kinds of hardware access or other instructions can only be executed in kernel mode

31. What does the kernel do? • Manages processes • Creating • Killing • Scheduling • Manages memory • Usually including extensive virtual memory systems • File system activities (creation, deletion, reading, writing, etc.) • Access to hardware devices • Networking • Provides a set of system calls that allow processes to use these facilities

32. Shells • A shell is a program written to take commands and execute them • Sometimes called a command interpreter • This is the program that manages input and output redirection • By default, one of the shells is your login shell, the one that automatically pops up when you log in (or open a terminal) • It's a program like any other and people have written different ones with features they like: • sh The original Bourne shell • csh C shell • kshKorn shell • bash Bourne again shell, the standard shell on Linux

33. Users and groups • On Linux, every user has a unique login name (user name) and a corresponding numerical ID (UID) • A file (/etc/passwd) contains the following for all users: • Group ID: first group of which the user is a member • Home directory: starting directory when the user logs in • Login shell • Groups of users exist for administrative purposes and are defined in the /etc/group file

34. Superusers • The superuser account has complete control over everything • This account is allowed to do anything, access any file • On Unix systems, the superuser account is usually called root • If you are a system administrator, it is recommended that you do not stay logged in as root • If you ever get a virus, it can destroy everything • Instead, administrators should log in to a normal account and periodically issue commands with elevated permission (often by using sudo)

36. Single file system • In Windows, each drive has its own directory hierarchy • C: etc. • In Linux, the top of the file system is the root directory/ • Everything (including drives, usually mounted in /mnt) is under the top directory • /bin is for programs • /etc is for configuration • /usr is for user programs • /boot is for boot information • /dev is for devices • /home is for user home directories

37. Files • There are regular files in Linux which you can further break down into data files and executables (although Linux treats them the same) • A directory is a special kind of file that lists other files • Links in Linux are kind of like shortcuts in Windows • There are hard links and soft links (or symbolic links) • File names can be up to 255 characters long • Can contain any ASCII characters except / and the null character \0 • For readability and compatibility, they should only use letters, digits, the hyphen, underscore, and dot • Pathnames describe a location of a file • They can start with / making them absolute paths • Or they are relative paths with respect to the current working directory

38. File permissions • Every file has a UID and GID specifying the user who owns the file and the group the file belongs to • For each file, permissions are set that specify: • Whether the owner can read, write, or execute it • Whether other members of the group can read, write, or execute it • Whether anyone else on the system can read, write, or execute it • The chmod command changes these settings (u is for owner, g is for group, and o is everyone else)

39. File I/O • All I/O operations in Linux are treated like file I/O • Printing to the screen is writing to a special file called stdout • Reading from the keyboard is reading from a special file called stdin • When we get the basic functions needed to open, read, and write files, we'll be able to do almost any kind of I/O

40. Processes • A process is a program that is currently executing • In memory, processes have the following segments: • Text The executable code • Data Static variables • Heap Dynamically allocated variables • Stack Area that grows and shrinks with function calls • A segmentation fault is when your code tries to access a segment it's not supposed to • A process generally executes with the same privileges as the user who started it

41. System calls • A system call is a way to ask the kernel to do something • Since a lot of interesting things can only be done by the kernel, system calls must be provided to programmers via an API • When making a system call, the processor changes from user mode to kernel mode • There is a fixed number of system calls defined for a given system

42. glibc • The most common implementation of the Standard C Library is the GNU C Library or glibc • Some of the functions in the glibc perform systems calls and some do not • There are slight differences between the versions of the glibc • Microsoft also has an implementation of the Standard C Library that doesn't always behave the same

43. Handling system errors • There are no exceptions in C • Instead, when a system call fails, it usually returns -1 • To find out why the system call failed • First, make sure you #include <errno.h> • Then check the value of the integer errno in your program after the system call fails • Use the man pages to determine what a given value of errno means • The perror() function is often used to print errors instead of printf() • It sends the output to stderr instead of stdout

44. Error handling example #include<stdio.h> #include<fcntl.h> #include<errno.h> int main() { intfd= open("eggplant.txt", O_WRONLY | O_CREAT | O_EXCL); if(fd == -1) { perror("Failure to create file: "); if( errno == EACCES ) perror("Insufficient privileges\n"); else if( errno == EEXIST ) perror("File already exists\n"); else perror("Unknown error\n"); exit(EXIT_FAILURE); } return 0; }

45. System types • C has a feature called typedef which allows a user to give a new name to a type • System types are often created so that code is portable across different systems • The most common example is size_t, which is the type that specifies length • It's usually the same as unsigned int • There are named types for process IDs (pid_t), group IDs (gid_t), user IDs (uid_t), time (time_t), and many others

46. Scope

47. Scope • The scope of a name is the part of the program where that name is visible • In Java, scope could get complex • Local variables, class variables, member variables, • Inner classes • Static vs. non-static • Visibility issues with public, private, protected, and default • C is simpler • Local variables • Global variables

48. Local scope • Local variables and function arguments are in scope for the life of the function call • They are also called automatic variables • They come into existence on the stack on a function call • Then disappear when the function returns • Local variables can hide global variables

49. Global scope • Variables declared outside of any function are global variables • They exist for the life of the program • You can keep data inside global variables between function calls • They are similar to static members in Java intvalue; void change() { value = 7; } intmain() { value = 5; change(); printf("Value: %d\n", value); return 0; }

50. Use of global variables • Global variables should rarely be used • Multiple functions can write to them, allowing inconsistent values • Local variables can hide global variables, leading programmers to think they are changing a variable other than the one they are • Code is much easier to understand if it is based on input values going into a function and output values getting returned