notes/education/software development/ECE1400/C.md

Compilation Steps

1. Preprocessing: The preprocessor obeys commands that begin with #, also known as directives Commands for the preprocessor are called directives. Directives begin with a pound sign, and they do not end with a semicolon.

Example:

#include <stdio.h>

2. Compiling. A compiler translates then translates the program into machine instructions.
3. Linking: The generated objects are combined to create a complete executable.

The preprocessor is typically integrated with the compiler.

Types

Strings

A string literal is characters enclosed in double quotation marks.

A newline can be inserted using \n.

Integers

An integer is a way to store a whole number. In C, integers are signed by default.

Values of an integer type are whole numbers.

Integers are divided into two categories, signed, and unsigned.

Floats

A float is a decimal value. Slower arithmetic and inexact values are both drawbacks of using floats.

Variables

A variable must be declared before it is assigned.

Formatting specifiers

Standard library

Formatting specifiers

Specifier	Function
%d	Decimal representation: Display a value as a base 10 (hence the decimal) integer.
%f	Fixed point decimal representation. Specify the number of places to round to by adding a decimal and a number, eg %.2f would round to two decimal places.
%e	Exponential floating point number representation.
%g	Either fixed point or exponential representation, whichever has a more compact representation.
For number formatting specifiers, the convention is as follows:
%-a.bX
%: Start of the formatting specifier
-: (optional) If included, justify value left in space. Otherwise, justify right in space
a: (optional) If included, the size of the field in characters.
.: Separator between a and b. Optional if b is not specified
b: The number of decimal places to round to
X: The type of format to use, and the end of the specifier. Use d for integer base 10 (decimal) representation, f for fixed point decimal, and e for exponential notation, and g to select between fixed point and exponential, whichever is shorter.

printf

Used to write a string to stdout with the ability to format variables into the string.

Write a string to standard output. f indicates that it's a formatting string. The string will not include move the cursor to a newline, append \n to the end of the string to do so.

Printf accepts a variable number of arguments, the first argument is the formatting string, then following arguments are the arguments to be inserted into the string.

TODO: examples

scanf

Read value(s) from stdin.

scanf is to stdin as printf is to stdout.

The format of the input is specified using formatting specifiers, and all following arguments are pointers pointing to variables to update.

Examples

// Read a float from standard input into the variable `v`.
float v;
// Here, `v` is uninitialized
scanf("%f", &v);

printf("You input: %f", v);

Behavior

The validity of a scanf call is not necessarily checked at compile time, and so the number of outputs specified should match the number of inputs.

For each formatting specifier specified in the string, scanf will attempt to locate an appropriate value in the input, skipping whitespace and newlines if necessary until the beginning of a number is reached.

When asked to read an integer, scanf searches for one of:

• A digit
• A plus or minus sign It will continue to read until it reaches a nondigit (whitespace is not skipped in this case, and it is counted as a nondigit). If it doesn't encounter a valid digit first, it will return early.

When asked to read a float, scanf searches for one of:

• A plus sign or minus sign
• A series of digits (possibly containing a decimal point), followed by an exponent (optional). An exponent consists of the letter e or E, an optional sign, and one or more digits. %e, %f, and %g all follow the same rules for recognizing floating point numbers.

If an ordinary character is included in the pattern matching string, it will be matched then discarded before proceeding to the next character.