CSc 352: Basic C Programming

Transcription

1 CSc 352: Basic C Programming

2 What s new relative to Java? Some syntactic differences a lot of the basic syntax is similar assignment, conditionals, loops, etc. The biggest differences are conceptual procedural rather than object-oriented no notion of classes and inheritance hierarchies much closer to the machine debugging sometimes requires thorough understanding of what s going on at the machine level explicit dynamic memory management (malloc, free) pointers 2

3 What s new relative to Java? No Garbage Collection No array boundary protection You have much more control This means you can write faster programs This also means code can be hard to debug and security vulnerabilities are much more likely C is generally compiled to machine code (java programs require java machine to be installed) 3

4 The program development process Simple programs (single source file) source code compiler gcc executable code C program created with an editor ASCII text human-readable machine code created using compiler binary file not human-readable

5 The program development process More complex programs (many source files) source files compiler object files file1.c gcc -c file1.o file2.c gcc -c file2.o linker executable code file n.c gcc -c file n.o

6 gcc The c compiler we ll be using on lectura in this class is gcc. gcc can create an executable file from a text file containing C code (called a source file) The source code file should be named <file name>.c The.c indicates that the file contains C source code gcc has MANY possible options, but in this class there are a couple we will almost always use: 6

7 gcc -Wall tells gcc to print out most warning messages your code must show no warnings when compiled with this option -o <file name> This tells gcc to name the executable file <file name> generally you will name the executable the same name as the source code file without the.c 7

8 gcc For example, if you have a C source code file called project2.c, then typing gcc Wall o project2 project2.c will hopefully create an executable file called project2 If the -o option is omitted, gcc will name the executable file a.out 8

9 A simple program 9

10 A simple program a simple C program that prints out hello followed by a return Points to note: execution begins at main(): every program must have one printf() is a standard C library routine the comic forgot the \n 10

11 A simple program invoking the C compiler compiler warning executable file produced by compiler executing the program 11

12 Gcc options: -Wall gcc Wall generates warnings on questionable constructs if no return type is specified for a function, it defaults to int need to supply prototype for printf 12

13 Fixing the compiler warnings specifies prototype for printf() specifies return type explicitly 13

14 Summary execution starts at main() every program should have one the return type for a function defaults to int the return type should be specified explicitly: good style You need to supply prototypes for functions imported from elsewhere (e.g., standard libraries). specified using #include 14

15 A simple program revisited 15

16 Gcc options: -Wall gcc Wall generates warnings on questionable constructs if no return type is specified for a function, it defaults to int need to supply prototype for printf 16

17 Fixing the compiler warnings How do we know what file to include? 17

18 The man command (review) The man command displays documentation for commands (and more). Here is an abridged example the "man page" for cat: % man cat CAT(1) CAT(1) User Commands NAME cat - concatenate files and print on the standard output SYNOPSIS cat [OPTION]... [FILE]... DESCRIPTION Concatenate FILE(s), or standard input, to standard output. -A, --show-all equivalent to vet... With no FILE, or when FILE is -, read standard input.

19 Manual sections The UNIX "manual" is divided into these sections: (from man man) 1 User commands 2 System calls (functions provided by the kernel) 3 Library calls (functions within program libraries) 4 Special files (usually found in /dev) 5 File formats and conventions eg /etc/passwd 6 Games 7 Miscellaneous (including macro packages and conventions), e.g. man(7), groff(7) 8 System administration commands (usually only for root) 9 Kernel routines [Non standard] Recall that man cat showed CAT(1). That "(1)" tells us that cat is a user command. man malloc shows MALLOC(3). That "(3)" tells us that malloc is a library function.

20 man scanf Header file 20

21 man printf Where is the header file? 21

22 man printf bottom There is both a user command and library call called printf 22

23 man 3 printf 23

24 Simple declarations and statements two uninitialized global variables, x and y, of type int a variable, z, of type int, that is local to the function main; initialized to 12 print format specifier: %d = print an integer in decimal format simple arithmetic expressions and assignment statements 24

25 Quick aside: Formatted Output: printf() takes a variable no. of arguments: printf( fmtstr, arg 1, arg 2,, arg n ) text: Ch. 3 Sec. 3.1 fmtstr is a string that can contain conversion specifiers the no. of conversion specifiers should be equal to n regular (non-%) characters in fmtstr written out unchanged each conversion specifier is introduced by % this is followed by additional (optional) characters specifying how wide the output is to be, precision, padding, etc. the conversion specifier indicates how the specified value is to be interpreted: d = decimal integer, e.g.: printf( value = %d\n, n); x = hex integer, e.g.: printf( hex value of %d is %x\n, x, x); f = floating point number, e.g.: printf( area = %f\n, A); 25

26 Simple conditionals, while loops if statement while statement error message: sent to stderr return value communicates normal/abnormal execution 26

27 For loops 27

28 Function calls, recursion function call recursion 28

29 Function calls (cont d) What happens when this printf() is called? the arguments are evaluated (as in all C function calls) factorial(6) evaluated when factorial() returns, the printf is executed: printf(, 720) This causes the string factorial(6) = 720 to be printed out 29

30 Formatted Input: scanf() takes a variable no. of arguments: scanf( fmtstr, arg 1, arg 2,, arg n ) text: Ch. 3 Sec. 3.2 fmtstr is a string that can contain conversion specifiers the no. of conversion specifiers should be equal to n arg i are locations where values that are read in should be placed each conversion specifier is introduced by % similar to conversions for printf execution behavior: uses format string to read in as many input values from stdin as it can return value indicates the no. of values it was able to read return value of EOF (-1) indicates no further input ( end of file ). 30

31 scanf() Specifying where to put an input value: in general we need to provide a pointer to the location where the value should be placed for a scalar variable X, this is typically written as &X a pointer is needed because the calling function gives the called function a copy of the argument 31

32 scanf() Examples: scanf( %d, &n) : reads a decimal value into a variable n scanf( %d %d %d, &x, &y, &z) : reads three decimal values separated by spaces and put them into variables x, y, z respectively suppose the input contains the values 12, 3, 71, 95, 101 separated by spaces. Then: x 12; y 3; z 71; return value = 3 suppose the input contains the values 19, 23. Then: x 19; y 23; z is unassigned; return value = 2 32

33 Exercise Which of these are correct? int x; printf( %d\n, x); int x, y; printf( %d, x, y); int x, y, z; printf( %d %d %d, x, y, z); int x, y; printf(%d, %d, x, y); int f(int n); printf( f(%d)= %d\n, n, f(n)); int x, y; printf( %d %d\n, x); 33

34 Exercise Which of these are correct? int x; printf( %d\n, x); int x, y; printf( %d, x, y); int x, y, z; printf( %d %d %d, x, y, z); int x, y; printf(%d, %d, x, y); int f(int n); printf( f(%d)= %d\n, n, f(n)); int x, y; printf( %d %d\n, x); X wrong no. of arguments X format specifier needs to be a string... X wrong no. of arguments 34

35 Exercise Which of these are correct? int x; scanf( %d\n, x); int x, y; scanf( %d %d, &x, &y); int x, y, z; scanf( %d %d %d, &x, &y, &z); int x, y; scanf(%d, %d, &x, &y); int f(int n); scanf( f(%d)= %d\n, &n, &f(n)); int x, y; scanf( %d %d\n, &x); 35

36 Exercise Which of these are correct? int x; scanf( %d\n, x); int x, y; scanf( %d %d, &x, &y); int x, y, z; scanf( %d %d %d, &x, &y, &z); int x, y; scanf(%d, %d, &x, &y); int f(int n); scanf( f(%d)= %d\n, &n, &f(n)); int x, y; scanf( %d %d\n, &x); X need &x X format specifier needs to be a string... X &f(n) doesn t make sense X wrong no. of arguments 36

37 Quick comment on the exercises You should understand the mistakes, and learn to spot them as well, but every issue that was illustrated will either be a compiler error or warning. 37

38 Reading inputs: ^D and end-of-file int main() { while (scanf( %d, &n)!= EOF) {... } } source code the system indicates EOF when there is no more input to read input from file./a.out < infile gcc executable Assuming the input is good, the program will above will terminate after all of the data from the file infile is read. How do you indicate the end of file (EOF) when input comes from the keyboard? 38

39 Reading inputs: ^D and end-of-file typing ctrl-d ends input stream (EOF) keyboard input int main() { while (scanf( %d, &n)!= EOF) {... } } gcc source code the system indicates EOF when there is no more input to read input from file./a.out < infile If the program above is taking input from the keyboard, pressing ctrl-d will send an EOF causing the loop condition to fail, and the program to exit executable 39

40 Reading inputs: ^C, ^D, and end-of-file keyboard input infinite loop int main() { while (scanf( %d, &n) < 2) {... } } gcc source code input from file executable./a.out < infile control-c kills the process 40

41 Assignment: l-values increment x twice? what s going on? 41

42 Assignment: l-values The left-hand-side (destination) of an assignment has to be a location this is referred to as an l-value Consider the expression x the outer ++ operator attempts to increment x++ but x++ is an expression that has no location! error x has a location and a value the ++ operator assigns the value x+1 to the location of x the expression x ++ has the new value of x, but no location (as a side-effect, x gets incremented) 42

43 What can be an l-value? l-values: variables of arithmetic type (int, char, float, etc.) array elements: x[y] also: structs, unions, pointers, etc. (to be discussed later) operations involving pointers (to be discussed later) Not l-values: functions result of an assignment value returned by a function call 43

44 Expressions and Statements A statement is a command to be executed when a program is run printf( hello\n ); x = 5; An expression is something which computes to a value 5 x + y x == 8 44

45 Expressions and Statements (continued) In c, most statements are expression statements which are expressions followed by a semi-colon. The execution of such statements is simply their evaluation, with any side effects Loosely, a side effect is an action that happens while evaluating an expression Examples without side effects (the compiler will tell you that these have no effect. 5; x + y; Examples with side effects (next page) 45

46 Expressions and Statements Expressions with side effects when evaluated scanf( %d, &i) evaluates to the number of variables assigned values side effect: stores value in i x++ x = 8 evaluates to x side effect: stores the value of x + 1 in x evaluates to 8 side effect stores the value 8 in x 46

47 Expressions and Statements So the assignment = in c is really an operator that returns the value to the right and has a side effect of storing that value in the variable to the left This is why x = y = z = 1 is legal in c. (The assignment operator is evaluated from left to right). a = b += c++ - d + --e / -f is legal, well defined, but BAD programming (DON T DO IT) Would you want to evaluate it? There are many legal C expressions that you should not use because they are not clear (many will cause compiler warnings) if in doubt, be less clever. 47

48 Another bad example a = 5; c = (b = a + 2) (a = 1); This is legal but NOT well defined. Sometimes it will evaluate to 6 and sometimes 2. Even on the same machine. There is no reason to ever devise such constructions (except to demonstrate bad behavior, or to compete in the obfuscated C contest --- see 48

49 A Common C Error if (x = 5) {... } I had meant x == 5, but I typed it wrong. But in c, this is still legal. x = 5 stores the value of 5 in x and evaluates to 5 5 is considered true by c (everything not 0 is true), so the if statement ALWAYS executes. Fortunately, the Wall option for gcc will warn about this error. 49

50 Primitive data types: Java vs. C C provides some numeric types not available in Java unsigned The C language provides only a minimum size guarantee for primitive types the actual size may vary across processors and compilers Originally C did not have a boolean type faked it with ints: 0 false; non-0 true hence you will see code of the form: if ( (x = getnum()) ) { } // if value read is nonzero C99 provides some support for booleans 50

51 Primitive numeric types: Java vs. C Java C C size Comments byte short int long unsigned char signed char typically (and at least) 8 bits typically (and at least) 8 bits char typically (and at least) 8 bits signedness is implementation dependent unsigned short int signed short int typically (and at least) 16 bits same as unsigned short unsigned int 16 or 32 bits the natural size for the machine signed int same as unsigned int unsigned long int at least 32 bits, often 64 signed long int == unsigned long Keywords in gray may be omitted 51

52 Signed vs. unsigned values Essential idea: signed : the highest bit of the value is interpreted as the sign bit (0 = positive; 1 = negative) unsigned : the highest bit not interpreted as sign bit For an n-bit value: signed: value ranges from 2 n-1 to 2 n-1 1 unsigned: value ranges from 0 to 2 n 1 Right-shift operator ( >> ) may behave differently unsigned values: 0s shifted in on the left (signed) negative values: bits shifted in is implementation dependent 52

53 Booleans Originally, C didn t have a separate boolean type truth values were ints: 0 = false; non-0 = true still commonly used in programming C99 provides the type _Bool _Bool is actually an (unsigned) integer type, but can only be assigned values 0 or 1, e.g.: _Bool flag; flag = 5; /* flag is assigned the value 1 */ C99 also provides boolean macros in stdbool.h: #include <stdbool.h> bool flag; /* same as _Bool flag */ flag = true; 53

54 Arithmetic operators: Java vs. C Most of the common operators in C are as in Java e.g.: +, ++, +=, -, -=, *, /, %, >>, <<, &&,, C doesn t have operators relating to objects: new, instanceof C doesn t have >>> (and >>>=) use >> on unsigned type instead 54

55 prototypes recall: 55

56 warnings when compiled gcc Wall generates warnings on questionable constructs if no return type is specified for a function, it defaults to int need to supply prototype for printf 56

57 Fixing the compiler warnings What does this really do? 57

58 prototypes What happens when we try to compile this simple program? 58

59 prototypes (cont) When we try to compile the program this happens: This looks a lot like the warning we got when we didn t have the #include <stdio.h> 59

60 prototypes When the compiler sees this, it wants to know what addint is. 60

61 Fix One Defined before it is used. 61

62 Fix Two prototype added 62

63 Functions from special libraries Some library code is not linked in by default Examples: sqrt, ceil, sin, cos, tan, log, [math library] These require specifying to the compiler/linker that the math library needs to be linked in. You do this by adding lm at the end of the compiler invocation: gcc Wall foo.c lm linker command to add math library Libraries that need to be linked in explicitly like this are indicated in the man pages. 63

64 void We ve said in C there are no procedures just functions. Every function returns a value, but what if I don t need/want a value returned? For example, suppose I have a function that just prints hi. I can declare that function as type void 64

65 void 65

66 void Function returns no value 66

67 void Function also has no parameters. 67

68 void Optional way to indicate that the function also has no parameters. 68

69 printing to stderr The assignments ask you to print error messages to standard error. To do this you use fprintf fprintf works like printf except that printf always prints to stdout and you tell fprintf where to print: To print an error to stderr: fprintf(stderr, "I'm an error\n"); 69

70 printing to stderr Note that printf("hi!\n"); and fprintf(stdout,"hi\n"); do exactly the same thing. 70

71 Returning from an error Remember that in the assignments, when your program exits, if it has seen an error it should not return 0. The catch is sometimes your program will continue to run after getting a bad input. It must remember it has seen the error and return the correct value. 71

72 Characters and strings A character is of type char (signed or unsigned) C99 provides support for wide characters strings : an array of characters terminated by a 0 character ( NULL : written \0 ) string operations are provided through libraries (they are not part of the language) C arrays don t have bound-checking careless programming can give rise to memory-corruption errors 72

73 Example of string manipulation declares an array of chars print out a string (%s) the input analog to printf: read a value into str (%s = string ) 73

74 More strings waits for input (from stdin) typed in on keyboard: stdin program output (stdout) end-of-file indicated by typing Ctrl-D 74

75 More strings Oops! this means the program tried to access an illegal memory address 75

76 limiting string size using scanf() So how can we avoid the errors on the previous slide? By using the conversion %ns with scanf() the size of the string read is limited to n Be sure the buffer being read into is size n + 1 to allow for the null terminator at the end. 76

77 Protecting String Inputs limits the number of chars input to 31 77

78 The new output program only read first 31 chars in the string The remainder of the string was read the next time through the loop. 78

79 More detail So strings are arrays of characters (that end with a NULL ( \0 )) But what is a character? A character is a byte of data. This can be viewed either as a (small) number or as a symbol from the ASCII table. To specify a character in C use single quotes: char c; c = b ; 79

80 So even though characters can be thought of as letters, digits, or symbols, you can also use addition, subtraction, multiplication, etc. on them. You can also compare them: A < G evaluates to true. The uppercase letters and lower case letters run in a sequence. i.e.: c + 1 == d 80

81 How can we use this to write a test if a character c is a capital letter? 81

82 How can we use this to write a test if a character c is a upper case letter? if (c >= A && c <= Z ) { // if c is an uppercase letter then we go here } Let s write a function to convert all the lowercase letters of a string to upper case. 82

83 The completed program 83

84 Initializing Strings char str1[50] = I am the walrus. //puts string in str char str2[] = I am the walrus. // allocates array of size 17 and stores string same as char str2[17] = I am the walrus. char *str3 = I am the walrus. //points str3 at the STRING CONSTANT I am the walrus. //it is legal to read str3 but not to write to the memory //it points to! 84

85 Reading a line at a time scanf is nice. It parses the input and converts it to integers, floating points, etc. Sometimes we want to read a line at a time from the input. scanf is not so great for that. Fortunately there are functions that do read in a line at a time from the input. Two of them are: getline() fgets() 85

86 getline 86

87 getline 87

88 getline (code example) #include <stdio.h> #include <stdlib.h> int main(void) { int block = 1; char* line = NULL; size_t len = 0; while (getline(&line, &len, stdin)!= EOF) { /* Because we read as many characters as needed (subject to available * memory), we will generally have a return in line, and so we do not * want one in the printf(). */ printf("line %03d: %s", block, line); block++; } /* * When we are done with it, we free line. This will become much more clear * in a few weeks. */ free(line); } return 0; 88

89 getline The nice thing about getline is that it allocates the memory you need for you. You don t have to worry about the input being to big to fit in the memory you ve allocated. The bad thing about getline is that it is a gnu extension and is not available for all systems. (It is available on most systems including lectura though) 89

90 fgets 90

91 fgets 91

92 fgets (coding example) #include <stdio.h> int main(void) { int block = 1; char buff[ 10 ]; /* * Unfortunately, fgets() returns NULL both on EOF and on error. We could * use ferror() and feof() to distinguish these, but for the example we will * assume that error on read is rare enough for demos. */ while (fgets(buff, sizeof(buff), stdin)!= NULL) { /* When we get to ends of lines, we will output an extra return * because fgets() puts the end of line into the buffer. */ printf("block %03d: %s\n", block, buff); block++; } } return 0; 92

93 fgets The nice thing about fgets() is that it s a standard c function and should be available on all systems. The bad thing is that you have to provide the memory for the function to store the input lines into. Notice that one of the parameters to fgets is the maximum number of characters to be read in. (See how this is slightly different than scanf?) There is a fprintf() and printf() if I want to just print to stdout. Likewise there is a fscanf() to read from any stream and scanf() to just read from stdin. fgets() lets me read from any stream, can I use gets() when I just want to read from stdin? 93

94 Don t use gets()! Even the manual page says not to. So why is it in the library? 94

95 Don t use gets()! Even the manual page says not to. The reason for this confusion is that gets() is not simply fgets() with the stream argument set to stdin (the buffer size argument gets dropped). This is different from printf/fprintf and scanf/fscanf Flaws like this are hard to repair because significant code basis might break if you fixed them. 95