CEG 221 Lesson 3: Review II & Beyond

1. CEG 221Lesson 3: Review II & Beyond Mr. David Lippa

2. CEG220 & Beyond • Advanced Input/Output • Text I/O, Void pointers, Binary I/O • Advanced Data Types • Pointers to Basic Types & Pass By Reference • Enumerated Types (enum) • Structures (struct) & Unions (union) • Pointers to Advanced types & Pointers to Pointers • Advanced Programming • Multiple files to separate interface from implementation • Modifiers on variables (static, auto, extern) • Modifers on functions (static vs. non-static) • String Processing using <string.h>

3. File Input / Output • Just as you can get/give user input from the terminal with scanf/printf, you can do so to/from strings (sscanf, sprintf) and files (fscanf, fprintf). • fscanf/fprintf take an additional parameter, the input (or output) stream, as its first argument • These functions are used for text input/output and are located in stdio.h

4. Text Input/Output • Prototypes: • fscanf(FILE* pStream, const char *pString, …) • fprintf(FILE* pStream, const char *pString, …) • sscanf(char *pSource, const char*pString, …) • sprintf(char *pDestination, const char*pString, …) • Uses: conversions, (ie. converting “3.14159” to the double 3.14159), writing text to files for verification of data values, writing cross-platform setting files (to avoid endian issues)

5. Analysis of Text I/O • Advantages: easy for cross-platform data storage – let’s the processor put the bytes in the proper order with scanf/printf; easy to verify correct results; generally more compressible than their binary equivalents • Disadvantages: files can get very large (especially those, such as images)

6. Introduction to Binary File I/OO • Most files are stored in binary format, writing raw bytes to disk, and then later read in and interpreted • Use fread and fwrite from <stdio.h>, which are significantly faster to read in giant chunks of data • Same prototypes for both fread/fwrite: • size_t fread(void *pMemory, size_t size, size_t numElements, FILE *pStream);

7. What is a void*? • We’ve all seen the return type void before – it means “nothing” (ie. A function that returns void returns nothing). So a void* is a pointer to nothing, right? WRONG! • In fact, it’s a pointer to anything. • A void* can be a pointer to an int, a char, a char*, a char**, a FILE*. • Because of this ambiguity, we cannot dereference a void* (ie. If pVoid is a void*, (*pVoid) is ambiguous

8. Using fread & fwrite • Arguments: • pMemory: the address to read/write from/to • size: the size of each element (sizeof) • pStream: the stream read/written from/to • Returns the number of elements read/written • Remember: • Allocate new memory when using fread – either dynamically (with malloc) or statically (passing in the address using &). (ie. int integer; struct pType p; see next slide for details)

9. Examples: • To read an integer: • int integer; • fread(&integer, sizeof(int), 1, pInputFile) • To read a structure that was written to disk • struct PersonType p; • fread(&p, sizeof(struct PersonType), 1, pInputFile) • In class: using fseek to jump around

10. Introduction to Advanced Types: Terms • Pointer – a memory address that is also a variable • We must first define a variable before we can declare and use it • Definition of a variable – specifies its structure and members • Declaration of a variable – creates an instance of a variable of a type, according to its types definition

11. Advanced Data Types:Pointers to Basic Types • We can create a pointer (a memory address) to a variable. • Pointers should be initialized to NULL, the empty memory address (also 0x00000000) • Pointers are always an ADDRESS, never a value • Dereferenced (convert ptr to value) with * • Use & to convert a variable to a memory address

12. Example: Pointers to Basic Types int iValue = 10; int *pInt = 5; // points to the ADDRESS 5 pInt = malloc(sizeof(int)); // allocate *pInt = 5; // pInt points to memory containing 5 pInt = &iValue;// pInt points to iValue == 10 free(pInt);// free up the memory pInt = NULL; // reset to NULL

13. Example: Pointers to Basic Types (Continued) • Something wrong in the previous slide! • Cannot free up iValue since it wasn’t malloc’d! • The memory malloc’d and formerly assigned to pInt is LOST since we have no copy of that pointer  MEMORY LEAK! • How to fix • Switch “pInt = &iValue;” and “free(pInt);”

14. Implications of Pointers:Passing By Reference • Because a pointer is simply a memory location, passing pointers to functions lets us change the value passed in – a feature not previously allowed to us! • This is called pass by reference (or pass by pointer), as opposed to pass by value, where a copy is made and the copy is modified • We can use the & operator to get the address of any variable (see example in next slide)

15. Passing By Reference • Let’s say we have an integer and want to modify it and the function void doSomething(int *pInt) takes an int*. We can use the & operator to get the address of an int, passing the address of that int to a function that takes an address of an int. int p; // create p doSomething(&p); // do sthg to p and change it

16. Advanced Data Types: Enums • Enumerated Types are just a glorified integer, assigned with a name and number value. They can be in hexadecimal format or in base 10 (ie. EyeColorType) • They are custom data types that can be used in switch() statements or if/else chains to handle a variety of cases • Since they are ints, they can be easily written/read to/from files

17. Example: Enums // define EyeColorType enum EyeColorType { BLUE=0, BROWN=1, GREEN=2, HAZEL = 4 }; // … // declare an EyeColorType called eColor EyeColorType eColor = HAZEL; // remember HAZEL == 4 // … switch(eColor) { BLUE: …; break; // BLUE == 0 BROWN: …; break; // BROWN == 1 … default: …; break; // this will be hit if eColor == 3 }

18. Advanced Data Types: Structs • Structs are a heterogeneous data type that is a collection of all its members • Example: • struct StudentType • First Name, Last Name • Age • Social Security Number • Number of credits taken to date • What types would all of these members be?

19. Defining a Structure enum GenderType { MALE, FEMALE }; typedef struct PersonType { char mFirstName[40]; // a string char mLastName[40]; // a string enum GenderType mGender; int mAge; float mGPA; struct PersonType *mpSpouse; } Person;

20. Declaring a Structure • How to declare a struct as a variable and as a pointer: • struct PersonType andrew; • struct PersonType* pPerson; • We can use “typedef” to create custom types that help eliminate confusion after the struct definition • typedef Person* PersonPtr; • Now we have PersonPtr and Person types

21. Declaring a Structure (Contd) • We can now declare a pointer to a person • PersonPtr pPerson1, pPerson2; instead of having to do: • struct PersonType *pPerson1, *pPerson2; • Furthermore, the extension Ptr to every pointer type clarifies what is a pointer and what isn’t. If we wanted an array of Person, we could create a pointer to a PersonPtr.

22. Example: Structures • An array of 14 persons: Person myClass[14]; • A pointer to a person: PersonPtr pPerson; • An array of 4 person pointers: PersonPtr myFamily[4]; • What we cannot do: • Inherit characteristics (ie. An engineer is a person)

23. Using Structures • To access a member of a pointer, we must dereference the pointer (with *) and then the structure (with .) • Examples: • myClass[0].mGPA = 4.00f; • pPerson = malloc(sizeof(Person)); • (*pPerson).mGPA = 3.89f; • pPerson->mGPA = 3.89f; // equivalent to above • pPerson->mpSpouse = &myClass[0];

24. Advanced Data Types: Unions • A union is just like a structure in terms of memory usage and behavior, with one exception: it only contains one of its internal variables at a time. • If struct PersonType were a union, setting the gender field would be its only contents. • Then, if the age were changed, the gender would be lost

25. struct StudentType { char mFirstName[30]; char mLastName[40]; char mSSN[9]; unsigned int mAge; int mNumCreditsTaken; char mStudentStatus; }; union NumberType { char mChar; short mShrt; int mInt; long mLong; }; Side By Side: Unions and Structs • Structs contain all the members in their definition • Unions only have one of their members contain information at a time • For a given union, if mInt = 40 and mChar is then set to be ‘A’, then the information in mInt is gone

26. Pointers to Pointers • We have briefly covered pointers to pointers. Wouldn’t you rather see “PersonPtr *pList” instead of “struct PersonType **pList”? • Remember, when dereferencing pList to make sure that enough memory was allocated and that when you dereference it, *pList is still a POINTER

27. Advanced Programming: Information Hiding at a High Level • Use multiple files to separate interface from implementation • Interface: how to use the functionality provided • Implementation: how the work gets done • We can then create a library consisting of the header file (interface) and the library (implementation). No one need know how the library functions, just that it does what was intended. • Go over examples in class

28. Advanced Programming: Modifiers • Modifiers on variables • const – variable cannot change • static – only one copy exists within that file • extern – defined externally in some file that #includes where the extern is defined • Modifers on functions (static vs. non-static) • Static – only one copy of the function can exist • No other function may have that name and argument list

29. The Basics of Modifiers I: CONST • There is one time where a const variable is not quite constant – that is when it is a pointer: • 1) const char *pChar = “Hello”; // contents can’t Δ • 2) char * const pPtr = …; // address can’t Δ • 3) const char * const pPtr2 = …; // neither can Δ

30. The 3 Cases of the const Modifier • Case (1) • pChar[0] = ‘C’; // illegal – contents can’t change • pChar = “World”; // legal – points to something else • Case (2) • FILE* const pFile = fopen(“Data.dat”, “rb”); // legal • pFile = NULL; // illegal – pointer can’t change • fprintf(pFile, “Hello”); // legal – contents can change • Case (3) • const FILE* const pFile = fopen(“Data.dat”, “rb”); // legal • fclose(pFile); // illegal • fprintf(pFile, “Hello”); // illegal

31. The Basics of Modifiers II • Since extern is rarely used, just don’t worry about it • The main use of “static variables” is to ensure that only one copy of a function or variable exists – frequently fixes the “function already defined” compiler/linker error. Statics are frequently used in C++ and significantly less in C.

32. Next Time • Algorithm Development I • What is an algorithm? • Why are algorithms important? • Examples of Algorithms • Introduction to Algorithm Development • Example of Flushing Out an Algorithm • Questions

33. QUESTIONS