CEG 221Lesson 3: Review II & Beyond

Mr. David Lippa

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>

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

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)

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)

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);

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

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)

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

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

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

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

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);”

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)

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 pdoSomething(&p); // do sthg to p and change it

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

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

}

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?

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;

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

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.

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)

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];

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

Side By Side: Unions and Structs

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;

};

• 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

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

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

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

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 Δ

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

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.

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

QUESTIONS

???