Langage de Programmation: I

- Le Langage C – Partie I

E SAAD
 Histoire du C
 Origines
C a trois ancêtres : les langages CPL, BCPL et B.

CPL : (pour Combined Programming Language) a été conçu au début des

années 1960 - universités de Cambridge et de Londres. Fortement typé
mais trop complexe  disparition dans las année 70

BCPL : (pour Basic CPL) Cambridge en 1966 par Martin Richards. Version
siplifiée  Ecriture d’un 1er Compilateur et de divers systèmes
d’exploitations

B : Ken Thompson vers 1970 dans les laboratoires Bell  Version simplifiée
du BCPL
 Histoire du C

C: développé par un collègue de Ken Thompson, Dennis Ritchie qui ajouta les
tableaux, les pointeurs, les nombres à virgule flottante, les structures... 1972
fut l'année de développement la plus productive et sans doute l'année de
baptême de C. En 1973, C fut suffisamment au point pour que 90% de
UNIX puisse être récrit avec.

- Une 1ère définition du langage est apparue en 1978 avec l’ouvrage de

Ritchie et Kernighan « The C programming language ».

- Son succès international a contribué à sa normalisation:

1- ANSI (American National Standard Institute
2- ISO (International Standadization Organisation
3- CEN (Comité Européen de Normalisation) en 1993
 1. Introduction au langage C

- Le langage C est un langage de bas niveaux, dans le sens où il permet la

manipulation de données que manipulent les ordinateurs (Bit, octet, adresse) ≠
Langages évolués (Pascal, Fortran, ADA)

- Il est suffisamment général pour permettre de développer des application de

type scientifique ou de gestion basée sur l’accès aux bases de données (Word
et Excel sont écrits à partir de C ou C++)

- Il est un des 1ers langages offrant des possibilités de programmation modulaire:

Un programme peut être constitué de plusieurs module (module = fichier .c)
 1. Introduction au langage C
Qu’est ce qu’un programme C?

C’est un texte écrit avec un éditeur de texte, respectant une certaine syntaxe et
stocké sous forme d'un ou plusieurs fichiers (généralement avec l'extension .c). A
l'opposé du langage assembleur, les instructions du langage C sont obligatoirement
encapsulées dans des fonctions et il existe une fonction privilégiée appelée main qui
est le point de départ de tout programme.

Exemple: main()
{
printf(’’Bonjour!’’);
}

Source.c
Compilation Objet.o Edition des liens Exécutable
 2. Éléments de base
2.1 les fichiers include

Exemple:
# include <stdio.h>
main()
{
printf(’’Bonjour!’’);
}

La directive #include inclu le fichier stdio.h au programme avant la compilation (pour

pouvoir utiliser la fonction prédéfinie printf.

On parle alors de préproceseur

 2. Éléments de base
2.2 les Commentaires

Exemple:
# include <stdio.h> //pour pouvoir utiliser la fonction printf
main()
{
printf(’’Bonjour!’’);
}
/*Ce programme imprime la chaine de
caractère ‘’Bonjour!’’ à l’écran*/
 2. Éléments de base
2.4 Les identificateurs

Les identificateurs servent à désigner les différents objets manipulés par le

programme:Variables, fonctions, …

- Commence nécessairement par une lettre

- une lettre majuscule est tenue pour différente de la lettre minuscule correspondante;
- Au plus 31 caractère
- Le caractère _ (appelé « blanc souligné ») est considéré comme une lettre ; il peut
donc figurer à n'importe quelle place dans un identificateur: _Total2, Prix_unit
 2. Éléments de base
2.5 Les Types dans C

Les types de base du langage C se répartissent en 3 grande catégories en fonction

de la nature des informations qu’ils permettent de représenter:

 Nombres entiers (int)

 Nombres flottants (float ou double)

 Caractère (char): apparaît en C comme un cas particulier de int.

Ils peuvent être signés ou non signés : signed ou unsigned (unsigned int x;)
 2. Éléments de base
a. Les Types Entiers

 short int ou short (entier sur 16 bits : - 32 768 à 32 767)

 int (entier sur 32 bits : - 2 147 483 648 à 2 147 483 647)

 long int ou long (entier sur 32 bits ou 64 bits, selon les machines)

Chacun des 3 peut être nuancé par l’utilisation du qualificatif unsigned pour ne

représenter que des nombres positifs:

Exemple: unsigned short x; x peut aller de 0 à 65 535

pas de bit réservé pour le signe

- C accepte les constantes entière en notation décimale, hexadécimale ou octale

 2. Éléments de base
b. Les Types Flottants

Float : codé sur 4 octets avec 1 bit de signe, 23 bits de mantisse et 8 bits
d'exposant
Double : codé sur 8 octets avec 1 bit de signe, 52 bits de mantisse et 11
bits d'exposant
Long : codé sur 10 octets avec 1 bit de signe, 64 bits de mantisse et 15 bits
d'exposant

- C accepte les constantes flottante en notation décimale ou scientifique

3.5e+3 3500 2.43 -0.38 -.38 4. .27

2. Éléments de base
c. Le Type Char

En C, un caractère est un entier signé codé sur 1 octet

Notation des constantes caractères : ‘a’ , ‘$’ ..

Important: ‘a’ ≠ ‘’a’’

Il existe des caractères non imprimables, tel que le changement de ligne, de

Tabulation, … en voici un tableau récapitulatif
2. Éléments de base

NOTATION RESULTAT 
\a cloche ou bip (alert ou audible bell)
\b Retour arrière (Backspace)
\f Saut de page (Form Feed)
\n Saut de Ligne (Line Feed)
\r Retour chariot (Carriage Return)
\t Tabulation horizontaLe (HorizontaL Tab)
\v Tabutation verticale (VerticaL Tab)
\\ \ 
\' ‘ 
\ '' ‘’ 
\? ? 
 2. Éléments de base
A propos du type booléen :

Pas de type booléen en C. Le type booléen est représenté par un entier. Il se comporte
comme la valeur booléenne vraie si cette valeur entière est non nulle.

Dans un contexte qui exige une valeur booléenne (comme les tests, par exemple), un
entier non nul équivaut à vrai et la valeur zero équivaut à faux
 2. Éléments de base
2.6 Les Mots réservés

Les mots suivants sont réservés. Leur fonction est prévue par la syntaxe de C et ils ne
peuvent pas être utilisés dans un autre but :

auto break case char const continue default do

double else enum extern float for goto if

int long register return short signed sizeof static

struct switch typedef union unsigned void volatile while

 3. Les Variables
3.1 Declaration

Type identificateur = expression

Exemple: int x, y=0, z;

 4. Opérateurs et Expressions
C dispose d'un important éventail d'opérateurs originaux d'affectation et
d'incrémentation.

4.1 Opérateurs arithmétiques en C

 Comme tous les langages, C dispose d'opérateurs classiques "binaires" , à

savoir l'addition (+), la soustraction (-), la multiplication (*) et la division (/), ainsi
que d'un opérateur "unaire" correspondant à l'opposé noté - (comme dans -n ou
-x+y).

 Les opérateurs binaires ne sont à priori définis que pour deux opérandes ayant
le même type parmi: int, long int, float, double, long double et ils fournissent
un résultat de même type que leurs opérandes.
 4. Opérateurs et Expressions
4.1 Opérateurs arithmétiques en C

 De plus, il existe un opérateur de "modulo" noté % qui ne peut porter que sur des
entiers et qui fournit le reste de la division de son premier opérande par son
second. Par exemple, 11%4 vaut 3, 23%6 vaut 5

 Remarque: le quotient de deux entiers fournit un entier. Ainsi 5/2 vaut 2; en

revanche, le quotient de deux flottants (noté, lui aussi, /) est bien un flottant
(5.0/2.0 vaut bien approximativement 2.5).

Priorité des opérateurs :

les règles sont "naturelles" et rejoignent celles de l'algèbre traditionnelle
 4. Opérateurs et Expressions

Conversions implicites :

 On peut écrire des expressions mixtes dans lesquelles interviennent des opérandes
de types différents:
Int n,p; float x; n*x + p
(int * float) + int
Conversion implicite: int  float ( float*float) + int
float + int
Même mécanisme : float + float  float

On parle de conversion d’ajustement de type: intlongfloatdoublelong double

 4. Opérateurs et Expressions

Promotions numériques :

 On a vu que les opérateurs numériques ne sont pas définis pour le types char et
short :

C prévoit que toute valeur char ou short soit d’abord convertie en int.
short n,p; float x; n*x + p
(short * float) + short
Conversion systématique: ( int * float) + int
Conversion implicite : float * float + int
float + float  float
 4. Opérateurs et Expressions
4.2 Opérateurs Relationnels

Comme tout langage, C permet de "comparer" des expressions à l'aide

d'opérateurs classiques de comparaison. exemple : 2*a > b +5

Par contre, C se distingue de la plupart des autres langages sur deux points:

1-le résultat de la comparaison est, non pas une valeur "booléenne" (on dit aussi
"logique") prenant l'une des deux valeurs vrai ou faux, mais un entier valant:
 0 si le résultat de la comparaison est faux,
 1 si le résultat de la comparaison est vrai.
Ainsi, la comparaison ci-dessus devient en fait une expression de type entier. Cela
signifie qu'elle pourra éventuellement intervenir dans des calculs arithmétiques;
 4. Opérateurs et Expressions
4.2 Opérateurs Relationnels

2-les expressions comparées pourront être de type quelconque et seront soumises au

règles de conversion présentées précédemment.

Liste des opérateurs: < <= > >= == !=

même priorité > même priorité

Exemple: a < b == c < d  (a < b) == (c < d)

Remarque: les opérateurs relationnels sont moins prioritaires que les opérateurs
arithmétiques ( x+y < a+2  (x+y) < (a+2) )
 4. Opérateurs et Expressions
4.3 Opérateurs Logiques

 C dispose de trois opérateurs logiques classiques: et (noté &&), ou (noté | |) et

non (noté ! ). Par exemple: (a<b) && (c<d) prend la valeur 1 (vrai) si les deux
expressions a<b et c<d sont toutes deux vraies ( de valeur 1), la valeur 0 (faux)
dans le cas contraire.

 Ces opérateurs acceptent n'importe quel opérande numérique, y compris les

types flottants, avec les règles de conversion implicite déjà rencontrées. à
condition de considérer que:
 0 correspond à faux,
 toute valeur non nulle correspond à vrai
 4. Opérateurs et Expressions
4.3 Opérateurs Logiques

Exemples:
n et p sont des entiers, le compilateur accepte des expression telles que:
n && p n||p if ( !n )  if (n == 0)

Remarque1: l’opérateur ! a une priorité supérieur à celle de tous lés opérateurs

arithmétiques et relationnels. La négation de a==b serait !(a==b) et non
!a==b
Ne sera évaluée que si a<b
est vrai

Remarque2: l’opérateur | | est moins prioritaire que &&. Tous deux sont de priorité
inférieure aux opérateurs arithmétique et relationnels
a<b && c<d équivaut à (a<b) && (c<d)
 4. Opérateurs et Expressions

4.4 Opérateur d’affectation ordinaire

 Nous avons déjà eu l'occasion de remarquer que : i = 5 était une expression qui
réalisait une action : l'affectation de la valeur 5 à i. Cet opérateur d'affectation (=)
peut faire intervenir d'autres expressions comme dans : c=b + 3

 Cet opérateur possède une associativité de droite à gauche : i = j = 5

 4. Opérateurs et Expressions
4.5 Opérateurs d’incrémentation et de décrémentation ( ++ -- )

 ++ i : expression qui incrémente de 1 la valeur de i, et sa valeur est celle de i

après incrémentation

 si la valeur de i est 5, l'expression : n = ++i - 5 affectera à i la valeur 6 et à n la

valeur 1.
 n = i++ - 5 (n==0 , i++ vaut 5, i vaut 6)

 On dit que ++ est:

-un opérateur de pré incrémentation lorsqu'il est placé à gauche
-un opérateur de post incrémentation lorsqu'il est placé à droite
 4. Opérateurs et Expressions
4.5 Opérateurs d’incrémentation et de décrémentation ( ++ -- )

Priorité:

3 * i++ * j-- + k++ équivaut à 3 * (i++) * (j--) + (k++)

La priorité élevée de ces opérateurs unaires permet d’écrire des expression

assez compliquées sans qu’il soit nécessaire d’employer des ( )

4.6 Opérateurs d’affectation élargie:

i=i+k  i+=k a=a*b  a*=b i=i-k  i-=k a=a/b  a/=b
 4. Opérateurs et Expressions
4.7 L’opérateur de CAST :

Exemple: n=10, p=3;

(double) (n/p) aura comme valeur 3
(double) n/p aura comme valeur 3.33333…

4.8 L’opérateur conditionnel : (seul opérateur ternaire en C)

syntaxe : condition ? Valeur si vrai : valeur si faux
z = (x=y) ? a : b ; on utilise la valeur de l’expression
a>b ? i++ : i-- ; la valeur de l’expression n’est pas utilisée
4. Opérateurs et Expressions

EXERCICES
 5. Les Entées-Sorties Conversationnelles

 Quelles sont les écritures autorisés pour des nombres fournis en données? Que se

passe-t-il lorsque l’utilisateur ne les respecte pas?

 Comment organiser les données lorsque l’on mélange les types numériques et les

types caractères?

 Que se passe-t-il lorsque, en réponse à scanf, on fournit trop ou peu

d’informations?

 Comment agir sur la présentation des informations à l’écran?

 5.1 Les possibilités de la fonction printf

La fonction printf a comme 1er argument une chaîne de caractères qui spécifie:

 Des caractères à afficher tels quels;

 Des code de format repérés par %. Un code de conversion (c, d, f..) précise
le type de l’information à afficher.

Un code de format peut contenir des informations complémentaires agissant sur le

cadrage, le gabarit ou la précision.

Exemple: printf("leur somme est : %d",n1+n2);

 5.1 Les possibilités de la fonction printf

a. Les principaux codes de conversion:

 c : char: caractère affiché ''en clair" (convient aussi à short ou à int compte tenu

des conversions systématiques)

 d : int (convient aussi à char, compte tenu des conversions systématiques)

 u : unsigned int (convient aussi à unsigned char ou à unsigned short, compte tenu

des conversions systématiques)

 ld : long

 lu : unsigned long
 5.1 Les possibilités de la fonction printf

a. Les principaux codes de conversion:

 f : double ou float écrit en notation "décimale" avec six chiffres après le point

 e : double ou float écrit en notation ‘'exponentielle'' (mantisse entre 1 et 9) avec six

chiffres après le point décimal, sous la forme x.xxxxxxe+yyy ou x.xxxxxxe-yyy pour
les nombres positifs et -x.xxxxxxe+yyy ou -x.xxxxxxe-yyy pour les nombres
négatifs

 s : chaîne de caractères dont on fournit l'adresse (notion qui sera étudiée

ultérieurement)
 5.1 Les possibilités de la fonction printf

b. Action sur le gabarit d’affichage:

Les entiers sont affichés par défaut sans espaces avant ou après. Les flottants avec six
chiffres après le point.
Pour agir sur l’affichage  un nombre est placé après % et précise le nombre de
caractère minimum à utiliser.

Exemples: printf("%3d" , n );
n = 20 ^20
n=3 ^^3
n = 2358 2358
n = -5200 -5200
 5.1 Les possibilités de la fonction printf

b. Action sur le gabarit d’affichage:

Exemples: printf("%f" , x );
x = 1.2345 1.234500
x = 12.3456789 12.345678

printf("%10f" , x );
x = 1.2345 ^^1.234500
x = 1.2345E5 123450.000000
printf("%e" , x );
x = 1.2345 1.234500e+000
x = 123.45 1.234500e+002
 5.1 Les possibilités de la fonction printf

c. Actions sur la précision :

pour les flottants, on peut préciser un nombre de chiffres après le point décimal

Exemples: printf("%10.3f" , x );
x = 1.2345 ^^^^^1.235
x = 1.2345E3 ^^1234.500
x = 1.2345E7 12345000.000
Remarques:
Cadrage de l’affichage à gauche  printf("%-10.3f" , x ); x = 1.2345  1.235^^^^^
- Le caractère * figurants à la place d’un gabarit ou une précision signifie que la valeur
effective est fournie dans la liste des arguments de printf:
printf("%8.*f" , n, x ); n=1; x=1.2345  ^^^^^1.2
- La fonction printf fournit une valeur de retour (nombre de caractère affichés)
 5.1 Les possibilités de la fonction printf

d. Les erreurs de programmation :

Erreur 1 : Code de format en désaccord avec le type de l’expression à afficher:

Conséquence : mauvaise interprétation si même taille (int en %u), sinon, conséquences
plus désastreuses.

Erreur 2: Nombre de code de format différents du nombre d’expressions de la liste

Conséquence 1 : si des expressions de la liste n’ont pas de format, elles ne seront pas
affichées ( printf("%d" , n, p ); // valeur de p ne sera pas affiché )
Conséquence 2 : s’il y a trop de code de format, printf cherchera à afficher n’importe
quoi ( printf("%d %d" , n ); n=8  8 2 )
 5.1 Les possibilités de la fonction scanf

a. Les principaux codes de conversion :

 c : char

 d : int

 u : unsigned int

 hd : short int

 hu : unsigned short

 ld : long

 lu : unsigned long
 5.1 Les possibilités de la fonction scanf

a. Les principaux codes de conversion :

 f ou e : float écrit en notation "décimale" ou ‘'exponentielle''

 Lf ou le : double écrit en notation "décimale" ou ‘'exponentielle''

 s : chaîne de caractères dont on fournit l'adresse (notion qui sera étudiée

ultérieurement)

b. Premières notion de tampon et de séparateurs :

Lorsque scanf attend des données, l’information frappée au clavier est rangée

temporairement dans l’emplacement mémoire nommé « tampon ». Ce dernier est

exploré caractère par caractère au fur et à mesure des besoins. Certains caractères

jouent un rôle particulier: les séparateurs (l’espace et la fin de ligne \n)

 5.1 Les possibilités de la fonction scanf

c. Les premières règles utilisées par scanf :

 Les codes de format correspondant à un nombre entraînent l’avancement du

pointeur jusqu’au 1er caractère différent d’un séparateur, puis scanf prend en
compte tous les caractères suivants jusqu’à la rencontre d’un séparateur.

 Quand au code de format %c, il entraîne la prise en compte du caractère désigné

par le pointeur (même un séparateur) et il est avancé sur le caractère suivant.
 5.1 Les possibilités de la fonction scanf

c. Les premières règles utilisées par scanf :

Exemples : (n et p sont de type int, c char, @ désigne une fin de ligne)

scanf("%d%d" , &n, &p );
12^25@ n = 12 p=25
^12^^25^^@ n = 12 p=25

123@
@
^25 n = 12 p=25
scanf("%d%c" , &n, &c );
12^a@ n = 12 c=‘ ‘
 5.1 Les possibilités de la fonction scanf

d. On peut imposer un gabarit maximal :

Le traitement d’un code de format s’interrompe soit à la rencontre d’un séparateur, soit
lorsque le nombre de caractère indiqué a été atteint !!

Exemples : (n et p sont de type int, @ désigne une fin de ligne)

scanf("%3d%3d" , &n, &p );

12^25@ n = 12 p=25
^^^^^12345@ n = 123 p=45

12@
25@ n = 12 p=25
 5.1 Les possibilités de la fonction scanf

e. Rôle d’un espace dans le format :

Un espace entre deux codes de format demande à scanf de faire avancer le pointeur au
prochain caractère différent d’un séparateur !!

Exemples : (n et p sont de type int, c char, @ désigne une fin de ligne)

scanf("%d %c" , &n, &c );

12^a@ n = 12 c=‘a‘
12^^^@
a@ n = 12 c=‘a‘
 5.1 Les possibilités de la fonction scanf

f. Arrêt prématuré de scanf :

Compte = scanf("%d %d %c" , &n, &p, &c );

12^25^b@ n = 12 p = 25 c=‘b‘ compte = 3
12b@ n = 12 p inchangé c inchangé compte = 1
b@ n indéfini p inchangé c inchangé compte = 0

Un arrêt prématuré de scanf a lieu dans le cas où scanf n’est pas en mesur de fabriquer
une valeur adéquate !!
 5.1 Les possibilités de la fonction scanf

f. Problème de synchronisation entre l’écran et le clavier :

Examinons cet exemple:

#include <stdio.h>
main()
{ int n, p;
printf("donner une valeur pour n : ");
scanf("%d",&n);
printf("Merci pour %d\n",n);
printf("donner une valeur pour p : ");
scanf("%d",&p);
printf("Merci pour %d\n",p);
} exécution
 5.1 Les possibilités de la fonction scanf

f. Problème de synchronisation entre l’écran et le clavier :

Le tampon n’est pas vide à chaque nouvel appel de scanf
g. Erreurs de programation :

1- Code de format en désaccord avec le type de l’expression:

Si même taille  introduction d’une mauvaise valeur
Si la variable a une taille inférieur  écrasement d’un emplacement mémoire
consécutif à cette variable

2- Nombre de codes de format différent du nombre d’éléments de la liste:

Scanf("%d",&n, &p);  seule la valeur de n est lue
Scanf("%d%d",&n);  on affecte une valeur à un emplacement aléatoire de la
mémoire
 Structures conditionnelles

La syntaxe est la suivante :

if (condition réalisée )
{ liste d'instructions }
else
{ autre série d'instructions }

Remarques :
la condition doit être entre des parenthèses
il est possible de définir plusieurs conditions à remplir avec les
opérateurs ET et OU (&& et ||)
Par exemple l'instruction suivante teste si les deux conditions sont
vraies : if ((condition1)&&(condition2))L'instruction suivante exécutera
les instructions si l'une ou l'autre des deux conditions est vraie : if
((condition1)||(condition2))
 Les boucles

La syntaxe est la suivante :

for (compteur; condition; modification du compteur)

{ liste d'instructions; }

Par exemple :

for (i=1; i<6; i++)

{
printf("%d", i);
}
 L'instruction while

L'instruction while représente un autre moyen d'exécuter plusieurs fois

la même série d'instructions.

La syntaxe de cette expression est la suivante :

while (condition réalisée)

{
liste d'instructions;
}
Cette instruction exécute la liste d'instructions tant que
(while est un mot anglais qui signifie tant que) la condition est réalisée.
Exemples d’applications
#include <stdio.h>
int main()
{
/* declarez le type des variables a et b */
int a;
int b;
int somme;
printf("entrer la val de a :");
/* entrer la valeur de a */
scanf("%d",&a);
printf("entrer la val de b :");
/*entrer la valeur de b*/
scanf("%d",&b);
somme=a+b;
printf("la somme est: %d",somme);
}
EX 1
#include <stdio.h>
int main()
{
printf("la taille de int est: %d\n", sizeof(int));
printf("la taille de float est: %d\n", sizeof(float));
printf("la taille de char est %d\n", sizeof(char));
printf("la taille de double est: %d\n",
sizeof(double));
}
EX 5
#include <stdio.h>
int main()
{
int X1;
int X2;
int X3;
printf("la valeur de X1 est: ");
scanf("%d",&X1);
printf("la valeur de X2 est : ");
scanf("%d", &X2);
X3=X1;
X1=X2;
X2=X3;
printf("la valeur de X1 est: %d\n",X1);
printf("la valeur de X2 est: %d",X2);
EX 7
#include <stdio.h>
int main()
{
int n;
int s;
printf("n=");
scanf("%d",&n);
s=n*(n+1)/2;
printf("la somme est : %d",s);
}
EX 2 (sans correction)
 #include <stdio.h>
 int main()
 {
 float c;
 float d=12;
 float p=3.14;
 c=d*p;
 printf("le c est : %f*%f=%f",d,p,c);
 }
EX 3 (not complet)
#include <stdio.h>
int main()
{
int a;
int b;
a=-21430;
b=4782;
printf("la somme est: %d\n", a+b);
printf("la soustraction est: %d\n", a-b);
printf("le produit est: %d\n" ,a*b);
printf("la division est : %d\n", a/b);
printf("la xx est : %d\n", a%b);
}
EX 4 (not correctin)
#include <stdio.h>
int main()
{
float f;
float m;
float a;
float mm;
f=12,75;
m=16;
a=15,5;
mm=((f*3)+(m*7)+(a*1))/11;
printf("la moyenne générale est: %f\n", mm);
}
EX 6
#include <stdio.h>
int main()
{
int a;
int b;
int c;
int x;
int s;
printf("la valeur de a est: ");
scanf("%d" ,&a);
printf("la valeur de b est: ");
scanf("%d" ,&b);
printf("la valeur de c est: ");
scanf("%d", &c);
printf("la valeur de x est: ");
scanf("%d", &x);
s=(a*x*x)+(b*x)+c;
printf("la valeur du polynome est: %d",s);
EX 2 ?????????
#include <stdio.h>
int main()
{
float c;
float d;
float p;
p=3,14;
printf("d=");
scanf("%f",&d);
c=d*p;
printf("la circonférence est:%f",c);
}
EX 4 neww
#include <stdio.h>
int main()
{
float f;
float m;
float a;
float mm;
printf("f=");
scanf("%f",&f);
printf("m=");
scanf("%f",&m);
printf("a=");
scanf("%f",&a);
mm=((f*3)+(m*7)+(a*1))/11;
printf("la moyenne générale est: %f\n", mm);
}
EX
#include <stdio.h>
int main()
{
int a;
printf("a=");
scanf("%d",&a);
printf("%d\n",a);
printf("%2d\n",a);
printf("%3d\n",a);
printf("%4d\n",a);
printf("%5d\n",a);
}
#include <stdio.h>
int main()
{
int a;
printf("entrer a: ");
scanf("%d",&a);
if(a>0)
{
printf("le nombre est posotif");
}
if(a==0)
{
printf("le nombre est nul");
}
if(a<0)
{printf("le nombre est negatif");
}
}
#include <stdio.h>

int main()
{
int a;
int b;
printf("a=");
scanf("%d",&a);
printf("b=");
scanf("%d",&b);
if(a>b)
{
printf("a est max");
}
if(a<b)
{
printf("b est max");
}
if(a==b)
{
printf("a est egal a b");
}
}
#include <stdio.h>
int main()
{
float a;
float b;
float x;
printf("a=");
scanf("%f",&a);
printf("b=");
scanf("%f",&b);
if(a==0 && b==0)
{
printf("la solution est R");
}
if(a==0 && b!=0)
{
printf("la solution esr l'ensemble vide");
}
if(a!=0)
{
printf("la solution est: %f",-(b/a));
}
}
#include <stdio.h>
#include <math.h>
int main()
{
float a;
printf("a=");
scanf("%f",&a);
float racine;
racine = sqrt(a);
printf("la racine de a est :%f",racine);
}
 equation deuxièm degré
#include <stdio.h>
#include <math.h>
int main()
{
float a;
float b;
float c;
float p;
float delta;
float x;
float x1;
float x2;
float x3;
float racine;
printf("a=");
scanf("%f",&a);
printf("b=");
scanf("%f",&b);
printf("c=");
scanf("%f",&c);
delta =(b*b)-(4*a*c);
printf("delta est egal a: %f\n",delta); voir la suite (dispositiv 17)
La suite d l equation 2èm degré (dispositive 16)
racine=sqrt(delta);
x1=((-b) + racine)/(2*a);
x2=((-b) - racine)/(2*a);
x3=(-b)/(2*a);
if(delta>0)
{
printf("l'équation admet deux solution:\n");
printf("x1=%f\n",x1);
printf("x2=%f",x2);
}
if(delta<0)
{
printf("l'equation admet aucune solution dans R:\n");
}
if(delta==0)
{
printf("l'equation admet une seule solution :\n");
printf("x3= %f",x3);
}
}