Résumé Language C
I- Instructions de base :
ccc
Types des données Opérateurs arithmétiques
Entiers int ⇒ %d , long ⇒ %ld + Addition
Réels float/double ⇒ %f , long double - Soustraction
Caractères char ⇒ %c , %s (Chaine) * Multiplication
Booléen bool / Division
% Le modulo
Déclaration des variables Opérateurs d’affectation
Variable Type Nom_var = valeur ; = Affectation simple
Constante Const Type Nom_const = valeur ; += Addition puis affectation
-= Soustraction puis affectation
Les fontions de base *= Multiplication puis affectation
printf Écriture sur la sortie standard /= Division puis affectation
scanf Lecture des variables %= Modulo puis affectation
Opérateurs d’incrémentation
Caractères d’échappement ++ Incrémentation
\n Retour à la ligne -- Décrémentation
\t Tabulation horizontale Opérateurs de comparaison
\",\’,\%,\\ Affichage du caractère == Égalité
< Infériorité stricte
Structure d’un Programme C : <= Infériorité
// Les bibliotiques : > Supériorité stricte
#include <stdio.h> >= Supériorité
#include <stdlib.h> != Différence
#include <stdbool.h> Opérateurs Logiques
#include <math.h> && ET logique
#include <string.h> || OU logique
int main () {
! Négation
// Les instructions :
printf("Hello world"); Les commentaires en C :
return 0; On utilise /* ... */ ou // ...
}
Les variables :
Variable Locale : F Variable Globale :
T Déclarée à l’intérieur d’une fonction. T Déclarée en haut du programme.
T Utilisée à l’intérieur de cette fonction. T Utilisée dans tout le programme.
1 Language C Compil’Court
II - Structures conditionnelles :
1- Structure conditionnelle simple :
F
if (condition) if (condition) {
instruction ; instruction1 ;
/*Si la condition est vraie le bloc s’execute, instruction2 ;
sinon il sera ignore*/ }
F
2- Structure alternative : 3- Structure imbriquée :
if (condition) { if (condition1 ) {
instructions ; instructions ;
... } else if (condition2 ) {
} else { instructions ;
instructions; } else {
... instructions ;
} }
4- Structure à choix multiple :
Lorsque l’imbrication des alternatives devient importante , l’utilisation de la structure à choix
multiple devient nécessaire.
switch (expression) {
case valeur1 : instruction1 ;
break ;
case valeur2 : instruction2 ;
break ;
...
default : instruction ;
break ;
}
III - Les structures répétitives :
1- Les boucles :
La boucle For : La boucle While : La boucle Do While :
Permet dexécuter des instruc- Permet de répéter des ins- F Permet de répéter des instruc-
tions un nombre de fois connu tructions tant qu’une condi- tions tant qu’une condition est
fixé à l’avance. tion est vraie. vraie.
for (init;cond;increment){ while (condition) { do {
instructions ; instructions ; instructions ;
} } } while (condition);
Compil’Court Language C 2
2- Contrôle des boucles :
Break : F Continue :
Permet d’arrêter le déroulement d’une boucle et Permet d’ignorer l’itération actuelle de la
de passer à l’instruction qui suit cette boucle. boucle et de passer à l’itération suivante.
boucle (...) { boucle (...) {
... ...
break; continue;
... ...
} }
... ...
IV - Les tableaux :
1- Tableaux à une dimension :
Syntaxe de déclaration Accéder aux éléments
Type Nom_Tab[size]; Affectation Nom_Tab[indice] = valeur ;
F
Type Nom_Tab1 [size] = {x1,..,xi}; Lecture scanf("% ..",&Nom_Tab[indice]);
Type Nom_Tab2 [ ] = {x1,..,xi}; Écriture printf("% ..",Nom_Tab[indice]);
2- Tableaux à deux dimensions :
Syntaxe de déclaration : F Accéder aux éléments :
Type Nom_Tab[nbr_lign][nbr_col]; Nom_Tab[num_lign][num_col] = valeur ;
V- Les chaînes de caractères :
ccc
T Une chaîne de caractères est traitée F Affichage et écriture
comme un tableau de caractères dont c = getchar() Lecture d’un caractère
la fin est marquée par le caractère ’\0’. putchar(c) Affichage d’un caractère
T On utilise ’%c’ comme spécificateur gets(ch) Lecture d’une chaîne
de format de caractère, et ’%s’ pour puts(ch) Affichage d’une chaîne
une chaîne de caractères. Fonctions sur les chaînes
T Il existe plusieurs fonctions sur strlen(a) Revoie la taille de la chaîne a
les chaîne dans la bibliothèque strcpy(a,b) Copie la chaîne b dans a
<string.h>. strcat(a,b) Ajoute les caractères de b à a
strcmp(a,b) Renvoie 0 si a et b identiques
Syntaxe de déclaration strchr(a,’x’) Trouve 1re occurrence du x ds a
char ch ; strstr(a,’xy’) Trouve 1reoccurrence de’xy’ds a
char caractere = ’A’ ; strrev(a) Inverse la chaîne a
char chaine[] = "Hello" ; strlwr(a) Renvoie la chaîne a en miniscule
strupr(a) Renvoie la chaîne a en majuscule
3 Language C Compil’Court
VI - Les fonctions :
1- Déclaration et appel des fonctions :
No Retour, No Args : F No Retour, Args :
void Nom_fun (){ void Nom_fun (arg1,...){
instructions ; instructions ;
} }
//Appel : //Appel :
Nom_fun (); Nom_fun (arg1,...);
Retour, No Args : Retour, Args :
Type_retour Nom_fun (){ Type_retour Nom_fun (arg1,...){
instructions ; instructions ;
return resultat ; return resultat ;
} }
//Appel : //Appel :
x = Nom_fun (); x = Nom_fun (arg1,...);
printf(Nom_fun ()); printf(Nom_fun (arg1,...));
VII - Les structures :
Une structure est un objet composé de plusieurs champs qui sert à représenter un objet réel ou un
concept.
struct nom_de_structure {
type1 nom_champ1 ;
type2 nom_champ2 ;
...
typeN nom_champ_N;
} variables ;
VIII - Les pointeurs :
1- Généralités sur les pointeurs :
Qu’est ce qu’un pointeur ? F Création d’un pointeur :
Un pointeur est une variable qui peut contenir
L’adresse d’une autre variable. int a ;
int *p = &a ;
Les opérateurs de base : ou :
& : pour obtenir l’adresse d’une variable.
int a ;
* : pour accéder au contenu d’une adresse.
int *p ;
%p : specificateur de format , pour afficher
p = &a ;
l’adresse mémoire d’une variable.
Passage par valeur vs Passage par adresse :
T Par valeur, une copie des arguments réels est transmise aux arguments formels respectifs.
T Par adresse, L’emplacement (adresse) des arguments réels est transmis å des arguments
formels, toute modification apportée aux arguments formels se reflétera dans les arguments
réels.
Compil’Court Language C 4
2- Pointeurs - Tableaux :
Si T un tableau et i un index de ses éléments : F Si P = T :
T : désigne l’adresse de l’élément T [0] P : pointe sur l’élément T [0]
T+1 : désigne l’adresse de l’élément T[i] P+1 : pointe sur l’élément T [i]
*(T+1) : désigne le contenu de l’élément T[i] *(P+1) : désigne le contenu de l’élément T [i]
3- Arithmétique des pointeurs :
la fontion sizeof() : fournit la taille (en octets) du type ou de la variable qui suit.
Incrémentation : p + + ⇐⇒ &T[0+1] ;
Décrémentation : p - - ⇐⇒ &T[2-1] ;
Addition : p = p + 3 ⇐⇒ &T[0+3] ;
Soustraction : q - 2 ⇐⇒ &T[3-2] ; et q - p ⇐⇒ Distance entre p et q ;
Comparaison : La comparaison de deux pointeurs qui pointent dans le même tableau est équi-
valente å la comparaison des indices correspondants.
IX - Allocation dynamique de la mémoire :
1- Types d’allocation de la mémoire :
Allocation automatique : F Allocation dynamique :
Lorsque vous déclarez une variable á l’aide d’un le compilateur alloue ou libére manuellement
type de données de base, le compilateur alloue de l’espace mémoire en fonction des besoins de
automatiquement de l’espace mémoire pour La programmation. La mémoire dynamique est
variable dans une zone de mémoire RAM appe- gérée dans une partie de la mémoire RAM ap-
lée Stack. pelée Heap.
2- Allocation dynamique :
Pour allouer dynamiquement de la mémoire, le langage c nous propose d’utiliser les fonctions :
malloc(), calloc(), realloc() et free().
Ces fonctions sont définies dans la bibliothéque : <stdlib.h>
Fonction malloc : Permet d’ allouer la mé- F Fonction realloc : Si la mémoire allouée est
moire de la taille demandée et renvoie un poin- insuffisante ou supérieure celle requise, nous
teur sur le premier octet de l’espace alloué. pouvons modifier la taille de La mémoire pré-
cédemment allouée.
void *malloc( size-octet ) ;
void *realloc(pointer, size-octet);
Fonction calloc : Utilisée pour allouer Le
nombre spécifié de blocs de mémoire du type Fonction free : Permet de libérer ou de vider
spécifié. Elle initialise chaque bloc avec une va- l’espace mémoire alloué.
leur par défaut «0».
void free( pointeur ) ;
void *calloc(nbrs-elem , size-elem);
5 Language C Compil’Court
