Introduction

Phases through which a C program goes to be executed

• edit (source file .c)
• pre-process (adds on header file .h)
• compile (creates object files .o)
  • compiler: translates C code into assembly
  • assembler: translates assembly into machine code
• link (links with libraries .lib, .dll)
  • combines the machine code from various libraries
  • determines branch addresses, variable locations
• load (load the program into memory)
• execute (.exe file)

A simple program

• pre-processor directive: eg #include <file.h>. Compiler will include the contents of file.h with the source code
• the code will always start at main
• return 0 means the program exited normally

Variables

Variable names

• Identifiers: consist of letters, digits (cannot begin with a digit) and underscores( _ )
• Case sensitive
• Should not use C keywords (eg if, int etc)

Some terminology

• variable declaration: eg int anInt;
• assignment: anInt = 5;

Data Types

• char : 1 byte
• int : 4 bytes (machine-dependent)
• float : 4 bytes
• double : 8 bytes
• pointer : 4 bytes

In order of promotion hierarchy

• long double
• double
• float
• unsigned long int
• long int
• unsigned int
• int
• short
• char

Casting is the name given to converting type.

(newType) variableOfOldType

Casting to a lower type leads to loss of precision.

Can get finer control over the integer size by using int8_t, int16_t, int32_t, int64_t, uint8_t, etc.

Operators

Arithmetic operators

In order of reverse precedence

• +
• -
• *
• /: division. Integer division truncates remainder 7/5 \rightarrow 1
• %: modulus. Returns the remainder 7%5 \rightarrow 2
• ()

For convenience, C also has:

• Assignment operators: +=, -=, *=, /=, %=
• Increment operators
  • ++: Increment
  • --: Decrement
  • ++i: Update the variable. Then evaluate the expression
  • i++: Execute the expression. Then update the variable

Logical operators

• &&: and
• ||: or
• !: not

Bitwise operators

• &: and
• |: or
• ^: xor
• ~: not
• <<: left shift
• >>: right shift

Control structures

• Sequence structures: programs executed sequentially by default
• Selection structures: if, if...else, and switch
• Repetition structures: while, do...while, and for

Selection structures

• Decision: if (...)
  • execute if true:, a non-zero number eg 1
  • ignore if false: 0
  • note: C does not have the booleans ‘true’, ‘false’!
• equality
  • ==: equal to
  • !=: not equal to
• relational operators
  • >: Greater than
  • <: Less than
  • >=: Greater than or equal to
  • <=: Less than or equal to

If statement

if ( condition ){
    statement;
}
else if( condition2 ) {
    // else if is optional
} 
else if( condition3 ) {
    // can have multiple else ifs
} 
else {
    // no condition is specified
    // else is optional
}

Switch statement

switch ( variableWithDistinctValues ) {
    case value1 : 
        statement1;
        break;
    case value2 : 
        statement2;
        break;
    case value3 : 
    case value4 :
        statement3and4;
        break;
    default: 
        statementForTheRest;
        break;
}

Repetition structures

For loops

for ( initialization; loopContinuationTest; increment ) {
    statement;
}

Can have multiple initializations, increments.

e.g. for (i = 0, j = 0; j+i <= 10; j++, i+=5) { ... }

While loops

initialization;
while ( loopContinuationTest ) {
    statement;
    increment;
}

Do-while loops

Same as while, but ensures that the body of the loop is executed at least once.

do {
    statements;
} while ( condition );

Other statements

• break : causes immediate exit from a while, for, do...while or switch statement
• continue : goes to the next iteration of the loop

Unstructured control flow

goto (avoid, unless you really know what you’re doing and it is the cleanest approach).

    ...
    goto foo;
    ...

foo:
    ...

They are useful for - breaking out of deeply nested loops - handling errors, exceptions - cleans up opened resources - jumping to some code if allocation fails

Exceptions are used to break out of a deep call stack quickly. Similar to gotos for breaking out of loops, but here applied to function calls. setjmp, longjmp

Functions

returnType functionName(type1 parameter1, type2 parameter2,...){
    declarations;
    statements;
    return expression;
}

• If the function is to return nothing
  • returnType is void and
  • use return; or
  • leave out return
• Functions cannot be defined inside other functions

To call a function:

variable = functionName(argument1, argument2, ...)

If the function returns void, then

functionName(argument1, argument2, ...)

• call-by-value: func(foo)
  • copy of argument is passed to the function
  • changes to the variable thus won’t affect the original value
  • useful when a function doesn’t need to change the original variable
  • avoids accidental changes to the variable
• call-by-reference: func(&foo)
  • passes the address of the original argument using &
  • changes to the variable thus will affect the original value
  • arrays are implicitly passed with & (the array name is already an address/reference (pointer))

All C functions are technically pass-by-value. For the “pass-by-reference” concepts defined above, what actually happens is that a copy of the pointer is passed to the function. Incrementing the pointer inside the function, does not change the original pointer.

Function prototype

• Used to validate functions and function calls.
• Must always be given

returnType functionName(type1 param1, type2 param2,...);

Header files

• contain function prototypes for library functions
  • essentially a contents page, and an instruction manual for library functions
• load with:
  • #include <file> for system header files
  • #include "file" for user header files
• you can create use your own function library, by creating your own header file and including it
• benefit: allows you to reuse code you wrote before

The C preprocessor literally inlines the contents of the included file

// lib.h
int give_me_int();
---
// main.c
#include "lib.h"

int main() {
  return give_me_int();
}

becomes

// main.c
int give_me_int();

int main() {
  return give_me_int();
}

Header guards: macro definitions that allow the compiler to only ever execute the header files the first time they are seen. It’s good practice to include them on projects of any significant size.

// stdio.h
#ifndef    _STDIO_H_
#define    _STDIO_H_

// Lots of header code

#endif /* _STDIO_H_ */

The next time stdio.h is included in the project, it will skip over all the meat of this file since _STIOD_H_ will be defined.

Standard libraries

The C standard library (or libc) provides macros, type definitions and functions for common tasks.

See https://en.wikipedia.org/wiki/C_standard_library.

Storing data

An identifier’s storage class determines:

• Storage duration: how long a variable exists in memory
• Scope: where object can be referenced in program
• Linkage: specifies the files in which an identifier is known

Types:

• local variables
  • Variables exist for certain section of program (block of code)
  • Exist while block is active
  • Destroyed when block is exited
• static storage
  • Variables exist for entire program execution
  • static: local variables defined in functions.
    • Keep value after function ends
    • Only known in their own function
  • Global variables and functions
    • Known in any function

Scope

Portion of the program in which the identifier can be referenced

• file scope
  • Variable defined outside a function
  • Known in all functions (in file)
  • Used for global variables, function definitions, function prototypes
• block scope
  • Variable declared inside a block ({...})
  • Used for variables, function parameters (local variables of function)
  • Outer blocks “hidden” from inner blocks if there is a variable with the same name in the inner block

Symbolic constants

#define NAME VALUE

• a preprocessor directive
• the preprocessor replaces all occurrences of NAME with VALUE in the code before compiling

Arrays

• Structure that stores related data items of the same data type.
• Fixed size throughout program execution.
• Group of consecutive memory locations
• 0-indexed
• can operate on array elements like any other normal variable

Declaration:

arrayType arrayName[ numberOfElements ];

Initialisation:

• can use a for-loop (loop through indices)

An initialiser list:

int a[ 5 ] = { 1, 2, 3, 4, 5 };
int b[ 5 ] = { 1 }; // remaining four elements default to value 0
int c[ ] = { 1, 2, 3, 4, 5 }; // size of c will be set to 5

Arrays and Functions:

returnType functionName(arrayType arrayArgument[], ...);

// To prevent the function from modifying the array, use const
returnType functionName(const arrayType arrayArgument[], ...);

• array arguments are passed by reference
  • thus any changes to the array in the function can change the data at the original memory location
  • use const to avoid any modification
• name of array is address of first element
• function thus won’t know array size
• the array size is usually passed in as a seperate argument
• array elements (i.e. not the whole array) are passed by value
  • so the original array is unaffected

Character arrays

char myName[] = "Anton";
// this is equivalent to the 6 characters:
char myName[] = {'A','n','t','o','n','\0'};

// and is also mostly equivalent to:
char* myName = "Anton";

• The string is a static array of characters.
• The null character '\0' terminates strings
• Can array index into strings: myName[0] is 'A'
• The array’s name is the address of the array (i.e. the array identifier is already a pointer)

e.g.

char yourName[10];
scanf("%s", yourName); // Note: no &
// This reads characters until a whitespace is encountered. 
// So if you enter "Anton Tang", yourName would just be
// Anton

Multidimensional arrays

e.g. This declares and initialises a 2 \times 2 matrix:

int my2dArray[2][2] = {{1, 2}, {3, 4}};
// my2dArray[1][0] is then 3

• initialisers grouped by row
• unspecified elements default to 0

Enumerations

• basically integers
• suitable for storing distinct but related items
• make code easy to use and understand

Definition:

enum EnumName { item1, item2, item3, ...};

Example:

// definition
enum Weekday { Mon, Tues, Wed, Thurs, Fri}; 

enum Weekday today; // declaration
today = Thurs; // assignment

if (today == Fri){
    printf("It's the weekend! Nearly...");
}

typedef enum WeekDay weekday_t;
weekday_t blues = Mon;

Structures

Collections of related variables (aggregates) under one name.

// definition
struct structName{
    dataType1 varName1;
    dataType2 varName2;
    ...
}; // NB: need ";" here!

// declaration and initialisation
struct structName structVar = {value1, value2, ...};
// note that above there are two parts to the struct type 

// declaring and initialing pointer to a struct
struct *sPtr;
sPtr = &structVar;

• Variables in a structure are called members of the structure
• Can contain members of different data types
• Combined with pointers, can create linked lists, stacks, queues, and trees.
• Can’t contain a member which is another struct of the same type.
• Can contain a member that is a pointer to the same structure type.
• A structure definition does not reserve space in memory
  • Instead creates a new data type used to define structure variables
• A struct is basically syntactic sugar for referring to chunks of memory
• There may be gaps between members

Accessing struct members

• Dot operator (.): when you have the structure name
  • Note: ++C.x is C.x = C.x + 1
• Arrow operator (->): when you have a pointer to the structure.

structVar.varName1 = value1;
(*sPtr).varName1 = value1;
sPtr->varName1 = value1;

Defining custom types

• Use typedef
• Creates synonyms (aliases) for previously defined data types
  • useful for structs
  • can be used for any variable (not just structs)
• Use typedef to create shorter type names

// Option 1
struct coord {
    double x;
    double y;
};

typedef struct coord Point;
Point pa, pb;

// without typedef
struct coord pa, pb; // annoying

// Option 2
typedef struct {
    double x;
    double y;
} Point;

Point pa, pb;

We can also define an integer pointer type typedef int * IntPtrType;

Padding/Packing

When structures are defined, the compiler is allowed to add padding (spaces without actual data) so that members fall in address boundaries that are easier to access for the CPU.

For example, on a 32-bit CPU, 32-bit members should start at addresses that are multiple of 4 bytes in order to be efficiently accessed (read and written).

struct S {
    int16_t member1;
    int32_t member2;
};

With padding:

+---------+---------+
| m1 |~~~~|   m2    |
+---------+---------+

With packing:

+---------+---------+
| m1 |   m2    |~~~~
+---------+---------+

For packed, the compiler has to generate more code (which runs slower) to access the non-aligned data members. Packed structs are suited for storing data in binary formats.

Unions

Allows for the same memory space to be interpreted as multiple types.

union myunion {
    int x;
    struct {
        char s1;
        char s2;
    } s;
};

union myunion y;

Pointers

Types of variables

• scalar variable
• array variable
• pointer variable

Pointers:

• pointers store the memory location of a value.
• simulate call-by-reference
• each variable has a
  • name
  • value
  • address
• direct reference: access variable’s value through variable name
• indirect reference: access variable’s value through the pointer
• indirection: using an address to access a variable

Declaration:

pointerType *pointerName;
pointerType *pointer1, scalar;

• can define pointers to any data type
• initialise pointers to 0, NULL, or an address
• & returns address of operand
• * is used for pointer declaration
• * also provides access to memory/variable that its operand points to
  • can be used to read/change the value
• the dereferenced pointer (operator of *) must be an address
• & and * are inverses
• to use NULL, include stdio.h first
  • eg check if null-pointer: if (myPointer == NULL) { ... }

Pointer expressions

Arithmetic operations can be performed on pointers

• Usually only useful if performed on/for arrays
• Increment/decrement ++, --
• Add an integer to a pointer( + or +=, - or -=)
• Can subtract pointers from each other
• Comparison (<, ==, >)
• Pointers of the same type can be assigned to each other
  • If not the same type, a cast operator must be used
  • No casting needed to convert to void pointer (represents any type)
  • Void pointers can’t be dereferenced

Pointers and arrays

Array elements can be accesed by:

• pointer/offset notation
  • *( arraypointer + i)
• pointer/subscript notation
  • arraypointer[ i ]
• pointer/offset notation with array name
  • *( array + i)
• array subscript notation
  • array[ i ]

The above is easy to remember once you realise that array and arraypointer are just aliases.

float f[5];
float *fptr = &f[0];
fptr++; // moves the address 4 (8) bytes forward on 32 (64)-bit machines

Using constant qualifier

const dataType variableName = variableValue;
// compiler will complain if you try to change this variable

Combinations possible

1. non-constant pointer to non-constant data
2. non-constant pointer to constant data
3. constant pointer to non-constant data: must be initiliased at declaration
4. constant pointer to constant data: must be initiliased at declaration

int *myPtr;                     // 1
const int *myPtr;               // 2
int * const myPtr = &x;         // 3
const int * const myPtr = &x;   // 4

When to use which combination?

• Applicable to argument declaration when writing function definitions
• Use the principle of least privilege
• Prevents errors – ensures that your function does not accidentally alter data

Function pointers

int min(int a, int b);
int max(int a, int b);

int foo(bool do_min, int a, int b) {
    int (*func)(int,int); // declaration
    if (do_min)
        func = min;
    else
        func = max;
     // indirect call
    return func(a, b);
}

sizeof operator

• Returns size of operand in bytes
• For arrays: (size of 1 element) \times (number of elements)
• can be used with
  • type name (eg int, myStructType)
  • variable names (eg myInt, myStructVar)
  • constant values (eg 19)
• sizeof( array ) returns amount of memory consumed by all array elements.
  • but this only works inside the scope where the array is defined.
  • if an array is passed to a function, sizeof cannot determine the memory size used by the array.
• also useful to reserve memory for structs
  • use sizeof( myStructType ) or sizeof( myStructVariable)

Advanced

Inline assembly

• if no C statement exists for the task
• if you want direct control over the assembly generated

asm("code");
asm("code": output); // asm to C
asm("code": ... : input); // C to C

References

• https://stackoverflow.com/questions/5473189/what-is-a-packed-structure-in-c