PHY2027 Scientific Programming in C

Comments and questions to John Rowe.

Hello John!

This module is for people who do not already know how to program computers, so we try to take things fairly slowly. Don't be afraid to ask questions if there's something you don't understand.

• Expectations The purpose of this page is to tell you what we are expecting of your program in order to get a good mark.
• Copying and collaboration.
• School policy on late submission and plagiarism
• University procedures on collusion and plagiarism.

Extended list of contents

• Preface
  Overview

  People v computers

  Our experience with computers so far

  Warm up discussion

  "Law of averages" errors

  Would you drive into a river if your satnav told you to?

  Giving instructions to computers

  Algorithms and data

  Another example of an algorithm

  Features of this algorithm

  Issues with algorithms

  Other issues with algorithms

  Walking through our algorithms

  To think about after the lecture

  Summary
• Introduction to C
  Overview

  The C programming language

  Our first C program

  Comments!

  Pre-processor (#) Directives

  The main() function

  The printf() function and character strings
  

  The return statement

  The Mega-principle

  Integer and floating-point expressions

  Declaring variables

  Printing numbers to the screen

  Summary
• Variables and expressions
  Arithmetic expressions

  Arithmetic assignment

  When the value of a variable changes its old value is gone forever

  Standard mathematical functions

  Some useful mathematical functions

  Sensible variable names

  Integer variables and expressions

  Declaring and using integer variables

  Printing the values of integer expressions

  Integer division and remainders

  Tips and warnings concerning integer division

  Converting between integers and floating point

  Complex numbers

  Reading variables from the keyboard with scanf()

  Summary
• Conditional statements
  Control statements

  The if() statement

  else

  else if ()

  Relational operators

  Three common mistakes to look out for

  { ... } blocks

  Indentation and layout

  Nested if()s

  The switch() statement

  The case labels

  The default label

  Falling through the cases
  

  Fall-through after other statements

  Summary
• Loops
  The while() loop

  The increment

  Multiple tests

  Debugging loops

  Preserving the value of variables

  The for() loop

  "In place" arithmetic operators

  Declaring loop variables inside a for() statement

  The do { ... } while(); loop

  The break and continue statements

  Deliberate infinite loops

  A final update to the index-card model

  Summary
• Functions
  What is a function?

  A separate piece of code with its own local variables

  It can be given arguments

  It can return a value

  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
  

  A more realistic example
  

  Functions are written outside of other functions

  Avoid ambiguity with a preceding comment
  

  The return type

  The return value

  Function parameters

  Local variables: a vitally important principle

  Function prototypes

  Summary
• Memory, input and output
  scanf()

  The computer stores the values of its variables in its memory

  An update to the stepper

  &i tells us where the variable i is stored in memory

  The type determines how many bytes are read and how to interpret them

  Mistakes with memory addresses

  Reading in variables with scanf()

  Don't forget the the &

  The format to read a double is "%lg"

  Checking the arguments to scanf()

  Looking ahead

  Writing to, and reading from, files

  Checking for valid input

  Approaches to handling the wrong input

  Infinite loops and the break statement

  Putting it together

  Summary
• Arrays, etc.
  Vectors and matrices

  Preparation

  What is an array?

  When to use arrays

  Declaring and using a one-dimensional array

  Array initialisation

  Looping over an array

  Avoid "magic numbers", use symbolic constants instead.

  Run-time array sizes

  How arrays work
  

  Passing the address of an array to a function

  Arrays of arrays, or multi-dimensional arrays

  Summary
• Memory and pointers
  Reminder: memory
  

  Pointers

  The * operator

  When pointers attack: random pointer values

  malloc

  Allocated memory is permanent
  

  Freeing memory

  Advanced: realloc()

  Advanced: "reallocating" memory with realloc()

  Multiple memory allocations
  

  Pointers can point to other pointers

  Differences from true multi-dimensional arrays

  Summary
• Dealing with text
  Single characters

  Character strings

  Non-fixed strings, or arrays of characters.

  Passing strings to functions

  Don't try to modify a fixed string

  Three things to look out for

  Character-based functions: <ctype.h>

  String utility functions: <string.h>

  Other useful features

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

  Summary
• Bugs and debugging
  Work in stages

  Shake the scorpions from your shoes (or worse!)

  Find the bugs before they bite you where it hurts

  Put in checks
  

  Conclusion

  1. Narrow down where the bug is

  2. Compare the two stories

  3. Get more information by printing stuff out

  Dealing with infinity and Nan

  4. Check our assumptions

  When programs crash

  Invoking the debugger

  What the debugger does for us

  Moving up the call stack

  The assert() macro
  

  Summary
• Structures
  Structures do for variables what functions do for code

  Defining a new composite variable (structure) type

  Declaring structures

  When to use structures and what to put in them

  Passing structures to functions

  Pointers to structures

  Passing pointers-to-structures to functions

  Passing pointers between functions

  More than one type of structure

  Thinking at a higher level

  Summary
• Keeping track of memory
  Allocating structures

  Freeing memory

  Keeping track of memory

  Linked lists

  Linked lists

  Creating a linked list

  Traversing a list

  Removing and freeing a member of a list

  Summary
• Recursion
  The test to see if a function must call itself

  Recursively-called functions have their own local variables

  When recursion goes wrong

  Recursive data structures

  Directionality and trees

  Flood fill

  Summary
• C wrap-up
  Unformatted input and output

  Reading in text without interpreting it

  Mixing formatted and unformatted input

  Command-line arguments

  Named constants and enumerations

  Sharing variables between functions

  Static variables inside functions

  Sorting, and pointers to functions

  qsort() can sort arrays of anything
  

  Bitwise operators

  Summary
• Multiple files and the pre-processor
  Splitting source code between files

  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

  #if ... #endif

  Typical uses of #if ... #endif

  Header file protection

  Macros: #defines with arguments

  Summary
• Summary of key points