Instructor: Ioannis A. Vetsikas E-mail: vetsikas@cs.cornell.edu CS113 Introduction to C Instructor: Ioannis A. Vetsikas E-mail: vetsikas@cs.cornell.edu Lecture 9 : September 13

const Type Qualifier Can be applied to the declaration of any variable – even function parameters Specifies that the variable’s value won’t be changed; for arrays it means that the elements will not be altered… const double pi = 3.14159; const char msg[] = “warning: ”; int strlen(const char[]); const int a; /* a is const int */ const int *b; /* b is pointer to const int */ int * const c; /* c is a const pointer to int */ const int * const d; /* d is a const pointer to const int */

enum In C, enum types are just int (starting usually from 0) enum day { SUN, MON, TUE, WED, THU, FRI, SAT }; enum boolean {FALSE, TRUE}; enum {FALSE, TRUE}; same as #define FALSE 0; #define TRUE 1; enum {AA=1, BB, CC}; The constant are numbered sequentially Can now define: enum day d; etc. Note: Enumerated constants cannot appear in two enums Enumeration tags form their own namespace enum boolean {FALSE, TRUE} boolean;

Scope of Type Definition Depending on the placement there is file or block scope usually… This applies to all kinds of definitions (e.g. also to enum, struct, typedef) int a=3; { int a=4; } printf(“a=%d\n”); What is the output?

Storage classes Storage class auto Every variable and function has a storage class Four storage classes: auto, extern, register and static Storage class auto Variables within functions or blocks default to automatic (unless defined otherwise), but one can also declare this explicitly: auto int i=1; Memory allocated upon entering a block is released at exit from block. So values are not kept between invocations.

Storage class static When variables declared within a block are defined as static then they retain their value between consecutive invocations. Thus static variables might be useful for debugging purposes When a global variable is declared static then it is not accessible from another file! See extern for more details on when a variable is accessible from other files…

Storage class register This is a relic from the “old times” I suggest that you not use it at all It tells the compiler to use a register in order to store the variable, instead of a space in memory Defaults to auto if the compiler decides otherwise Most modern compilers will ignore this statement and optimize the code as they see fit anyway! Hence you cannot point to a register class variable

Storage class extern Variables defined outside functions (global) and all functions themselves have default class extern extern tells the compiler to look for a variable elsewhere (out of the current scope) either in the same file or in another file (no new memory used) file1.c: int a=1, b=2, c=3; int f(); int main() { printf(“%3d%3d%3d%3d\n”, f(), a, b, c); } file2.c: inf f() { extern int a; int b, c; a=b=c=4; return a+b+c;}

Initialization Extern and static variables can only be initialized with a constant value (think that the initialization is decided at compile time) and the initialization happens only once. If no value is given at declaration then they are initialized to zero (in whatever form applicable) Register and auto variable are initialized every time the block where they are defined is entered and they can have expression to be evaluated too in the initialization. If no value is given then they may not be initialized and thus have junk values int i=x*y; static int j=4;

Header files When a program includes many files we might want the definitions and declarations to be in just one place Also useful for libraries, since you just include the header and have all the functions and definitions available (e.g. stdio.h) Use #include to include this files into the code If you make your own library remember to include it when you compile your code E.g. use #include “library.h” in main.c and compile using gcc main.c library.c

Command line arguments int main (int argc, char *argv[]) argc: number of command line arguments argv: array of string (each string an argument) First argument (argv[0]) is always the name of the program After last argument pointer there is always a null pointer (argv[argc]=NULL) E.g. if we type c:main.exe hello, world 3 then argc=4 and argv[0]=“c:main.exe” and argv[1]=“hello,” and argv[2]=“world” and argv[3]=“3” and argv[4]=NULL

Chapters covered from K&R Chapter 4 (all except 4.11) Chapter 5 (all except 5.11-5.12) Chapter 6 (all except 6.9)