#include <stdio.h>

/* la fonction main est appelée automatiquement à l'exécution du programme */
int main() {
  printf("Hello, world!\n");
  return 0; // valeur de retour
}

Quelques remarques :

• sensible à la casse
• caractères blancs ne sont pas significatifs
• commentaires sur une ligne indiqués par //, sur plusieurs lignes entre /* et */

int a = 12; int b = 5;
// bloc d'instructions après if
if (a > 0) {
  a += 1;
  b = a + b;
}

• Les instructions se terminent par un point virgule
• On peut grouper plusieurs instructions entre accolades

$ gcc -Wall code.c -o prog

$ ./prog
Hello, world!

• Les programmes en C ne sont pas directement exécutables
• Il faut les compiler
• La compilation produit un fichier exécutable (langage machine)
• La compilation s'effectue en plusieurs temps :
  • précompilation (traîtement syntaxique)
  • compilation (génération de code machine)
  • édition de liens (production d'un exécutable en combinant les fonctions)

#include <stdio.h>
#include <stdlib.h>
#include "fichier.h"

#define PI 3.14159
#define ever ;1;

int main() {
  int n = 1;
  for(ever;1;) {
    if (PI3.14159 / n < 1) {
      break;
    }
    n++;
  }
}

• Inclusion de fichiers (#include)
• Remplacement de constantes et macros (#define)

#include <math.h>

float hyp(int, int);

float hyp(int a, int b) {
  float r;
  r = sqrt(a * a + b * b);
  return r;
}

Chaque fonction a un prototype (ou signature) :

• type de retour
• nom
• liste des arguments : type éventuellement suivi du nom

Le prototype sert à définir le cadre d'utilisation de la fonction

Exemple: stdio.h

int main() {
  // code principal du programme
  return 0;
}


int main(int argc, char *argv[]) {
  // affiche tous les arguments :
  for (int i=0; i<argc; i++) {
    printf("%s\n", argv[i]);
  }
}

Tout programme doit comporter une fonction main

• C'est cette fonction qui est exécutée quand le programme est lancé
• la fonction main peut faire appel aux autres fonctions
• son type de retour est toujours un entier (code de retour du programme)
• elle peut recevoir des arguments correspondant aux options lors de l'appel :
  • un entier indiquant le nombre d'arguments
  • un tableau contenant des chaînes de caractères (les arguments)

int a = 12;
unsigned int b;
long int c;
long long int d;
unsigned long long int e;

float x = -2.72;
double y;

char s = 'A';

• Chaque variable doit avoir un type défini
• Le type permet au compilateur de déterminer l'espace mémoire occupé par la variable et de décoder correctement sa valeur
• Il existe plusieurs types de données « élémentaires » prédéfinis

int x = 12;

if (x > 0) {
  x--;
} else {
  x++;
}

while (x > 1) {
  x--;
}for (int i=0; i < 5; i++) {
  x *= 2;
}

// version équivalente avec un while
int i=0;
while (i < 5) {
  x *= 2;
  i++;
}switch (x % 3) {
  case 1:
    x -= 1;
    break;
  case 2:
    x += 1;
    break;
  default:
    x += 3;
    break;
}

On peut contrôler le déroulement du programme en fonction des valeurs des variables à l'aide de structures de contrôle :

• if/else permet d'exécuter une instruction si une condition est vérifiée ou non
• while permet d'exécuter une instruction tant qu'une condition est vraie
• for est une syntaxe spéciale qui génère une boucle while
• switch permet d'exécuter des instructions en fonction de la valeur d'une expression

char c = 'A'; // 'A' = 65
int a = 3;
int b = 2;
unsigned int u;
float x, y;

x = a / b;
y = (float) a / b;
// x = 1, y = 1.5

a = (int) 3.9;
b = -1;
u = (unsigned short) b;
b = a + c;
// a = 3, u = 65535, b = 68

Dans certains cas, il est possible de convertir une variable d'un type en un autre (cast) :

• la plupart des types de base sont interconvertibles car ils représentent tous des nombres
• pour demander la conversion explicite en un type, on préfixe la variable du type entre parenthèse
• certaines conversions sont faites implicitement lors d'opérations entre deux types différents
• la conversion d'un float en int élimine la partie fractionnaire (arrondi inférieur en positif, et supérieur en négatif)

/* déclarations */
int tab[10];
// le programme réserve 40 octets
long int tab2[10];
// le programme réserve 80 octets
char s[20];
// le programme réserve 20 octets

/* utilisation */
tab[0] = 0;
tab[1] = 1;
for (int i = 2; i < 10; i++) {
  tab[i] = tab[i-1] + tab[i-2];
}

// initialisation à la création
int t[4] = {1, 2, 3, 4};

• Un tableau contient toutes les valeurs à la suite en mémoire
• L'espace mémoire d'un tableau est donc égal à la taille d'un élément multiplié par le nombre d'éléments
• La variable correspondant au tableau ne contient pas véritablement toutes les valeurs, mais simplement l'adresse mémoire où se trouve la première case du tableau
• Pour trouver la valeur en position i dans le tableau, il faut aller à l'adresse de la première case, et se déplacer de i fois la taille d'un élément

int a, b, *p;

a = 10;
p = &a;

// *p vaut 10

b = *p;
a++;

// a = 11, *p = 11, b = 10

• Un pointeur est une variable qui contient l'adresse mémoire d'un objet (et qui connaît le type de l'objet pointé)
• La notation *p désigne la valeur qui se trouve à l'adresse p
• La notation &a désigne l'adresse à laquelle est stockée la variable a
• Dès que l'on manipule des objets plus complexes que les types de base, les variables contiennent des pointeurs vers les objets et non pas les objets eux-mêmes

int *p1;      // supposons p1 = 2100
int *p2;      // supposons p2 = 3300
sizeof(int);  // 4
p1 + 5;       // 2120
p1 - 3;       // 2088
p1++;         // p1 = 2104
p1--;         // p1 = 2100
p2 - p1;      // 300

void *p3 = p1;
char *p4 = p1;
p3 + 3;       // 2103
p4 - 5;       // 2095

On peut faire des opérations arithmétiques sur les pointeurs :

• pointeur + entier
• entier + pointeur
• pointeur - entier
• pointeur++
• pointeur--
• pointeur - pointeur

Les autres opérations ne sont pas valides

Attention : Pour toutes ces opérations, l'unité correspond à la taille en mémoire du type pointé

int a, b;
a = 1;
b = a;

a = 2; // a = 2, b = 1

int u[3] = {0, 10, 20};
int *v;
v = u;
u[1]++; // u[1] = 11, v[1] = 11
v++; // u[1] = 11, v[1] = 20

char *n, *m;
n = "abc";
m = n;
n = "def"; // n = "def", m = "abc"

• Lorsqu'on copie une variable contenant une valeur de type simple (int, char, float, etc.), la valeur est copiée et les deux variables sont indépendantes
• Si deux pointeurs sont égaux, toute modification du contenu de l'un modifie également le contenu de l'autre

int longueur (char *s) {
  int i = 0;
  while (s[i] != '\0') {
    i++;
}
  return i;
}

int main() {
  char *s = "Youpi";
  int l = longueur(s); // l = 5
  char nom[4];
  nom[0] = 'B';
  nom[1] = 'o';
  nom[2] = 'b';
  nom[3] = '\0';
  l = longueur(nom); // l = 3
}

• Les chaînes de caractères sont des tableaux de caractères, dont la dernière case contient'\0'
• En général il n'est donc pas nécessaire de mémoriser la longueur d'une chaîne de caractères
• Lorsque l'on réserve l'espace mémoire manuellement, il faut faire attention à prendre une case de plus pour le caractère '\0'

// définition du type
struct Voiture {
  int nb_portes;
  char *marque;
};

// initialisation
struct Voiture v1;
v1.marque = "Peugeot";
v1.nb_portes = 5;

struct Voiture v2 = {
  .nb_portes = 3,
  .marque = "Volvo",
};

struct Voiture v3 = {2, "Fiat"};

• Les structures sont des objets en C contenant plusieurs champs
• La définition d'une structure donne un type et un nom à chaque champ
• On accède aux champs à l'aide de la notation pointée
• Les valeurs des champs d'une structure sont stockés à la suite en mémoire
• La taille occupée en mémoire par une structure est égale à la somme des tailles des différents champs
• On peut utiliser sizeof pour trouver la taille