Some notes about C

#INCLUDE ...

At the top of a C file, includes other files.

Variables are declared only once, before usage and can be initialized by assigning a value. They must have a type and name:

int var;

• Assign a constant value

  myvar = 0;

• Assign another variable

  myvar = othervar;

A variable has a block scope. It is visibile in the block it is declared and in all blocks internal to that block - where it can be redefined and thus masks the one in the outer blocks. It is not available to any block external to its declaration, and it is automatically destroyed at the end of its scope.

A variable defined at file level is global (to that file) and it is initialized to 0 by default.

A variable defined at block level is local (to the block) and overrides any global variable of the same name. It is initialized with a random value.

auto int var;

auto is the default modifier for variables. Automatic variables are destroyed as soon as their scope ends.

extern int var;

Variables declared as extern are accessibile but defined in a different scope (usually in a different file). No memory is allocated.

register int var;

Hints the compiler to store the variable in register memory (which has the fastest access time).

static int var;

Initialized to zero if not explicitly assigned (can only be initialized with constant values). Are not destroyed at the end of their scope and are not visible outside the file (extern modifier raises an error).

Can be int, short or long. unsigned prepended to type force the variable to strore only unsigned values.

The actual size depends on the architecture: sizeof(<type>);

char. Holds one character at time and its size in one byte. Use '' to declare a character.

Can be float, double or long double. They represente floating point fractional numbers and differ by their precision. Size is architecture dependent.

+, -, *, /, %

All associate left to right; + and - have lowest precedence.

++, --

Increment/decrement the value of a variable by one. Operate only on lvalues.

• pre-increment

  ++<var>: var is incremented then used.

• post-increment

  <var>++: var is used then incremented.

==, !=, <=, >=, <, >

&&, ||, !

&& and || operators short circuit, meaning the evaluation ends as soon as a result of the expression is available.

&, |, ~, ^, <<, >>

The first four operators are bitwise and, or, not and xor.

• var << n

  Shifts var by n bits to the left; rightmost positions are filled with zeros. It is equivalent to var * pow(2,n).

• var >> n

  Shifts var by n bits to the right; leftmost positions are filled with zeros. It is equivalent to var / pow(2,n).

var = value

The following shorthand assignment operators are available: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=.

Determines in which order operators are evaluated.

if (condition) {
  statement;
  ...
} else {
  statement;
  ...
}

if can be nested and the else block is optional.

switch (exp) {
  case val1:
    statement(s);
    break;
  ...
  case valn:
    statement(s);
    break;
  default:
    statement(s);
 }

exp evaluation must result in an integer constant value, and val must be an integer constant or an integer expression (or a macro). Duplicate cases are not allowed. break stops the evaluation of cases and the default case is optional.

while (expression) {
  statement 1;
  ...
  statement n;
}

Evaluates statements until expression is true.

for (initialization; condition; increment/decrement) {
  statement 1;
  ...
  statement n;
}

Performs initialization, then evaluates condition and repeat statements until condition is true. increment/decrement is performed after each iteration.

*do {
  statements;
} while(expression);

Evaluates statements as the while loop, but statements are evaluated at least once.

<return_type> myfunction (<type_1> <arg_1>, ..., <type_n> <arg_n>);

This is called function prototype; arguments list is optional and statements are not included.

Definition is like the prototype, with arguments listed and statements included.

myfunction (<actual arguments>);

static function ...

The static keyword restricts the access to the function to the file it is declared into.

A function calls itself directly or indirectly. To avoid infinite loops always specify a base condition to stop the recursion.

<data_type> myarray[N];

N is the number of elements and must be a positive integer constant. N chunks of contiguous memory are allocated.

myarray[] = {val0, ..., valN-1};

myarray[i]

I must be between 0 and N - 1 included.

<data_type> myarray[N1][N2]...[Nn];

Are arrays of arrays.

const <data_type> myarray[N1][N2]...[Nn];

<data_type> myarray[n]

The lenght n is set at runtime, and can be provided by the user or can be the result of a calculation. Variable length arrays can't be set as static variables and can't be initialized.

<type> *mypointer;

type is the type of value mypointer will point to, and must be initialized before use.

*ptr

The * (dereference) operator acts on the value of the object referenced by ptr. It must not be applied to an uninitialized pointer!

*q = p

p and q are pointers to the same type of data. After the assignment both p and q point to the same memory location.

*q = *p

The memory segments pointed by p and q now contain the same value.

return &var;

Never return pointers to local variables.

p + x

Moves pointer p x elements forward from its initial position.

p - x

Moves pointer p x elements backward from its initial position.

p - q

Subtracts q from p; the result is the distance between pointers. p and q must refer to the same array.

p++; ++p

Moves p forward by one element.

p--; --p

Moves p backward by one element.

Usual relational operators are allowed. Comparison is possibile only if both pointers point to the same array.

a[0] == *a;

Array names can be used as pointers to the first element, for example when passing arrays as function argument.

<type> (*p)[N] = &a;

p is a pointer the the whole a N-elements array. **p returns the value of the first element.

char *ptr = "Hello World!";

It is a sequence of characters enclosed in double quotes, stored as an array of characters. It is terminated by \0.

char s[12];

Declares a string of 11 characters (one extra character is needed for the string terminator).

char s[12] = "Hello World";

Declares and initializes the string. The literal can be shorter than the array length, but must not be equal or longer.

char s[] = "A long string";

If the string is initialized from a literal, and the diminsion is not specified, the compiler will set the correct length of the array.

• printf("%s", string);
• puts(string);

scanf("%s", string);

Reads a string from standard input. Treats a whitespace character as the end of the string (%[^\\n]s instead of %s can be used as a workaround). Does not check if the string exceeds the allocated length, but the number of characters to read can be made explicit: %10s.

#include <string.h>;

char array[][N];

Declares an array of strings of length N. All strings have the same length (so memory space can be wasted).

char *array[]

Declares an array of pointers to character. Strings may have different lengths.

<type> (*ptr)(<paramenters>)

Points to a function with the given prototype.

ptr = &<function>;

res = *ptr(<actual parameters>)

struct {
  <type1> var1;
  <type2> var2;
  ...
  <typeN> varN;
}

It is a user defined data type which groups elements of different types.

struct mytype x = {val1, ..., valN};
struct mytype x = {.val1 = ..., .valN = ...};

The first kind of initialization requires that the values of the struct are initialized in order, while the second one allows order free initialization.

val = x.varN;

Values can accessed with the . operator.

struct mytype arr[N];

struct mytype *ptr;

Values can be accessed using the shorthand ptr->x.