Header files

• <assert.h>: for adding diagnostics that aid program debugging.
• <ctype.h>: for functions that test characters for certain properties, and function prototypes for functions that can be used to convert lowercase letters to uppercase letters and vice versa.
  • islower()
  • toupper()
• <errno.h>: for reporting error conditions.
• <float.h>: Contains the floating point size limits of the system.
• <limits.h>: Contains the integral size limits of the system.
• <locale.h>: enables a program to be modified for the current locale. This enables the computer system to handle different conventions for expressing data like dates, times, money and large numbers throughout the world.
• <math.h>
• <setjmp.h>: for functions that allow bypassing of the usual function call and return sequence.
• <signal.h>: handle various conditions that may arise during program execution.
• <stdarg.h>: for dealing with a list of arguments to a function whose number and types are unknown.
• <stddef.h>: Contains common definitions of types used by C for performing certain calculations.
• <stdio.h>
• <stdlib.h>: for conversions of numbers to text and text to numbers, memory allocation, random numbers, and other utility functions.
• <string.h>: for string processing functions.
• <time.h>: and types for manipulating the time and date.

Dynamic memory allocation

Both the following functions are contained in stdlib.h.

• void* malloc(int nrOfBytes)
  • allocates memory during execution time
  • returns a generic pointer that points to the address of the first memory position in the block
  • returns a NULL pointer if it was unable to allocate the memory
  • eg type* newptr = malloc (arraySize * sizeof( int ));
    • allocates memory for an array of integers
    • the array’s starting address is stored in newptr
• void free(ptrType* pointerToMemory)
  • frees memory allocated previously
  • always free dynamically allocated memory (prevents memory leaks)
• example usage:
  • int* myIntAddress = malloc(sizeof(int));
  • free(myIntAddress)
• you can draw parallels with this and filehandling
  • FILE* filePtr = fopen("abc.xyz","r");
  • fclose(filePtr);

Common errors

Every block of memory allocated with malloc() should eventually be returned to the pool of available memory by exactly one call to free().

• memory leaks: when a block’s address is forgotten but free() is not called for it. The memory it occupies cannot be reused until the program terminates.
• use-after-free: program calls free() for a block and then continues to use the block. This can create a conflict with re-use of the block through another malloc() call.
• double free: when free() is called more than once on a block. Leads to undefined behavior. Can corrupt the state of the memory manager.

IO library functions

• printf
• scanf
• printing/reading variables
  • %d: decimal integer
  • %f: float, double (printf)
  • %e: float, in scientific notation
  • %lf: double (scanf)
  • %c: char
  • %s: string
  • %4d: field width (left-pads with up to 4 spaces)
  • %-4d: field width (right-pads with up to 4 spaces)
  • %.4f: precision (print up to 4 decimal places)
• common escape sequences
  • \n: Newline. Position the cursor at the beginning of the next line.
  • \t: Horizontal tab. Move the cursor to the next tab stop.
  • \a: Alert. Sound the system bell.
  • \\: Backslash. Insert a backslash character in a string.
  • \": Double quote. Insert a double quote character in a string.
  • \’: Single quote. Insert a single quote into string.
  • \r: Position the cursor at the beginning of the current line.
  • \?: Insert a question mark character
  • %%: Percentage symbol

Math library functions

All of the math.h functions return type double.

• sqrt(x)
• exp(x)
• log(x): natural logarithm
• log10(x)
• fabs(x): absolute value of x
• ceil(x): rounds x to the smallest integer greater than x
• floor(x): rounds x to the largest integer less than x
• pow(x, y): x raised to power y
• fmod(x, y): remainder of x/y as a floating point number
• sin(x): where x is in radians (all trig functions)
• cos(x)
• tan(x)

Generating random numbers

• from stdlib.h
• int rand(void) returns a random integer from 0 to RAND_MAX = 32767
• e.g. i = 2 + rand() % 5; is a pseudorandom number from 2 to 6 (= 5+2-1).
• computers generally can’t give truly random values; typically a function with an initial value, called a seed, is used to generate numbers that look and behave like random variables (pseudorandm numbers).
• rand() generates the same sequence of numbers for the same seed
• can use srand() to change the seed value:

// to set the seed manually
unsigned int seed = 42; // unsigned implies non-negative
srand(seed);

// to set the seed automatically
srand( time( NULL) ); // need <time.h>

// to generate random numbers
fprintf("%d", rand());

File handling

Data files

• Can be created, updated, and processed by C programs.
• Are used for permanent storage of large amounts of data. Storage of data in variables and arrays is only temporary.
• Binary files:
  • Unformatted (stored as “raw bytes”)
  • Data not human readable
  • Written and read sequentially or randomly
• Text files:
  • Data is stored as characters (char)
  • Usually only written and read sequentially

Opening and closing files

Opening files

#include <stdio.h>

FILE * filePtr;
filePtr = fopen( "someFilename.xyz", "r" );
// optional: check if file was opened
if ( filePtr == NULL ) {
    printf( "ERROR - file could not be opened!\n" );
}
else{
    // do stuff with the file
    fclose( filePtr );
} 

• Declares pointer filePtr that may point to a file.
• Opens someFilename.xyz and let filePtr points to its beginning.
• "r": File is opened to read and as text file
• Files should always be closed after use

File open modes

• r: Open a file for reading.
• w: Create a file for writing. If the file already exists, empty it.
• a: Append; open/create a file for writing at end of file.
• update mode:
  • r+: Open a file for update (read/write).
  • w+: Create a file for update (read/write). If the file already exists, empty it.
  • a+: Append; open/create a file for update; writing is done at the end of the file.
• binary mode:
  • rb: Open a file for reading in binary mode.
  • wb: Create a file for writing in binary mode. If the file already exists, empty it.
  • ab: Append; open/create a file for writing at end of file in binary mode.
• update, binary:
  • rb+: Open a file for update (read/write) in binary mode.
  • wb+: Create a file for update in binary mode. If the file already exists, empty it.
  • ab+: Append; open/create a file for update in binary mode; writing is done at the end of the file

Files and Streams

• C views each file as a sequence of bytes
• File ends with the end-of-file marker or file ends at a specified byte
• Stream created when a file is opened
• A stream is a communication channel between files and programs
• Opening a file returns a pointer to a FILE structure
• Three files with associated streams are automatically opened with program execution:
  • stdin: standard input (keyboard) (in stdio.h)
  • stdout: standard output (screen) (in stdio.h)
  • stderr: standard error (screen)
• FILE structure
  • File descriptor
    • Index into an operating system array, the open file table
  • File Control Block (FCB)
    • Found in every array element, system uses it to administer the file

Standard library functions (in stdio.h)

• int fgetc( FILE *stream );
  • Reads one character from a file
  • Takes a FILE pointer as an argument
  • fgetc( stdin ) equivalent to getchar()
• int fputc( int char, FILE *stream );
• char* fgets( char *str, int count, FILE *stream );
  • Reads a line from a file
• int fputs(const char *str, FILE *stream);
  
• int fscanf( FILE *stream, const char *format, ... );
  • File processing equivalents of scanf()
• int fprintf( FILE *stream, const char *format, ... );
  • File processing equivalent of printf()
• int feof( FILE *stream );
  • Returns true if end-of-file indicator (no more data to process) is set for the specified file
• void rewind( FILE *stream );
  • Resets the file position pointer to the beginning of the file

Example:

#include <stdio.h>
#include <stdlib.h>

int main () {
   char str1[10], str2[10], str3[10];
   int year;
   FILE * fp;

   fp = fopen ("file.txt", "w+");
   fputs("We are in 2018", fp);
   
   rewind(fp);
   fscanf(fp, "%s %s %s %d", str1, str2, str3, &year);
   
   // str1 = "We"
   // str2 = "are"
   // str3 = "in"
   // year = "2018"

   fclose(fp);
   
   return(0);
}

Write to/Read from Binary Files

• fwrite: Transfer bytes from a location in memory to a file
• fread: Transfer bytes from a file to a location in memory

Eg: fwrite( &myObj, sizeof( egType ), 1, fPtr );

• &myObj: Location to transfer bytes from
• sizeof( egType ): Number of bytes to transfer
• 1: For arrays, number of elements to transfer. In the eg, only one element is being transferred
• fPtr: File to transfer to or from

Random-Access Files

• Access individual records without searching through other records
• Instant access to records in a file
• Data can be inserted without destroying other data
• Data previously stored can be updated or deleted without overwriting
• Implemented using fixed-length records
  • i.e. some data is set aside for each record
  • Text files usually do not have fixed-length records and are therefore handled sequentially (not like the pc can know how long each line will be).
• Data in random-access files
  • Random-access files are usually binary/unformatted (stored as “raw bytes”)
  • All data of the same type (eg ints) use the same amount of space as in memory
  • All records of the same type have a fixed length
  • Data is not human readable

Writing Data to a Random-Access File

Sets file position pointer to a specific position

int fseek( FILE *stream, long int offset, int whence );

fwrite( &dataVariableToWrite, sizeof( dataVariable ), 1, filePtr );
fread( &dataVariableToRead, sizeof( dataVariable ), 1, filePtr );
// here 1 is the nr of elements to read; can be something else

• stream: pointer to file
• offset: (in bytes) file position to seek (relative to the position specified in whence)
• whence: specifies reference point in file for offset
  • SEEK_SET: seek starts at beginning of file
  • SEEK_CUR: seek starts at current location in file
  • SEEK_END: seek starts at end of file