A very brief introduction to programming in C

Mike Holenderski
November 10, 2014
Before a variable can be used, it has to be declared,
specifying its type. For example,

A C program can be modeled as a state machine. The

state is defined by the values assigned to the variables
declared in the program. The program code specifies
how its state should change during program execution.
C belongs to the class of imperative programming languages, which have four fundamental primitives for specifying the state transitions: assignment, sequential composition, branching, and loop. Sometimes a program will
contain repetitive code. To make the program code more
readable and concise, the primitives can be combined
into functions, which can be called from other places
in the program.
Section 2 describes how the program state is specified. Sections 3 and 4 introduce the four basic primitives. Functions are presented in Section 5.

int i;
means that variable i is of type int (i.e. it is an integer
number).
In C, boolean variables (i.e. those which can be either
true or false) are represented using the type char or
int, where 0 represents a false value, and anything else
represents a true value. It is customary to use 1 to
represent true.
The integer data types char and int can be either
signed or unsigned. Signed types can represent both
positive and negative values, whereas unsigned types can
only represent values greater or equal to 0. For example,
unsigned int j;
signed int k;

Comments

Programs are meant to be read by other people, not

just machines. To help others understand the code one
should describe using plain language what it does and
any assumptions the code relies on. Such descriptions
are places in comments between the /* and */ signs.
For example,

declares an unsigned integer variable j and a signed integer variable k. Note that integer types are signed by
default, so the previously declared variable i is a signed
integer.

2.2

/* This is short a comment */

Arrays

Arrays represent fixed size sequences of values of the

same type. An array variable is defined by the type of
the values it contains and its size. For example,

Variables

int a[3];
The program state is defined by the values assigned to all
variables in the program. Each variable is of a particular declares an array variable called a which contains 3 intype, which describes what kind of values the variable teger values.
can assume. We distinguish the following types:

2.1

2.3

Simple types

Structures

A structure (or a tuple) is a collection of data types

which you want to treat as a single entity. For example,

The most common simple types are

1. char: an 8-bit integer number1

struct {
int x;
int y;
} point;

2. int: a 16-bit integer number2

3. float: a 16-bit rational number2
1 char

used to represent a letter character, hence the name.

exact bit-size of a variable type depends on the underlying
processor architecture. These values hold for a 16-bit controller.

declares a variable point, which may represent a point in

a two dimensional grid with integer coordinates x and y.

2 The

2.4

Type definition

2.7

Initial values

It may be convenient to introduce aliases for certain When declaring a variable one can also specify its initial
value, which the variable will hold at the moment that
types, in particular structures. For example,
the program starts executing. For example,
typedef struct {
int i = 42;
int x;
int y;
declares an integer i which will be initialized to 42.
} Point;
The value of an uninitialized variable is undefined.
declares a Point to be a structure type, containing two
integer fields x and y. The Point type can then be used
to declare other variables. For example,

Assignment

An assignment accomplishes a state change during program execution, by assigning a new value to a variable.
An assignment has the following syntax:

Point p1;
Point p2;
declares two structure variables p1 and p2, each containing an x and y field.

<variable> = <expression>;

where <variable> is the name of the variable which will

acquire the value expressed by the <expression>. An
2.5 Pointers (Advanced)
<expression> is comprised of constant values (such as
numbers), variable names, function calls (see Section 5),
A pointer points to another variable. Pointers are comand operators (such as == or <). A variable name
monly used in combination with structure types. For
inside of the <expression> represents the current value
example,
held by the corresponding variable.
C provides the following basic operators:
Point* p;
a
a
a
a
a
a

declares a pointer variable p which points to a Point

structure.

2.6

Functions (Advanced)

A variable can also be of a function (see Section 5) type.

A function declaration specifies a functions signature,
i.e. the types of all its arguments, and the type of its
return value. For example,

3.1

==
!=
<=
>=
||
&&

b
b
b
b
b
b

check
check
check
check
check
check

if
if
if
if
if
if

a
a
a
a
a
a

and b are equal

and b are not equal
b
b
or b is true (i.e. not 0)
and b are both true

Simple types

For example,

char (*f)(Point*, int);

i = i + 1;

declares a variable f, which is a pointer to a function

which takes two arguments: the first of type Point*
and the second of type int, and returns a value of type
char.
A C function, besides returning a value, can also
change the program state. A void return type means
that the function does not return any value. Such a
function only changes the program state. Similarly, a
void argument list means that the function does not
accept any arguments. For example,

increments the value of the i variable by 1. Another

example,
k = i > 10;
compares the value of i to 10, and if it is larger than 10,
then k is assigned 1 (representing true), otherwise it is
assigned 0 (representing false).

3.2

Arrays

Individual elements of an array variable can be accessed

using the bracket notation. For example,

void (*g)(void);

a[2] = a[1] + 20;

declares a function variable, which does not accept any
arguments nor does it return any value.
takes the value of the second element of array a, adds
Function types can also be defined. For example,
20 to it, and assigns the result to the third element of a.
typedef char (*PointFunction)(Point*, int); Note that arrays are indexed starting at 0, i.e. an
array declared with
defines a function type PointFunction. All functions of
int a[3];
this type take one Point* and one int argument, and
return a value of type char.
will contains elements a[0], a[1], and a[2].
2

3.3

Structures

3.6

Functions (Advanced)

Individual fields of a structure variable can be be ac- A function variable can be assigned a particular function
cessed using the dot notation. For example,
definition (see Section 5). For example,
p2.y = p1.x + 2;

char LongerThan(Point*, int);

PointFunction f;

assigns to the p2.y field a value which is equal to the

value of p1.x plus 2. We can also assign the value of declares a LongerThan function, and a function variable
an entire structure to another structure variable. For f of type PointFunction. We can assign a particular
example,
function to a function variable, as long as their signatures match. For example,
p2 = p1;
f = LongerThan;
copies the field values from p1 to p2, i.e. after the assignment, p2.x will have acquired the value of p1.x, and assigns the LongerThan function to the function varip2.y will have acquired the value of p1.y.
able f.

3.4

Constants

Control flow

A constant provides a name for a fixed value which does

not change during runtime. Constants are useful for Control flow describes how to combine assignments to
maintaining the code, when the same value is used in create programs. The three essential control flow primseveral places in the program: the value assigned to a itives are: sequential composition, branching, and loop.
constant needs to be changed only in one place in the
code. For example,

4.1

Sequential composition

#define N 1000

Assignments and declarations can be combined into sewill make sure that any occurrence of N in the code will quences using the ; sign, meaning that the joined asbe substituted with 1000. Note that it is a textual sub- signments should be executed one after the other. For
stitution. For example,
example,
#define e 1+1
Point point;
int x = e*2;
point.x = 1;
point.y = point.x + 2;
will evaluate to x = 1 + 1 2 = 3, rather than x =
(1 + 1) 2 = 4.
will declare variable point and then assign 1 to point.x,
and subsequently 3 to point.y.
3.5 Pointers (Advanced)
Note that in C the ; sign must also follow the last
assignment.
A pointer can be assigned a reference to another variable. For example,

4.2

p = &p1;

Branching

assigns to the pointer p a reference to the structure p1. Sequential composition on its own can express only the
A pointer can be dereferenced, returning the value of most basic programs and is not sufficient for most programming tasks. A conditional branch can be introthe variable it is pointing to. For example,
duced into the sequence using the if-then-else statement.
p2 = *p;
For example,
assigns to the fields of the structure p2 the values of the
structure pointed to by the p pointer.
A pointer to a structure, e.g. the p pointer, must be
dereferenced to access the individual fields. For example,

if (i > 42) {
/* then branch: we know that i > 42 */
point.x = i;
point.y = 2*i;
} else {
/* else branch: we know that i <= 42 */
point.x = 0;
point.y = 0;
}

k = (*p).x;
assigns the value of the x field of the Point structure
pointed to by the p pointer.
There is an alternative notation for accessing a filed
of a structure pointed to by a pointer. For example,

checks if i is greater than 42, and if so, executes the

point.x = i; point.y = 2*i; branch. Otherwise, it
executes the point.x = 0; point.y = 0; branch. The

k = p->x;
is equivalent to k = (*p).x;
3

curly braces { and } enclose the code comprising Local vs. global variables
a branch. Note that only one of the branches will be
The scope of a variable determines from where it can be
executed.
accessed. A local variable is declared inside of a funcIt is also possible to skip the else branch. For example,
tion and can be accessed only within that function. A
global variable is declared outside of functions (on the
if (i > 42) {
global level) and can be accessed within any function.
point.x = i;
For example,
point.y = 2*i;
}
int i;
checks if i is greater than 42, and if so, executes point.x
= i; point.y = 2*i;. Otherwise, it does nothing.

4.3

int Factorial(int x) {
int y = 1;
int k = 1;
while (k <= x) {
y = y * k;
k = k + 1;
}
return y;
}

Loop

A conditional loop will keep executing a piece of code

until its guard is false. For example,
while (i > 42) {
point.x = point.x - i;
point.y = point.y + i;
i = i + 1;
}

int main(void) {
int k = 10;
int x;
i = 0;
while (i < k) {
x = Factorial(i);
i = i + 1;
}
}

checks if i is greater than 42, and keeps executing its

body (enclosed by curly braces) until the condition is
false (i.e. i is less or equal to 42).

Functions

declares a global variable i, which is accessible form

Factorial() and main().
Both functions declare
their own local variable k, i.e. the k declared inside
Increment() does not interfere with the k declared in
main(), and vice-versa. The same hods for variable x,
since function arguments are treated as local variables.
Important: all local variables must be declared before
any assignments or function calls!

To enable code reuse and recursion, parts of the code can

be grouped into functions. For example, imagine that
our program needs to compute a lot of dot products. We
would like to introduce a function which will compute
the dot product of two free vectors. We can declare a
function
int DotProduct(Point, Point);
which takes two Point arguments and returns a value
of type int. We can then define this function as

References
[1] Niklaus Wirth, Algorithms & data structures, Prentice Hall, 1985

int DotProduct(Point a, Point b) {

int dotProduct = a.x*b.x + a.y*b.y;
return dotProduct;
}

[2] B. Kernighan, D. Ritchie, The C Programming Language, 2nd Edition, Prentice Hall, 1988

This defines function DotProduct, which takes two

Point arguments a and b, and returns the dot product
of the vectors pointed to by a and b.
A function can be called (or executed) by instantiating
its arguments. For example,
k = DotProduct(p1, p2);
calls the function DotProduct, instantiating the a argument with p1 and the b argument with p2, and assigns
the result to variable k. After this function call k will
be equal to the dot product of vectors p1 and p2.
4