Variables Opérateurs

En C, une donnée est stockée dans une variable caractérisée Operateurs arithmétiques
par : * multiplication Operateurs de comparaison
I son type et son identificateur (définis lors de la / division == teste l’égalité logique
déclaration) ; % modulo != non égalité
I sa valeur, définie la première fois lors de l’initialisation puis + addition < inférieur
éventuellement modifiée par la suite. - soustraction > supérieur
- opposé (1 opérande) <= inférieur ou égal
Rappels de syntaxe : Types élémentaires : ++ incrément (1 opérande) >= supérieur ou égal
type id ; int -- décrément (1 opérande)
type id = valeur; double
char Operateurs logiques
id = expression ; && "et" logique
|| ou
Exemples : int val = 2 ; ! négation (1 opérande)
double const pi = 3.141592653;
i=j+3; Priorités (par ordre décroissant, tous les opérateurs d’un même groupe
sont de priorité égale) :
Les variables non modifiables se déclarent avec le mot réservé () [] -> ., ! ++ --, * / %, + -, < <= > >=, == !=,
const : &&, ||, = += -= etc., ,
©EPFL 2021 ©EPFL 2021
Jean-Cédric Chappelier double const g = 9.81; Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 1 / 13 Programmation Orientée Système – Fiches Résumé – 2 / 13

Les structures de contrôle Les fonctions

les branchements conditionnels : si ... alors ... Prototype (à mettre avant toute utilisation de la fonction) :
if (condition) switch (expression) {
type nom ( type1 arg1, ..., typeN argN );
. . . .instructions
......................... case valeur:
type est void si la fonction ne retourne aucune valeur.
instructions;
if (condition 1) break;
instructions 1 ...
... Définition :
default:
else if (condition N) instructions; type nom ( type1 arg1, ..., typeN argN )
instructions N } {
else
corps
instructions N+1
return value;
les boucles conditionnelles : tant que ... }
while (condition) do Instructions while
Instructions (condition); Passage par valeur : Passage par référence (va-
leur de pointeur en fait) :
les itérations : pour ... allant de ... à ...
for (initialisation ; condition ; increment) type f(type2 arg); type f(type2* arg);
instructions f(x) f(&x)
les sauts : break; et continue;
+ x ne peut pas être + x peut être modifié par f
Note : instructions représente 1 instruction élémentaire ou un bloc. modifié par f
©EPFL 2021
instructions; représente une suite d’instructions élémentaires. ©EPFL 2021
Jean-Cédric Chappelier Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 3 / 13 Programmation Orientée Système – Fiches Résumé – 4 / 13
 Les tableaux Les structures
Déclaration du type correspondant :
déclaration : type identificateur[taille];
déclaration/initialisation : struct Nom_du_type {
type identificateur[taille] = {val1 , ... , valtaille }; type1 champ1 ;
type2 champ2 ;
Accès aux éléments : tab[i] i entre 0 et taille-1 ...
};
Le passage type1 f(type2 tab[]); d’un tableau tab à une
fonction f se fait automatiquement par référence Déclaration d’une variable :
pour éviter les effet de bords : type1 f(type2 const tab[]); struct Nom_du_type identificateur;

tableau multidimentionnel : Déclaration/Initialisation d’une variable :

type identificateur[taille1][taille2]; struct Nom_du_type identificateur = { val1, val2, ...};
tab[i][j];
Accès à un champs donné de la structure :
identificateur.champ
Les tableaux ne peuvent pas être des types de retour pour les
fonctions. :-( Affectation globale de structures :
©EPFL 2021 ©EPFL 2021
identificateur1 = identificateur2
Jean-Cédric Chappelier Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 5 / 13 Programmation Orientée Système – Fiches Résumé – 6 / 13

Les pointeurs Les chaînes de caractères

Déclaration : type* identificateur; Valeur littérale : "valeur"

Adresse d’une variable : &variable Déclarations :

Accès au contenu pointé par un pointeur : *pointeur char* nom;
char nom[taille];
Pointeur sur une constante : type const* ptr; char nom[] = "valeur";
Pointeur constant : type* const ptr = adresse;
Écriture : printf("...%s...", chaine); ou puts(chaine);
Allocation mémoire :
#include <stdlib.h> Lecture : scanf("%s", chaine); ou gets(chaine);
pointeur = malloc(sizeof(type));
Quelques fonctions de <string.h> :
pointeur = calloc(nombre, sizeof(type));
pointeur = realloc(pointeur, sizeof(type)); strlen strcat
strcpy strncat
Libération de la zone mémoire allouée : free(pointeur);
strncpy strchr
strcmp strrchr
Pointeur sur une fonction : type_retour
strncmp strstr
(* ptrfct)(arguments...)
©EPFL 2021 ©EPFL 2021
Jean-Cédric Chappelier Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 7 / 13 Programmation Orientée Système – Fiches Résumé – 8 / 13
 Les entrées/sorties Les entrées/sorties (fichiers)
Type : FILE*
ouverture : FILE* fopen(const char* nom, const char* mode)
Clavier / Terminal : stdin / stdout et stderr Mode :
"r" en lecture, "w" en écriture (écrasement), "a" en écriture (à la
Fichier de définitions : #include <stdio.h>
fin), suivit de ’+’ pour ouverture en lecture et écriture, et/ou de ’b’
Utilisation : pour fichiers en binaires
écriture : int printf("FORMAT", expr1, expr2, ...);
Écriture :
lecture : int scanf("FORMAT", ptr1, ptr2, ...);
fprintf(FILE*, ...) pour fichiers textes
Saut à la ligne : ’\n’ size_t fwrite(const void* adr_debut, size_t taille_el, size_t
nb_el, FILE*); pour les fichiers binaires
Lecture d’une ligne entière :
char* fgets(char* s, int size, FILE* stream); Lecture :
fscanf(FILE*, ...) pour fichiers textes
size_t fread(void* adr_debut, size_t taille_el, size_t nb_el,
FILE*); pour les fichiers binaires
Test de fin de fichier : feof(FILE*)
©EPFL 2021
Jean-Cédric Chappelier
©EPFL 2021
Jean-Cédric Chappelier
Fermeture du fichier : fclose(FILE*)
Programmation Orientée Système – Fiches Résumé – 9 / 13 Programmation Orientée Système – Fiches Résumé – 10 / 13

C : divers Compulation séparée

Prototype le plus général de main :
int main(int argc, char *argv[]) Compilation modulaire
⇒ séparation des prototypes (dans les fichier .h) des définitions
argc : nombre d’arguments, taille du tableau argv (dans les fichiers .c)
argv : tableau de pointeur sur des caractères : tableau des
⇒ compilation séparée
arguments.
1. Inclusion des prototypes nécessaires dans le code :
argv[0] est le nom du programme
#include "header.h"
Précompilation : 2. Compilation vers un fichier "objet" (.o) : gcc -c prog.c
#define alias ( arguments ) sequence a reecrire 3. Lien entre plusieurs objets :
où la portion ( arguments ) est optionnelle gcc prog1.o prog2.o prog3.o -o monprog
Makefile :
#if expression
moyen utile pour décrire les dépendances entre modules d’un
ou
projet (et compiler automatiquement le projet)
#ifdef identificateur
ou Syntaxe :
#ifndef identificateur
cible: dependance <TAB>commande
puis #elif ou #else, optionnels,
©EPFL 2021
Jean-Cédric Chappelier
et le tout terminé par #endif. ©EPFL 2021
Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 11 / 13 Programmation Orientée Système – Fiches Résumé – 12 / 13
 Déverminage
Pour utiliser un programme de déverminage, compiler avec
l’option -g
gcc -g -o monprogramme monprogramme.cc
Lancer le dévermineur : gdb monprogramme ou ddd monprogramme
Démarrer mon programme dans gdb/ddd : run ou run arguments
Suspendre l’exécution du programme à des endroits précis :
utiliser le bouton « breakpoints » ou la commande break

Exécuter pas à pas : next ou step

Regarder le contenu d’une variable :
I soit en mettant la souris dessus
I soit print nom_variable
I soit display nom_variable
La valeur de la variable est alors affichée à chaque pas de
©EPFL 2021
programme.
Jean-Cédric Chappelier

Programmation Orientée Système – Fiches Résumé – 13 / 13