Programmation en C

et C++
ALTN51
L3 APP LSI

Marwa HARZI --- [Link]@[Link]

Soufia BENNAI --- [Link]@[Link]

2022 / 2023
Présentation du cours

Cours de 30h répartis en:

§ DE (2h).
§ TPA (1h).
§ CTD / CTP (27h).

Évaluations :

§ Devoir écrit (DE) -- 60.00% (Mardi 04 octobre 2022)

§ Interrogation de TP (TP) -- 40.00%
Chapitre n°1 :
Les concepts de Base
en langage C
Qu'est-ce qu'un langage ?

• Un compromis entre la machine (qui ne comprend que des 0 et des 1, en fait des
niveaux électriques) et l'utilisateur ou programmeur.

• Un moyen de donner des instructions (ordres) à la machine.

• Possède une syntaxe : une grammaire extrêmement pointilleuse : la machine
ne fait pas d’efforts.

• Possède un lexique : orthographe des mots de référence, là encore pas d’effort.

• Plus ou moins souple

• De niveau plus ou moins élevé.

• Plusieurs familles de langages.

Pourquoi le langage C ?

• Langage impératif, déclaratif :

• Très diffusé : ressources importantes.

• Utilisé depuis longtemps : fiable, documenté, normalisé

• Portable : nombreux compilateurs.
• Sert de base à : JAVA, C++, C#.

• Cohérent.
Historique du langage C :

• Inspiré par les langages : BCPL (Basic Combined Programming Language) 1967 ([Link])

• B (amélioration de BCPL) 1970 par [Link] 1970 le langage B était fruste et non
portable

• 1971 : problème de B avec le PDP-11

• 1972 : première version de C écrite en assembleur (B. Kernighan/D. Ritchie)

• 1973 : écriture d'un compilateur C portable (A. Snyder)

• 1975 : écriture de PCC (Portable C Compiler) 1987 : début de normalisation par l'IEEE

• 1989 : norme ANSI X3-159 (d'où le nom C ANSI)

• depuis : apparitions de langages basés sur le C, souple et puissant.

Présentation du langage C

• Langage de bas-niveau : accès à des données que manipulent les ordinateurs.

• Conçu pour écrire des programmes de système d'exploitation : 90% du noyau

UNIX est écrit en C.

• Compilateur C écrit en C !
• Suffisamment général pour des applications variées : scientifiques, accès aux bases
de données.

• Langage de haut-niveau : modules (fichiers séparés).

Le C : un langage compilé

• L'ordinateur (le micro-processeur) ne comprend que le langage machine,

constitué d'une suite de 0 et de 1.

• Traduction des ordres donnés dans d'autres langages (PASCAL, C, Basic,...)

ü Traduction au fur et à mesure : interprétation

ü Traduction de tout un programme : compilation

• Compilateur : traduit un langage de programmation en langage machine

 Principe de la compilation

Le programme en C est un fichier 'texte' (.c)

transformation en un fichier .exe (entête + code)

langage C modulaire : plusieurs fichiers .c ---> 1 fichier .exe

production de l'exécutable en 2 étapes :

• la compilation proprement dite

génération de fichiers .o 'intermédiaires'

• l'édition des liens

réunion de fichiers .o en un exécutable .exe

Les types

ü Un langage manipule des données :

ü Les valeurs manipulées en langage C sont physiquement des 0 et des 1, mais

elles sont regroupées : significations différentes

• nombres entiers

• nombres à virgule

• caractères

chaque valeur peut avoir un traitement différent : procédés de calcul, affichage, saisie.
Les types de base

Ø Le type char :
• Codé sur 1 octet,
• 255 valeurs différentes,
• Intervalle de -128 à +127 ou de 0 à 255,

• Utilisé pour les caractères ou pour les 'petits' nombres entiers.

Ø Le type int :
• Codage variable en taille, généralement 2 octets,
• 65536 valeurs différentes,
• Intervalle de -32768 à +32767, ou de 0 à +65535,
• Utilisé pour les nombres entiers.
Les types de base

Ø Le type float :
• Représentation de nombres en virgule flottante (dits nombres réels
mais limitations !)
• Codé sur 4 octets selon la norme IEEE-754.
• Intervalle de -1038 à -10-38 et de 10-38 à 1038

Ø Le type double :

• Extension du type float

• Codé sur 8 octets intervalle : de -10308 à -10-308 et de 10-308 à 10308

Les types de base

Les modificateurs : à mettre devant le type

signed types int et char : indique que les valeurs peuvent être positives ou
négatives : cas par défaut

unsigned types int et char : valeurs positives seulement

short type int : force le stockage sur 2 octets

long • type int : force le stockage sur 4 octets

• type double : stockage sur 10 octets (précision étendue)
Les types de base : résumé
Nom du type taille en octets intervalle

(signed) char 1 [-128;+127]

unsigned char 1 [0;255]

(signed) short int 2 [-32768;+32767]

unsigned short int 2 [0;65535]

(signed) int 2 ou 4, selon la machine

unsigned int 2 ou 4, selon la machine

(signed) long int 4

unsigned long int 4

Nom du type taille en octets intervalle

float 4 [-1038;+1038]
double 8 [-10308;+10308]
long double 10 [-104932;+104932]
Les types de base

Le type void : type particulier, signifiant 'rien'.

Utile pour écrire les premiers programmes.
vu en détail plus tard
Syntaxe et premier programme

L'ordinateur ne traduit pas des intentions, mais des ordres :

• domaine de l'utilisateur # domaine de l'ordinateur.
• capacités de l'utilisateur # capacités de l'ordinateur.

---> savoir comment lui donner des ordres pour qu'il soit efficace.

Solution language C :
compromis entre les utilisateur et ordinateur ---> qui nécessite une syntaxe très
stricte (pas d'ambiguïtés)
Syntaxe et premier programme

Le premier programme : présentation de la syntaxe

Directive permettant d'utiliser printf. Ne fait aucune action

en elle-même.

#include <stdio.h>
void main()
Ceci est une instruction, qui décrit ce
{ que le programme doit faire

printf("Bonjour\n");
Éléments indiquant le début et la fin du
programme. Ne font pas d'action.
}

Le rôle de ce programme est d'afficher le mot "Bonjour" à l'écran

Les commentaires

§ Lignes ignorées par le compilateur

§ utiles pour le programmeur pour noter ce qui est fait
§ 2 syntaxes :

1. C: encadrer le commentaire par /* (début) et */ (fin du commentaire)

2. C++ : faire débuter la ligne par //

La majorité des compilateurs comprend les 2 syntaxes/

Les variables

Toute valeur susceptible d'être modifiée (de varier) doit être stockée dans
une variable.

Pour manipuler une variable, on est obligé de préciser ce qu'elle est pour
que le langage puisse la traitercorrectement.

C'est le rôle d'une déclaration de variable :

présentation des éléments indispensables au compilateur :

• le nom de la variable

• le type de la variable
Les variables : déclaration

Le nom : c'est un identificateur à choisir. Moyen facile de repérer la variable.

Au niveau syntaxique :

• un nom de variable doit commencer par une lettre ou '_' (underscore)

• il y a 31 caractères significatifs

• différence minuscules/majuscules

• il peut contenir des chiffres, des lettres, et'_’

Exemples :

une_variable ---> correct

Toto ---> correct
x9 ---> correct
6o6on ---> incorrect : commence par un chiffre
une-variable ---> incorrect : contient le caractère ‘-’
ceciEstUnIdentificateurDeVariableA43Lettres ---> correct
Les variables : déclaration

Le type : permet au langage C de savoir comment coder les valeurs de la variable et comment les
traiter.
Au niveau syntaxique : on utilise les noms de types déjà vus :
char, int, float, double, void et les modificateurs adéquats.

La déclaration de variable se fait de la manière suivante :

type de la variable nom de la variable; !!! ne pas oublier le;

Exemples et significations :

Int unNombre; unNombre est une variable de type int

char x; x est une variable de type char
Float valeur_numero_4; valeur_numero_4 est une variable de type float
short int toto; toto est une variable de type short int
Les variables : déclaration

• Dans un programme, on ne peut utiliser que des

variables préalablement déclarées.(erreur sinon)

• Rôle et placement dans le programme : #include <stdio.h>

void main()
une déclaration de variable n'est pas une instruction,
{
elle n'effectue pas d'action visible ou sensible. déclarations de toutes les variables
instructions du programme
}
• Ce que fait le compilateur : il utilise dans la
mémoire une boîte pour stocker la valeur de la
variable, et repère son adresse (là où elle se situe).
Le nom est associé à cette adresse pour faciliter
l'écriture.
Les variables : déclaration
En pratique :

• On ne connaît pas toujours toutes les variables au début du programme : on peut les y
ajouter au fur et à mesure si on en a besoin.

• Problème de clarté : choisir des noms significatifs : facilite la relecture, ne change rien au
programme.

#include <stdio.h>
void main()
{
int valeur1;
float x_1;
float x_2;
}

Syntaxiquement correct (le compilateur accepte), ne fait rien.

Les variables : déclaration abrégées

• Écriture concise pour déclarer plusieurs variables de même type.

• Au lieu d'une variable: liste de variables séparées par des virgules, terminée par un point-
virgule.

Exemple :

Au lieu de:
int a;
int b; int c;

Écrire :
int a,b,c;
Opérations de base
Les affichages : utilisation de printf

• C'est une fonction (vu plus tard) qui permet de réaliser un affichage à l'écran.
• Capable d'afficher les valeurs des variables (pas leur nom !)
• syntaxe générale :

printf(texte_formaté, liste_de_variables…);

Qu'est-ce que le texte formaté ?

C'est un texte contenant des mots ou caractères à afficher : caractères normaux (lettres) et spéciaux (mise en page)

basé sur le codage ASCII : codes pour quelques caractères spéciaux

• \n : passage à la ligne
• \a : bip
• \t :tabulation horizontale
• \v : tabulation verticale
• un texte doit se trouver entre double guillemets " "
Opérations de base

Exemples : textes simples

printf("Bonjour"); affiche le texte Bonjourà l'écran

printf("\tSalut"); affiche une tabulation horizontale puis le texte Salut
printf("\a\a\nhello \n"); 'affiche' deux bips, un passage à la ligne, le texte hello, puis un autre passage à la ligne

Exemples : textes formatés, affichage de variables (pour afficher une variable : ne pas donner son nom dans le texte).
Exemple de programme pour afficher une variable

#include <stdio.h>
void main()
{
int uneValeur; /* declaration de valeur */
uneValeur = 5; /* affectation de la variable */
printf("uneValeur"); /* on veut afficher '5' */
}
Opérations de base

Le programme précédent affiche le texte uneValeur.

Utiliser un code de format dans la chaîne pour préciser que l'on veut afficher une valeur, le type de la
valeur est précisé.

Code type de la valeur à afficher

%d entier signé
%c caractère
%u entier non signé
%e nombre à virgule – exposant
%f nombre à virgule float
%lf nombre à virgule double
%g nombre à virgule : meilleure
%s chaîne de caractères
Opérations de base
La chaîne contient le texte et les formats, la liste des valeurs à afficher est précisée à la suite de la chaîne.

Exemple : reprise du programme précédent

uneValeur est un entier signé : format %d mis dans la chaîne

#include <stdio.h>
void main()
{
int uneValeur; /* declaration de valeur */
uneValeur = 5; /* affectation de la variable */
printf("%d",uneValeur); /* on veut afficher '5' */
}

printf("%d",uneValeur); se lit alors : - le format de la valeur à afficher est %d

ou
- affichage d'un entier signé dont la valeur est donnée par uneValeur.

On peut mélanger texte et formats : On peut afficher plusieurs valeurs avec un seul printf.
Opérations de base

Texte et plusieurs formats : exemple de programme

#include <stdio.h>
void main
{
char carac;
double valD;

carac='H';
valD = 3.14159;

printf("deux valeurs : %c et %lf\n",carac,valD);

}

résultat:
deux valeurs : H et 3.141590000
 Opérations de base

Saisie de valeurs : emploi de scanf

comme printf, scanf est une fonction qui permet de faire des saisies, en
utilisant aussi des formats pour interpréter ce qui est saisi.
Emploi légèrement différent : pas de texte, seulement une chaîne avec des
formats.

En fait, on n'utilise qu'un format par scanf

saisie d'une valeur Û un scanf

possibilité de saisir plusieurs valeurs dans un scanf : emploi pas évident,
source de confusion.
 Opérations de base

Saisie de valeurs : emploi de scanf

scanf s'emploie de la manière suivante :
scanf(chaine_de_format, adresse_de_la_variable);

différent de printf : variables, ici adresses.

Faire précéder la variable dont on veut saisir la valeur de l'opérateur

&.
Les codes pour les formats sont les mêmes que pour printf (%d, %u,
%f,…)
 Opérations de base
Exemples de saisies avec scanf : différents types
#include <stdio.h>

void main()
{
unsigned int value_1;
char unCaractere;
double nbVirgule;
int x;

/* 4 saisies séparées pour les 4 valeurs */

scanf("%u",&value1);
scanf("%c",&unCaractere);
scanf("%lf",&nbVirgule);
scanf("%d",&x);

printf("%u %c %lf %d\n", value_1, unCaractere,

nbVirgule, x);
}
 Opérations de base

• Effet de scanf : arrêt du programme en cours, attente d'une saisie :

entrer la valeur souhaitée et valider avec entrée.
• scanf n'affiche pas de message : le faire précéder d'un printf pour que
l'utilisateur sache ce qu'il doit faire (pas d'écran noir sans instructions,
recommandé, pas obligatoire)
• ne pas inclure de codes de mise en page dans le scanf, notamment pas
de \n !!!
• Nécessitera d'appuyer 2 fois sur entrée : une fois pour terminer le
format du scanf, une fois pour valider.
 Les expressions

ü Une expression est une valeur qui peut être calculée par l'ordinateur,
qui contient des termes et des opérateurs reliés par une syntaxe
précise.
ü Plus simplement : une suite de symboles qui est comprise par le
langage et qui donne un résultat.

ü Déjà connu : les expressions mathématiques qui donnent une valeur

• 1+2´4-(5/6) est une expression mathématique valide et
calculable, qui vaut : 49/6

• !21+ ´ ´2 n'est pas une expression, bien que constituée de

symboles tous connus : ne respecte pas une syntaxe
donnée.
 Les expressions

• En C : même principe : règles de syntaxe et de priorités pour calculer la

valeur d'une expression.
• De plus, une expression a un type : sa valeur calculée sera utilisée par le
langage, donc doit avoir un type.

• Termes possibles dans une expression :

ü les variables peuvent être utilisées (puisqu'elles ont un type et
une valeur)
ü des constantes numériques peuvent être
utilisées
ü Opérateurs : nous en verrons tout un
ensemble.
 Constantes numériques

• Constantes entières : nombre sans virgule, précédé ou non du signe -

exemples : 3 0 824 -12000

• Constantes caractère : les caractères sont des valeurs entières, on peut

leur attribuer une valeur comme pour les entiers ci-dessus, mais aussi
directement un caractère en l'encadrant de simples guillemets : la
valeur sera alors le code ASCII du caractère
exemples : 'a' 23 ‘H' ';'
 Constantes numériques

• Constantes à virgule : un nombre écrit sous la forme classique ou

scientifique (avec exposant) : partie entière. partie décimale E
exposant
Exemples : 3.14 0.0001 1.27E+32 65634.23476432E-5

• Pour un nombre à virgule n'ayant pas de partie décimale : noter

juste le .
Exemple : 1. -8. Le point indique que ce n'est
pas un entier.
 Opérateurs

Arité (cardinalité) des opérateurs : nombre de termes (ou opérandes)

Opérateurs mathématiques et priorités :

opérations classiques 2-aires :

addition : + soustraction : - multiplication : * division :/
* et / prioritaires sur + et -
modulo 2-aire : %

a%b donne le reste de la division entière de a par b.

ajout de parenthèses possible pour gérer les priorités : à employer sans
modération : ne change pas le programme, facile à lire!
 Opérateurs d’affectation

Opérateur =
cet opérateur a un rôle particulier.
À sa gauche, on doit trouver une variable obligatoirement (et pas
une expression complexe)
À sa droite, on trouve une expression.
Rôle : calcule l'expression à droite de l'opérateur = et donne cette
valeur à la variable à gauche de cet opérateur.
Peut sembler évident, mais attention !
 Opérateurs d’affectation
void main()
{
int a,b;
double d,e;

/* toujours la même chose : calcul de l'expression */

/* à droite, affectation à la variable de gauche */

a=4;
b=a+2;
a=b*5+a/2-17;

d= 6.02252E+23;
e=5.*d;

/* curiosité ? */
b = b-1;
e = e/1000.;
}
 Opérateurs d’affectation

Une affectation n'est pas une équation !

Lorsque l'on écrit b = b-1; (d'ailleurs l'équation n'aurait pas de
solutions !), on calcule la valeur de b-1, puis on range cette valeur
dans b.

retour sur les trois premières lignes du programme, pour exemple :

a=4; l'expression vaut 4 : a reçoit cette valeur

b=a+2; calcul de a (4) +2 : l'expression vaut 6, b reçoit 6
b=b-1; calcul de b (6) -1, l'expression vaut 5, b reçoit 5
 Opérateurs d’affectation

Une affectation est elle-même une expression ! Sa valeur est égale à la

valeur calculée et donnée à la variable de gauche.
Reprise des exemples précédents :
a=4; est une expression qui vaut 4
b=a+2; est une expression qui vaut 6
b=b-1; est une expression qui vaut 5

possibilité d'affectations multiples du type :

void main()
{
int a,b,c;

a=b=c=17;
}
 Opérateurs d’affectation

Expression calculée (ou évaluée) de droite à gauche :

a=b=c=17; 1
2
3

étape 1 : évaluation de 17, rangement dans la variable c;

étape 2 : c=17 est une expression qui vaut 17, rangée dans b par :
b=c=17;
étape 3 : b=c=17 est une expression qui vaut 17, rangée dans a par
a=b=c=17;
étape 4 : a=b=c=17 est une expression qui vaut 17, qui n'est pas
rangée.
 Opérateurs composés

Combinaison d'opérateurs mathématiques et d'affectation :

permet d'appliquer un opérateur mathématique à une variable puis d'affecter
le résultat de cette opération à lavariable.
Opérateurs :
addition et affectation : +=
soustraction et affectation : -=
multiplication et affectation :*=
division et affectation: /=

emploi par l'exemple :

x += 4; signifie x=x+4; e *= d+5.1; signifie e=e*(d+5.1);

y /= x; signifie y =y/x; et ainsi de suite
 Changer le type d’une expression
• Les expression peuvent contenir des termes qui sont de type différents : le
compilateur accepte ces expression (elles sont valides) mais effectue des
changements de type pour les valeurs.
• Perte de précision possible (le compilateur émet alors des warnings) cette
opération s'appelle cast ou transtypage.

Exemple :

int a,b;
double x;
a=5;
x=3.1415926;
b=a+x; /* l'expression est affectee a un int ! */

warning C4244: '=' : conversion from 'double ' to 'int ',

possible loss of data
 Changer le type d’une expression
Les expression peuvent contenir des termes qui sont de type
différents : le compilateur accepte ces expression (elles sont valides)
mais effectue des changements de type pour les valeurs.
Perte de précision possible (le compilateur émet alors des warnings)
cette opération s'appelle cast ou transtypage.
Exemple :
int a,b;
double x;
a=5;
x=3.1415926;
b=a+x; /* l'expression est affectee a un int ! */

warning C4244: '=' : conversion from 'double ' to 'int ',

possible loss of data
 Changer le type d’une expression
Une opération peut ne pas donner le résultat escompté :
exemple classique, lorsque l'on divise 2 entiers entre eux : division
entière même si le résultat est stocké dans un double !
Le transtypage est effectué au fur et à mesure de l'évaluation de
l'expression, pas en analysant l'expression !
Exemple :
int a=5;
int b=2;
double x=a/b;

printf("x=%lf\n",x) affichera 2.0000 !

a/b est une division entière, résultat 2, converti en double ensuite !

 Changer le type d’une expression

• Solution : effectuer soit même les transtypages pour être certain du type des valeurs !

• Pour transtyper une expression d'un type en un autre, il suffit de noter entre parenthèses le type
souhaité devant l'expression :

• (type_souhaité)expression.

• Soit i un entier : (double)i donne la même valeur mais en type double

• soit x un double : (int)x transtypera x en int, en supprimant les chiffres après la virgule
 Changer le type d’une expression
Exemple pour faire la division correctement : il faut transtyper a et b
individuellement en double !
Si l'on écrit : x=(double)(a/b); ne change rien
x=(double)a/(double)b; on aura le résultat souhaité