The text of each key point is a hyperlink to its place in the appropriate lecture notes. Alternatively, click on the section title to read the full page.

Preface

Exercise: Mr Turtle

Functions can call other functions.

Introduction to C

The purpose of C is to unambiguously express an algorithm and its data in a way that is easy for us to understand and modify.

All executable statements live inside a function and the program starts by executing the contents of the main() function.

Statements finish with a semi-colon and long statements should be split over several lines for clarity.

The Mega-principle
Whenever we are faced with a choice, our first question should always be: "which choice will be the clearest and give me the least chance of making a mistake?".

Variables and expressions

Conditional statements

Control statements control which instruction is executed next.

Loops

Functions

Code that would otherwise need to appear more than once in a program should be made into a function.

Functions allow us to divide complicated tasks into sub-tasks that can be thought about separately.

Memory, input and output

When using a memory address there are two possible mistakes:
1. We may use the wrong value of the address.
2. We may use the correct address but tell the compiler it points the the wrong type of object, such as a float rather than an int.

The compiler can warn about us errors in scanf() - make sure you enable the checks!

Arrays, etc.

Dealing with text

#include <ctype.h> has various character tests as well as toupper() and tolower().

We can have arrays of character arrays, just like any other array type.

Bugs and debugging

It's not the bug we find as we go along that takes the time,but the one we don't find as we go along.

Memory and pointers

In order to dereference a pointer it is absolutely essential that its value has been explicitly set to the address of a legitimate variable, just as when we dial a phone number it is essential that it is the number of the correct telephone.

Appendix: allocation

Structures

Keeping track of memory

It is essential to initialise the first member of the list to NULL.

To go over every element of a linked list use: for(p = first; p != NULL; p = p->next)

Recursion

C wrap-up

Enumerations give names to integers and are used to list (enumerate) different, mutually-exclusive choices.

Multiple files and the pre-processor

Putting the word static in from of a function definition stops it from being called from another .c file.

Putting the word static in from of a variabe declared outside of a function stops it from being accessed from another .c file.

Protect header files with #ifndef _FILENAME_H

Validate Link-check

Privacy & cookies

Summary of key points

People v computers

Algorithms and data

Comments!

Pre-processor (#) Directives

The main() function

Statements

The printf() function and character strings

The return statement

Making our program easier to understand

Arithmetic and variables

Printing numbers to the screen

Arithmetic expressions

Standard mathematical functions

Integer variables and expressions

Complex numbers

Reading variables from the keyboard with scanf()

The if() statement

Relational operators

{ ... } blocks

The switch() statement

The while() loop

Debugging loops

The for() loop

"In place" arithmetic operators

The break and continue statements

What is a function?

Why are functions useful?

1. Code that gets used more than once

2. Hiding complexity

Criteria for a good function

Writing our own functions

We have written one function, and used others, already

Local variables: a vitally important principle

Function prototypes

Mistakes with memory addresses

Reading in variables with scanf()

Checking the arguments to scanf()

Writing to, and reading from, files

When to use arrays

Declaring and using a one-dimensional array

Passing the address of an array to a function

Arrays of arrays, or multi-dimensional arrays

Single characters

Character strings

Non-fixed strings, or arrays of characters.

Three things to look out for

Utility functions for characters and strings

String utility functions: <string.h>

Other useful features

Two-dimensional character arrays are arrays of (writeable) strings

Find the bugs before they bite you where it hurts

Put in checks

Finding bugs

When we needed to "pass the array to another function" we encountered the simple, but key innovation is that whereas previously we had used memory addresses that are constants, we can now also use memory addresses that are the values of variables. We can illustrate a trivial example as follows:

Pointers

When pointers attack: random pointer values

Using pointers to allocate space

Advanced: realloc()

How to use pointers effectively

Structures do for variables what functions do for code

Defining a new composite variable (structure) type

When to use structures and what to put in them

Pointers to structures

Thinking at a higher level

Allocating structures

Linked lists

Creating a linked list

Traversing a list

Removing and freeing a member of a list

Unformatted input and output

Command-line arguments

Named constants and enumerations

Sharing variables between functions

Static variables inside functions

qsort() can sort arrays of anything

Header files: "mydefs.h"

Calling functions in other source files

Sharing and not sharing variables between files

Sharing variables between functions in different source files

Pre-processor (`#`) Directives

The `main()` function

The `return` statement

Reading variables from the keyboard with `scanf()`

The `if()` statement

`{ ... }` blocks

The `switch()` statement

The `while()` loop

The `for()` loop

The `break` and `continue` statements

Reading in variables with `scanf()`

Checking the arguments to `scanf()`

String utility functions: `<string.h>`

Advanced: `realloc()`

Header files: "`mydefs.h`"