IPC144 Session 18 The C Programming Language

1

IPC144Session 18

The C Programming Language

2

Objectives

List the file open and close functions, with their parameters and return valuesList the three modes to open a file inExplain the behaviour of the computer when opening existing and non-existent files under these modesUse the file commands to read formatted and unformatted data from text filesTo define the three levels of scopeTo show the scope limits of variables within a C programShow the syntax to declare a structurePass structures to functions

3

The C Language

FilesA computer will loose the contents of memory when it is powered off

This can be rather inconvenient if there are megabytes of data that need to be entered every time the machine is powered up

The solution is to store the data on a media that does not easily loose its data, especially when powered off

The data is arranged on this media in FILES

4

The C Language

FilesA very common media used to store files is disks

There are two types of files: Binary and Text

Binary files consist of data that is in a format that the computer can easily read, but that people typically have a harder time understandinge.g. an executable file, a database file

Text files are a special case of binary filesText files consist of data that people can easily read

Text files contain lines of data that are terminated by a new-line character (the '\n' character we have seen)e.g. a C source code file

5

The C Language

FilesTry thinking of a file as a string

There will be a starting position and eventually an ending position that corresponds to the null terminator that we have seen in strings

The file equivalent to the strings null terminator is an End-Of-File marker (EOF)

When you are manipulating a string, you may have some sort of index into the string that points to the current character

Consider the following code that prints each character of a string on the same line:

6

The C Language

Files#include <stdio.h>#include <string.h>#define STRING_SIZE 50int main(void){ char aStringOfData[STRING_SIZE + 1]; int i; /* an index into the string */ strcpy(aStringOfData, “This is a test string”);

for (i = 0; i < strlen(aStringOfData); i = i + 1) { printf(“%c”, aStringOfData[i]); }

printf(“\n”); /* just to finish off the line */}

7

The C Language

Files#include <stdio.h>#include <string.h>#define STRING_SIZE 50#define STRING_EOF 0 /* end of string indicator for demo */int main(void){ char aStringOfData[STRING_SIZE + 1]; int i; /* an index into the string */ strcpy(aStringOfData, “This is a test string”);

i = 0; while (aStringOfData[i] != STRING_EOF) { printf(“%c”, aStringOfData[i]);

i = i + 1; }

printf(“\n”); /* just to finish off the line */}

8

The C Language

StreamsThere needs to be a way to create a connection between your program and a stream of data

This is accomplished by creating a pointer to the data stream

Oh no, more pointers

When defining a pointer to an int, we declare it as:int *ptrToInt;

We specify the data type (int) as well as the pointer variable ptrToInt

9

The C Language

StreamsWhen defining a pointer to a stream, we declare it as:FILE *ptrToStream;

e.g. FILE *fpInput;

Now that the pointer has been declared, how do we assign it to a stream?

We use the fopen function:

FILE *fopen(char *fileName, char *access);

10

The C Language

StreamsFILE *fopen(char *fileName, char *access);

This function returns: a pointer to the stream if it was successfully openedNULL if the stream was not successfully opened

The filename is either a pointer to a string or a literal passed to the functione.g.:

fp = fopen(“bank.txn”, “r”);OR

strcpy(fileName, “bank.txn”);fp = fopen(fileName, “r”);

The access string defines how the stream will be opened (more about access later)

11

The C Language

StreamsSome additional terminology for files and streams

When we compared a file to a string, we used used an index into the string (the variable 'i' for example) to keep track of where in the string we were

In the case of files there is also an 'index' that keeps track of where in the file we are- it is referred to as the 'file marker'

The operating system keeps track of the file marker

The file marker will range from the beginning of the file to the EOF (End-Of-File)

12

The C Language

StreamsSetting the file marker to the beginning of the file is like setting i = 0 when talking about strings

Setting the file marker to the end of the file (or to EOF) is like setting i = strlen(theString) when talking about strings

13

The C Language

StreamsA stream can be opened for READ or for WRITE or for APPEND

READThe file is opened for read only – the access string is “r”

The file must already exist- if the file does not exist NULL is returned by the fopen() function

If you attempt to WRITE data to this file, an error will be returned

If the file is opened successfully, the file marker is positioned at the beginning of the file

14

The C Language

WriteThe file is opened for write – the access string is “w”

If the file does not exist, it is created

If you attempt to READ data from this file, an error will be returned

If the file is opened successfully, the file marker is positioned at the beginning of the file

The successfully opened file will have all of its data deleted

15

The C Language

AppendThe file is opened for write – the access string is “a”

If the file does not exist, it is created

If you attempt to READ data from this file, an error will be returned

If the file is opened successfully, the file marker is positioned at the end of the file

In the case of a newly created file, the beginning of file and end of file are the same

16

The C Language

StreamsIn the cases above, there is no provision for UPDATING the contents of a text file

The reason is that if you were to replace a line of text in a file with a shorter line, you have no reliable way of deleting the left-over text

Conversely, if you wanted to replace a line of text with a longer line, you have no reliable way to insert space into the file to avoid overwriting the next line

17

The C Language

StreamsReplace the third line with ‘a shorter line’ (I used '<' to represent the new-line character, and ']' to represent the EOF)

this is a <long text file that<contains many lines of data<for your viewing pleasure]

You would get:

this is a <long text file that<a shorter line<lines of data<for your viewing pleasure]

18

The C Language

StreamsReplace the third line with ‘a much longer line for demonstration’

this is a <long text file that<contains many lines of data<for your viewing pleasure]

You would get:

this is a <long text file that<a much longer line for demonstration<viewing pleasure]

19

The C Language

StreamsNow that you have successfully opened a file for READ / WRITE / APPEND, how do you close it?

You use the fclose() function, the prototype is:

int fclose(FILE *filePointer);

If the fclose() function completes successfully, zero is returned

If fclose() completes unsuccessfully, EOF is returned

e.g.fclose(fp);

OR

result = fclose(fp);

20

The C Language

StreamsThis is probably a good time to point out that the C functions need to be CAREFULLY checked when using the return values

In some cases, such as fclose(), a zero is returned if the function completes SUCCESSFULLY - by definition C treats this value as FALSE

The return of zero is not necessarily wrong - it just means that there were zero errors encountered when running the function

You need to be careful how you use the return codes from functions

21

The C Language

StreamsBased on what has been discussed up to this point, write a C program that tests to see if a file called "bank.txn" exists. If it does not exist, create it. Remember to close your file at the end of the program.

22

The C Language

StreamsBased on what has been discussed up to this point, write a C program that tests to see if a file called "bank.txn" exists. If it does not exist, create it. Remember to close your file at the end of the program.

#include <stdio.h>void main(void){ FILE *fpBankFile;

fpBankFile = fopen(“bank.txn”, “r”); if (fpBankFile == NULL) { fpBankFile = fopen(“bank.txn”, “w”); if (fpBankFile == NULL) { printf(“Failed to Create bank.txn\n”); } }

fclose(fpBankFile);}

23

The C Language

StreamsHow do you read or write data to a file?

When writing formatted output to the screen, we used the printf() function

When writing unformatted output to the screen, we used the puts() function

When reading formatted input from the keyboard, we used the scanf() function

When reading unformatted input from the keyboard, we used the gets() function

Now that we are dealing with Files, we use variations of these functions

24

The C Language

StreamsThe fprintf() function is for printing formatted output to a file. Its function prototype is:

int fprintf(FILE *filePointer, char *format, ...);

As you can see, the only difference is the file pointer is now the first argument of the fprintf() function

If the function is successful, the number of characters printed is returned

If the function fails, EOF is returned

Although it may be not as meaningful to test the return code of the printf() function, the fprintf() should be tested as there is no other feedback that your program is running successfully

e.g.

fprintf(fp, “This is a number %d\n”, x);

25

The C Language

StreamsThe fputs() function is for printing unformatted output to a file. Its function prototype is:

int fputs(char *string, FILE *filePointer);

As you can see, the only difference is the file pointer is now the second argument of the fputs() function

If the function is successful, the number of characters printed is returned

If the function fails, EOF is returned

Again testing the results of the fputs() is a good idea

*puts() automatically appends a newline character at the end of the line*fputs() does not automatically append a newline character at the end of the line

e.g.fputs(mystr, fp);fputs(“Hello world\n”, fp);

26

The C Language

StreamsThe fscanf() function is for reading formatted input from a file. Its function prototype is:

int fscanf(FILE *filePointer, char *format, ...);

As you can see, the only difference is the file pointer is now the first argument of the fscanf() function

If the function is successful, the number of variables assigned to is returned

If the function fails, EOF is returned

e.g.fscanf(fp, “%d %d”, &vara, &qvar);

27

The C Language

StreamsThe fgets() function is for reading unformatted input from a file. Its function prototype is:

char *fgets(char *string, int n, FILE *filePointer);

There is an additional parameter, n, that is used to limit the number of characters that are to be read:

the computer will read n - 1 characters or until a '\n' character is detected - whichever occurs firstthis is useful to prevent a memory overrun by setting this value to the maximum size of the string- the computer will read n - 1 characters from the file, and set the nth character to '\0'if there is still data on the line, the next read will resume where previous read left off (the file marker is not advanced to the end of the line)

28

The C Language

Streamschar *fgets(char *string, int n, FILE *filePointer);

If the function completes successfully, a pointer to the string is returned

If the function does not complete successfully, NULL is returned

If the fgets() function reads a '\n' character, it is also stored

The fgets() function works better with strings than fscanf()

*gets() discards the newline character when it is read*fgets() does not discard the newline character – it is stored in the string

29

The C Language

StreamsThis is a sample of C code to open a file called test.txt for read and display its contents on the screen:

#include <stdio.h>#define BUFFER_SIZE 80int main(void){ FILE *fpInput; char fileData[BUFFER_SIZE + 1]; char *getStatus;

fpInput = fopen("test.txt", "r"); if (fpInput == NULL) { printf("Failed to Open Input File\n"); } else { getStatus = fgets(fileData, BUFFER_SIZE + 1, fpInput); while (getStatus != NULL) { printf("%s", fileData); getStatus = fgets(fileData, BUFFER_SIZE + 1, fpInput); } fclose(fpInput); }}

30

The C Language

StreamsThere are predefined file pointers within C

These pointers are created and opened to their respective streams when your program begins running

stdin - standard input - the keyboard

stdout - standard output - the screen

stderr - standard error - the screen

The scanf() and printf() functions can also be written:

fscanf(stdin, “%d\n”, myInt);fprintf(stdout, “%s\n”, myString);

31

The C Language

StreamsWrite a program that counts the number of lines in a file called "testdata.dat", as well as the number of characters (do not include the "\n" character in your count of characters)

32

The C Language

Streams#include <stdio.h>#include <string.h>#define BUFFER_SIZE 80

int main(void){ int lineCount; int charCount; char fileData[BUFFER_SIZE + 1]; char *readStatus; FILE *fpInput;

lineCount = 0; charCount = 0; fpInput = fopen("testdata.dat", "r"); if (fpInput == NULL) printf("Cannot open input file\n"); else { readStatus = fgets(fileData, BUFFER_SIZE + 1, fpInput); while (readStatus != NULL) { lineCount = lineCount + 1;; charCount = charCount + strlen(fileData) - 1; readStatus = fgets(fileData, BUFFER_SIZE + 1, fpInput); } printf("There are %d lines and %d characters\n", lineCount, charCount); fclose(fpInput); }}

33

Scope

34

The C Language

ScopeScope defines the extent to which a variable may be used in code. The hierarchy of scope is (from wide to narrow):

Global (or file level)Function prototypeBlock { }

This can become a seriously confusing mess if you start using the same variable names at each level of scope.

35

The C Language

Scope, continuedGlobal (or file level)

These variables are declared before (outside) of the main function:

#include <stdio.h>

int c;

int main(void){ printf("%d\n", c);}

They are visible (usable) by any part of the program (any function).

Generally speaking, global variables are considered a BAD thing from a style point of view. If at all possible, avoid using them.

36

The C Language

Scope, continuedFunction Prototype

These variables are declared as part of the declaration of a function:

#include <stdio.h>

void f1(int x);

int main(void){ int c; c = 5; f1(c);}

int f1(int c){ printf("C = %d\n", c);}

They are visible only to the function for which they are declared. When the function completes, these variables are destroyed.

37

The C Language

Scope, continuedBlock

These variables are declared between an opening and closing brace {...}:

#include <stdio.h>

int main(void){ int c; c = 5;

{ int i; i = 9; printf("i = %d\n", i); }}

They are visible only within the matching pair of braces. When the braces end, these variables are destroyed.

38

The C Language

Scope, continuedAssume we have a variable 'c' that is declared as a global variable.

It could be masked (hidden from view) by a variable called 'c' declared in a function declaration

Both of the above could be again hidden by a variable called 'c' declared in a block

C

C

C

39

The C Language

Scope, continued#include <stdio.h> int f1(int c);int f2(void); int c = 10;int main(void){ int c; for (c = 0; c < 5; c = c + 1) { int c; for (c = 5; c >= 0; c = c - 1) printf(" C = %d", c); printf("\n"); } printf("Block (main function) C = %d\n", c); f1(c); f2();} int f1(int c){ printf("Function prototype C = %d\n", c);} int f2(void){ printf("global C = %d\n", c);}

40

The C Language

Scope, continued C = 5 C = 4 C = 3 C = 2 C = 1 C = 0 C = 5 C = 4 C = 3 C = 2 C = 1 C = 0 C = 5 C = 4 C = 3 C = 2 C = 1 C = 0 C = 5 C = 4 C = 3 C = 2 C = 1 C = 0 C = 5 C = 4 C = 3 C = 2 C = 1 C = 0Block (main function) C = 5Function prototype C = 5global C = 10

41

Structures

42

The C Language

StructuresThere is a method in C to create a customized data type that allows you group a set of data types into one variable type called a structure.

The group of data types take on a single name, the name of the structure.

This is a convenient means to keep related data together.

It is self-documenting.

43

The C Language

StructuresAnatomy of a structure declaration:

struct structName { dataType varName;dataType varName;

. . .};

The list of elements - normal variable declarationsEnclosed in braces

The name for the collection / group / structureThe keyword to begin the declaration of a structure.

This can be considered a template- it is not a variable declaration (yet).

The template MUST exist at a level of scope that makes it visible to all instances.

44

The C Language

StructuresTo create an instance of the structure:

struct structName instanceName;

The name of the instance - the variable The template nameKeyword to define a structure

The syntax to reference an element of the structure.

instance.element

i.e.theStructure.a = 1;

45

The C Language

StructuresExample:

#include <stdio.h>#include <string.h>int main (void){ struct myStruct {int a; float b; char c; char str[10];};

struct myStruct theStruct; theStruct.a = 1; theStruct.b = 2.0; theStruct.c = '3'; strcpy(theStruct.str, "a string"); printf("the struct initially: a=%d b=%f c=%c str=%s\n", theStruct.a, theStruct.b, theStruct.c, theStruct.str); }

46

The C Language

Structures and FunctionsWhen passing structures from a module to a function, it must be passed by reference- the same as arrays are passed by reference.

The function call will include the address-of operator, the function declaration will include the indirection operator:

...myFunc(&theStruct);...

void myFunc(struct template *passedStruct){...}

Don't forget to declare the template at a higher level of scope.

47

The C Language

StructuresThe dereference operator that is embedded in the structure is the '->' operator.

instead of:

*myvar = x + y;

usetheStruct->element = x + y;

not *theStruct.element = x + y;

48

The C Language

Structures#include <stdio.h>#include <string.h>struct myStruct {int a; float b; char c; char str[10];}; void alters(struct myStruct *ts);int main (void){ struct myStruct theStruct; theStruct.a = 1; theStruct.b = 2.0; theStruct.c = '3'; strcpy(theStruct.str, "a string"); printf("the struct initially: a=%d b=%f c=%c str=%s\n", theStruct.a, theStruct.b, theStruct.c, theStruct.str); alters(&theStruct); printf("the struct after alter: a=%d b=%f c=%c str=%s\n", theStruct.a, theStruct.b, theStruct.c, theStruct.str);}void alters(struct myStruct *ts){ ts->a = 10; ts->b = 20.0; ts->c = '6'; strcpy(ts->str, "New String");}

49

The C Language

StructuresWhat if you needed to track vats of oil in a manufacturing system. Perhaps there will be a vat number, a total capacity for the vat, the current volume of oil in the vat and a description of the vat.

This could be stored in 4 arrays (int, double, double, string)

vatNum capacity volume description

50

The C Language

StructuresInstead of four arrays, of different data types and meanings, how about one array of structures?

vatNum

capacity

volume

description

51

The C Language

StructuresHow do we declare an array of structures?

Treat the structure instance declaration like any other data type we have seen:

int i[5];

struct template myinstance[5];

52

The C Language

StructuresTo reference a specific index within the array of structures, apply the [ ] to the STRUCTURE, not the element of the structure:

myinstance[i].a = x * y;

53

The C Language

StructuresFor example:

#include <stdio.h>#include <string.h>int main (void){ struct myStruct {int a; float b; char c; char str[10];};

struct myStruct theStruct[5]; int i;

for (i = 0; i < 5; i= i + 1) { theStruct[i].a = i; theStruct[i].b = 2.0 * i; theStruct[i].c = '0' + i; strcpy(theStruct[i].str, "a string"); }

for (i = 0; i < 5; i = i + 1) printf("the struct initially: a=%d b=%f c=%c str=%s\n", theStruct[i].a, theStruct[i].b, theStruct[i].c, theStruct[i].str);}

54

The C Language

StructuresNow things get really weird, when passing an array of structures to a function, we are already referencing the address of the array.

Recall:

int a[5];...

a[0] = 0;*a = 0;...

myFunc(a);...

void myFunc(int *a){}

55

The C Language

StructuresThe same happens with an array of structures:

struct template a[5];...

a[0].element1 = 0;...

myFunc(a);...

void myFunc(struct template *a){}

56

The C Language

Structuresvoid myFunc(struct template *a){}

The difference is when dealing with elements of the structure within the function.

Because the structure has already been dereferenced, the '->' operator is not required.

With the function, the elements can be accessed using the more familiar dot notation ('.').

57

The C Language

StructuresFor example:#include <stdio.h>#include <string.h>struct myStruct {int a; float b; char c; char str[10];}; void alters(struct myStruct *ts);int main (void){ struct myStruct theStruct[5]; int i; for (i = 0; i < 5; i= i + 1) { theStruct[i].a = i; theStruct[i].b = 2.0 * i; theStruct[i].c = '0' + i; strcpy(theStruct[i].str, "a string"); } for (i = 0; i < 5; i = i + 1) printf("the struct initially: a=%d b=%f c=%c str=%s\n", theStruct[i].a, theStruct[i].b, theStruct[i].c, theStruct[i].str); alters(theStruct); for (i = 0; i < 5; i = i + 1) printf("the struct after alter: a=%d b=%f c=%c str=%s\n", theStruct[i].a, theStruct[i].b, theStruct[i].c, theStruct[i].str);}

58

The C Language

Structures

void alters(struct myStruct *ts){ int i; for (i = 0; i < 5; i = i + 1) { ts[i].a = ts[i].a * 100; ts[i].b = ts[i].b * 1000.0; ts[i].c = ts[i].c - '0' + 'A'; strcpy(ts[i].str, "New String"); }}