!

"#$

Anne Universitaire : 2009 2010

!
"#

$ % %&%' ( )%
'
% " ********************************************************************************************************************
*
' +,)-" ,'****************************************************************************************************************************************
*
% .%( .%+&%
'
/%) ,'0
& (% - ., ' 0 /%1%"- ,' )/-'
.+, + &&%********************************************************************************************************************************************************
*
%( )
%+%' ( 2.%( )% 3 + 4 %(******************************************************************************************5
5*
%( '
(
,'( ****************************************************************************************************************************6
7*
(,+ %( )% ',&4+%( ,- )% %1 %
/%"+ ' ************************************************************************
6*
%( ,.%+ %-+(************************************************************************************************************************************8
*
%( ",'3%+( ,'( )% 2.%(************************************************************************************************************ 9
"#
$ ( ( % )% ',&4+%( % )% " + " %+%( - " 3 %+ ************************************************************
*
,'" ,' % ": **************************************************************************************************************************
*
,'" ,' (" ' ***************************************************************************************************************************
*
,'" ,' % ": + ********************************************************************************************************************
"#
$ %( ( +-" -+%( ",') ,''% %( %
%( 4,-" %( ********************************************************* 5
*
/ '( +-" ,' ( ***
,+( *** ( ',' ******************************************************************************************** 5
*
%( ,.%+ %-+( , ;-%(************************************************************************************************************ 7
*
/ '( +-" ,' - " ( ,- ***
+% ********************************************************************************************* 6
5*
4,-" %
' ;-% ***
+% *** ***************************************************************************************************
7*
/ '( +-" ,' .,-+ *** ********************************************************************************************************************* <
6*
/ '( +-" ,' +%.% %+ ***
' ;-% **************************************************************************************** 8
"#
5 $ %(
4 % -1 %
%( ": '%( )% " + " %+%(*********************************************************************
*
%(
4 % -1 )% ',&4+%( = '
, >*****************************************************************************
*
'
(
,' )%(
4 % -1 *****************************************************************************************************
*
%( ": '%( )% " + " %+%( ********************************************************************************************************
5*
,'" ,'( (-+ %( ": '%( )% " + " %+%(***********************************************************************
"#
7 $ %( ,'" ,'(**************************************************************************************************************************************** 5
*
' +,)-" ,'************************************************************************************************************************************** 5
*
)%" +
,'**************************************************************************************************************************************** 5
*
,'" ,'( ( '( . (( % )/ + -&%' ( % '% +%'3,2 ' + %' .+, + &&%****************************************************************************************************************************************************** 7
5*
,'" ,' +%'3,2 ' -'% 3 %-+ - .+, + &&% % ( '( . (( %
)/ + -&%' ( *************************************************************************************************************************************************** <
7*
,'" ,'( 3%" . (( % )/ + -&%' (******************************************************************************** <
6*
+%(-&% (-+ 3 + 4 %( %
,'" ,'(************************************************************************************* 8
*
% . (( % )% . + &% +%( %' +% ,'" ,'( ,- %' +% ,'" ,'( %
.+, + &&% .+ '" . ******************************************************************************************************************************* 8
. ? *********************************************************************************************************************************************************************************
"
. ? ********************************************************************************************************************************************************
. ? ********************************************************************************************************************************************************************************* 5
"
. ? ********************************************************************************************************************************************************
. ? *********************************************************************************************************************************************************************************5
"
. ? ********************************************************************************************************************************************************55
. ?5 *********************************************************************************************************************************************************************************79
",++%" ,' )- . '?5**********************************************************************************************************************************************75
. ?7 *********************************************************************************************************************************************************************************6
"
. ?7 ********************************************************************************************************************************************************6
%
=@ A
998> ***********************************************************************************************************************66
"
B
**************************************************************************************************************************6
%
C =@
998>*************************************************************************************************************************** 9
"
B
C ******************************************************************************************************************************
4! D
# **********************************************************************************************************************************************************************

"#
% %&%' ( )%

,!E

'

%"

* ' +,)-" ,'

Le langage C est un langage volu et structur, assez proche du langage machine destin des
applications de contrle de processus (gestion d'entres/sorties, applications temps rel ...).
Le langage C possde assez peu d'instructions, il fait par contre appel des bibliothques, fournies en
plus ou moins grand nombre avec le compilateur.
exemples:

math.h : bibliothque de fonctions mathmatiques

stdio.h : bibliothque d'entres/sorties standard

,
!!

A
*

"

"FF

! "FF

D
* % .%( .%+&%
.+, + &&%

*
'

/%)

,'0

& (% - ., ' 0 /%1%"-

,' )/-'

"#
, l'aide d'un diteur (traitement de textes). Le nom du fichier
contient l'extension .CPP, exemple: EXI_1.CPP (menu edit ).
$#
0 c'est dire cration des codes machine destins au
microprocesseur utilis. Le compilateur indique les erreurs de syntaxe mais ignore les fonctions
bibliothque appeles par le programme.
Le compilateur gnre un fichier binaire, non listable, appel fichier objet: EXI_1.OBJ (commande
compile ).
%#
: Le code machine des fonctions bibliothque est charg, cration d'un fichier
binaire, non listable, appel fichier executable: EXI_1.EXE (commande build all ).
&#

(commande flche jaune ).

Les compilateurs permettent en gnral de construire des programmes composs de plusieurs fichiers
sources, d'ajouter un programme des units dj compiles ...

%
G
G
A
L

H
H
=>

*#I
*#I

=M4,'@,-+M>N
=M.
#=>N J
/

D
O

J!!

/
# ***M>N
A

K! !

Le langage C distingue les minuscules, des majuscules. Les mots rservs du langage C doivent tre
crits
*
On a introduit dans ce programme la notion dinterface homme/machine (IHM).
Lutilisateur visualise une information sur lcran,
Lutilisateur, par une action sur le clavier, fournit une information au programme.
%
G
G
A
L

H
H
=>

*#I
*#I

J!!

0 !0
N J
A
! J
=M4,'@,-+M>N
J
/
P 9N J
J
! P 79 N J
J
P = F !>J N J
J
=M3
$ Q R M0
>N
=M.
# ***M>N
D #=>N J
/
A J
O
+

K! !

Dans ce programme, on introduit 3 nouveaux concepts :

La notion de dclaration de variables : les variables sont les donnes que manipulera le
programme lors de son excution. Ces variables sont ranges dans la mmoire vive de
lordinateur. Elles doivent tre dclares au dbut du programme.
La notion daffectation, symbolise par le signe =.
La notion dopration.

%( )

%+%' ( 2.%( )% 3 +

4 %(

>
Le langage C distingue plusieurs types d'entiers:
___________________________________________________________
2.%
)%("+ . ,'
% &%&, +%
___________________________________________________________
int
unsigned int

entier standard sign

entier positif

4 octets: 231 n 231 1

4 octets: 0 n 232

short
unsigned short

entier court sign

entier court non sign

2 octets: 215 n 215 1

2 octets: 0 n 216

char
caractre sign
1 octet : 27 n 27 1
unsigned char
caractre non sign
1 octet : 0 n 28
_____________________________________________________________
Numration: En dcimal les nombres s'crivent tels que, prcds de 0x en hexadcimal.
exemple: 127 en dcimal s'crit 0x7f en hexadcimal.
Remarque: En langage C, le type # est un cas particulier du type entier:

Exemples:
Les caractres alphanumriques s'crivent entre
Le
Le
Le
Le

'b' a pour valeur 98 (son code ASCII).

22 a pour valeur 22.
127 a pour valeur 127.
257 a pour valeur 1 (ce nombre s'crit sur 9 bits, le bit de poids fort est perdu).

Quelques constantes caractres:

________________________________________________________________
CARACTERE
VALEUR (code ASCII)
NOM ASCII
________________________________________________________________
'\n'
interligne
0x0a
LF
'\t'
tabulation horizontale
0x09
HT
'\v'
tabulation verticale
0x0b
VT
'\r'
retour charriot
0x0d
CR
'\f'
saut de page
0x0c
FF
'\\'
backslash
0x5c
\
'\''
cote
0x2c
'
'\"'
guillemets
0x22
"
_______________________________________________________________

%
G
G
A
L

H
H
=>

*#I
*#I

J!!

0 !0
N J
A
! J
#
0 AN
=M4,'@,-+M>N
J
/
P 9N J
J
! P 79 N J
J
P 67 N
APS BN
P = F !>J N J
J
=T 3
$ Q R U0
>N
=T
# D
$ Q R U0 > N
=T
# D
A $ Q R U0 > N
=T
# D
$ Q R U0A> N
=T
# D
A$ Q R U0A> N
=M.
# ***M>N
D #=>N J
/
A J

K! !

O
+

Un rel est compos d'un signe

d'une mantisse
d'un exposant
Un nombre de bits est rserv en mmoire pour chaque lment.
Le langage C distingue 2 types de rels:
_________________________________________________________
2.%
)%("+ . ,'
% &%&, +%
_________________________________________________________
float
rel standard
4 octets
double
rel double prcision
8 octets
__________________________________________________________
5* %( '
(
,'(
Le langage C permet l'initialisation des variables dans la zne des dclarations:
char c;
est quivalent
char c = 'A';
c = 'A';
int i;
est quivalent
int i = 50;
i = 50;
Cette rgle s'applique tous les nombres, char, int, float ...
6

7* (,+

%( )% ',&4+%( ,- )% %1 %

>

,'"

/%"+ '

,' .+ '

Ce n'est pas une instruction du langage C, mais une fonction de la bibliothque stdio.h.
'!

! (

printf("BONJOUR");
printf("BONJOUR\n");
%

G
G
A
L

H
H
=>

/* pas de retour la ligne du curseur aprs l'affichage, */

/* affichage du texte, puis retour la ligne du curseur. */

*#I
*#I

=M4,'@,-+ M>N
=M
4% -R M>N J
A
=M4,'@,-+MN J
=M4,''%( 3 " '"%(M>N
=M.
# ***M>N
#=>N J
/
A J

D
O
+

(
!

7 Affichage d'une variable de type # $

G
G
A
L

H
H
=>

*#I
*#I

#
N
P66N
=MQ R M0 >N

J
J
J
J
J
J
J
J
J

=MQ R M0 >N
=MQ R M0 >N
=MQ R M0 >N

D
O

=M.
#=>N J

#
# D
("
V
D J
# D
("
V
D J
# D
("
V
D J
# D
J
D J
# ***M>N
A J

J
J
!
#

# D

$
"

%
G
G
A
L

6
H
H
=>

#
N
P/ /N
=M
=M.
D #=>N J

# $$$$

"

# $$$$$$$

*#I
*#I

J
PQ
/

("

#
P Q R M0 0 >N
# ***M>N
A J

O
+

*
%d
%x
%u

(
affichage en dcimal (entiers de type int),
affichage en hexadcimal (entiers de type int),
affichage en dcimal (entiers de type unsigned int),

%
/
?
Soit a et b sont des entiers, a = 21430
b = 4782, calculer et afficher a+b, a b, a*b, a/b, a%b en
format dcimal, et en soignant linterface homme/machine.
a/b donne le quotient de la division, a%b donne le reste de la division.
(
G
G
A
L

H
H
=>

*#I
*#I

0!N
P K 5 9N
!P 5 < N
=M F 4 P Q R M0 F!>N
=M K 4 P Q R M0 K!>N
=M
4 P Q R M0 J!>N
=M
4 P Q R M0 !>N
=M
4 P Q R M0 Q!>N
=M.
D #=>N J
/
A

# ***M>N
J

O
<

%
/
?
Soit a et b sont des rels,
a = 21,43
b = 4,782, calculer et afficher a+b, a b, a*b, a/b, en
soignant linterface homme/machine.
'4 $ Pour le format de sortie pour les rels c'est : %f
(
G
G
A
L

H
H
=>

*#I
*#I

0!N
P K *5 N
!P 5* < N
=M F 4 P Q R M0 F!>N
=M K 4 P Q R M0 K!>N
=M
4 P Q R M0 J!>N
=M
4 P Q R M0 !>N
=M.
D #=>N J
/
O
>

- +%( ,'"

# ***M>N
A

,'( )% (,+

%(

Affichage d'un caractre: La fonction

#
c tant une variable de type # , l'criture

permet d'afficher un caractre:

# = >N est quivalente
=MQ R M0 >N

Affichage d'un texte: La fonction

permet d'afficher un texte:
l'criture
=M! E M>N est quivalente
=M! E R M>N
Il vaut mieux utiliser puts et putchar si cela est possible, ces fonctions, non formates, sont
d'excution plus rapide, et ncessitent moins de place en mmoire lors de leur chargement.
6* %( ,.%+ %-+(
Oprateurs arithmtiques sur les rels: +
Oprateurs arithmtiques sur les entiers: +
avec la hirarchie habituelle.
Exemple particulier:

* / avec la hirarchie habituelle.

* / (quotient de la division) % (reste de la division)

char c,d;
c = 'G';
d = c+'a' 'A';

Les caractres sont des entiers sur 8 bits, on peut donc effectuer des oprations. Sur cet exemple, on
transforme la lettre majuscule G en la lettre minuscule g.
Oprateurs logiques sur les entiers:
& ET | OU ^ OU EXCLUSIF
~ COMPLEMENT A UN
DECALAGE A DROITE.
%

p = n 3;
p = n 3;

DECALAGE A GAUCHE

/* p est gale n dcal de 3 bits gauche */

/* p est gale n dcal de 3 bits droite */
8

INCREMENTATION DECREMENTATION
Le langage C autorise des critures simplifies pour l'incrmentation et la dcrmentation de
variables:
i = i+1; est quivalent i++;
i = i 1; est quivalent i ;
OPERATEURS COMBINES
Le langage C autorise des critures simplifies lorsqu'une mme variable est utilise de chaque ct
du signe = d'une affectation. Ces critures sont viter lorsque l'on dbute l'tude du langage C car
elles nuisent la lisibilit du programme.
a = a+b;
est quivalent
a+= b;
a = a b;
est quivalent
a = b;
a = a & b;
est quivalent
a&= b;
LES DECLARATIONS DE CONSTANTES
Le langage C autorise 2 mthodes pour dfinir des constantes.
"
:
d'une variable, dont la valeur sera constante pour tout le programme:
Exemple:

A
L

=>
. P * 5 78N
0 W P <* N
P J W J. N

****
O
Dans ce cas, le compilateur rserve de la place en mmoire (ici 4 octets), pour la variable pi, mais
dont on ne peut changer la valeur.
$

Exemple:

G
A
L

W !

l'aide de la directive de compilation G

. P * 5 78N
=>

0 W P <* N
J W J. N

****
O
Le compilateur ne rserve pas de place en mmoire. Les constantes dclares par G
traditionnellement en majuscules, mais ce n'est pas une obligation.
*

s'crivent

%( ",'3%+( ,'( )% 2.%(

Le langage C permet d'effectuer des oprations de conversion de type: On utilise pour cela l'oprateur
de "cast"().
9

Exemple :
G
G
A
L

H
H
=>

*#I
*#I

P9
50EN
0 N
P<8*6 0 N
EP= > N
P=
>N
P= # >N
P= # > N
=M" A
=M" A
=M" A
=M" A
=M.
#

KI $ Q7* KI Q R M0 0E>N
KI
$ Q KI Q7* R M0 0 >N
KI # $ Q KI Q R M0 0 >N
KI # $ Q7* KI Q R M0 0 >N
# M>N D #=>N

O
+

"#
(

( % )% ',&4+%( % )% " + " %+%( - "

,!E

3 %+

$
!

,'"

,'

% ":

La fonction D #, appartenant la bibliothque

*# permet la saisie clavier d'un caractre
alphanumrique. La saisie s'arrte ds que le caractre a t frapp.
On peut utiliser D
K

# de deux faons:

Exemple:

printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

getch();

K A

Exemple:

char alpha;
printf("ENTRER UN CARACTERE (ATTENTION PAS DE RETURN) ");
alpha = getch();
printf("\nVOICI CE CARACTERE: %c",alpha);
#

D
*

#=> D

*
,'"

,' (" '

La fonction
, appartenant la bibliothque
type de variable.

*#, permet la saisie clavier de n'importe quel

Les variables saisir sont formates, le nom de la variable est prcd du symbole & dsignant
l'adresse de la variable.
Exemples:

char alpha;
int i;
float r;
scanf("%c",&alpha);
scanf("%d",&i);
scanf("%x",&i);
scanf("%f",&r);

/* saisie d'un caractre */

/* saisie d'un nombre entier en dcimal */
/* saisie d'un nombre entier en hexadcimal*/
/* saisie d'un nombre rel */

+
$ Si l'utilisateur ne respecte pas le format indiqu dans
erreur n'est gnre.
%

, la saisie est ignore. Aucune

char alpha;
scanf("%d",&alpha);
Si l'utilisateur saisie 97 tout va bien, alpha devient le caractre dont le code ASCII vaut 97.
Si l'utilisateur saisie a, sa saisie est ignore.
*

,'"

,'

% ": +

La fonction D # pemet la saisie d'un caractre (char). Elle appartient la bibliothque

Les 2 critures suivantes sont quivalentes:
char c;
printf("ENTRER UN CARACTERE: ");
scanf("%c",&c);

*#.

char c;
printf("ENTRER UN CARACTERE: ");
c = getchar();

La fonction D # est moins gourmande en place mmoire que scanf. Il vaut mieux l'utiliser quand
cela est possible; D # utilise le flux d'entre exactement comme scanf.

"#
%( ( +-" -+%( ",')
,!E

,''%

%( %

%( 4,-" %(

$
!
+

/ '( +-"

,' ( ***

,+( *** ( ',' ***

Il s'agit de l'instruction:

>
L4 ," )/ '( +-" ,'(O
L4 ," )/ '( +-" ,'(O

Organigramme:

oui

non

condition
vraie

bloc 1 d'
instructions

bloc 2 d'
instructions

suite du programme
Syntaxe en C:

>
L
************N
************N
************N
O
L
************N
************N
************N
O
5

J!

J!

Le bloc "sinon" est optionnel:

oui

A
>
L4 ," )/ '( +-"

,'(O

non

condition
vraie

bloc d'
instructions

suite du programme
=

Syntaxe en C:

+
*

>
L
************N
************N
************N
O

J!

$ les {} ne sont pas ncessaires lorsque les blocs ne comportent qu'une seule instruction.
%( ,.%+

%-+( ,

;-%(

test d'galit:

= PP!>

test de non galit:

= XP!>

tests de relation d'ordre:

= H!>

= HP!>

= I!>

test de ET LOGIQUE:

==

>>

> YY =
% /

> ZZ =
,- /

M
==

test de OU LOGIQUE
M

=X=

test de NON LOGIQUE

M

!M
!M

>>

>>
/

= IP!>

Le langage C admet des critures contractes dans les expressions de test:

char reponse;
printf("Voulez vous jouer ?");
P D # =>N
=
PP / />
printf("BONJOUR\n");
else printf("TANT PIS"\n);

/ '( +-"

est quivalent

char reponse;
printf("Voulez vous jouer ?");
==
P D # =>> PP/ />
printf("BONJOUR\n");
else printf("TANT PIS"\n);

,' - " ( ,- ***

+% ***

L'instruction switch permet des choix multiples

= # >*

>

Syntaxe:
[
L

#=A

$ ******N
*******N
! \N
$********N
********N
! \N

>

au cas o la variable vaut:

cette valeur1: executer ce bloc d'instructions.

cette valeur2: executer ce bloc d'instructions.

*
*
*

etc ...
$ *******N
********N

aucune des valeurs prcdentes: executer ce bloc

d'instructions, pas de "break" ici.

O
le bloc "default" n'est pas obligatoire.
Linstruction switch correspond une cascade dinstructions if ...else

Exemple:
Cette instruction est commode pour fabriquer des "menus":
#

#
[
L

# N
=M ( % . + +,-.%
.%+ R M>N
=M ( %
.: 4% ;-%
.%+ R M>N
=M.,-+ (,+ +
.%+ (R M>N
=MR 3, +% ":, 1$ M>N
P D # =>N
#= # >
/ /$ *******N
*******N
! \N
/ /$ ******N
******N
! \N
/(/$
!

=MR
\N

' )- .+, + &&% ****M>N

=MR "% ":, 1 '/%( . ( .+%3- M>N J

O
5*

4,-" %

' ;-% ***

+% ***

=
A
>
L4 ," )/ '( +-" ,'(O

Il s'agit de l'instruction:

Organigramme:

oui

non

condition
vraie

bloc d'
instructions

Syntaxe en C:

[#

>
L
************N
************N
************N
O

J!

Le test se fait / !
+

0 le bloc d'instructions n'est pas forcment excut.

K
K

7*

les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.
On peut rencontrer la construction suivante: [# =
>N termine par un ; et
sans la prsence du bloc d'instructions. Cette construction signifie: M
/
A
M*

/ '( +-"

,' .,-+ ***

Il s'agit de l'instruction:
=
N
L4 ," )/ '( +-"

>

,'(O

Organigramme:

initialisation

condition de
continuit vraie

non

oui

bloc d'instructions

modification

suite du programme

Syntaxe en C:
=

>

L
************N
************N
************N
O

J!

Remarques:
Les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.
Les 3 instructions du for ne portent pas forcment sur la mme variable.
Une instruction peut tre omise, mais pas les ;
<

= P 9 N H 9 N FF>
L
************N
J!
************N
************N
O

Exemples:

correspond l'organigramme suivant:

i = 0

non

i < 10
oui
bloc d'instructions

suite du
programme

i=i+1

=NN>

La boucle

L
************N
************N
************N
O

J!

est une boucle infinie (rptition infinie du bloc d'instructions).

Utilisation de variables diffrentes:
P 9N
= P9N
L
************N
************N
************N

H 9 N FF>
J!

F JN

O
%
6*

$ Ecrire un programme C qui permet de saisir un entier puis calcule sa factoriel.

/ '( +-"

,' +%.% %+ ***

Il s'agit de l'instruction:

' ;-% ***

L4 ," )/ '( +-"

=
A
>

,'(O

Organigramme:
bloc d'
instructions

oui

non

condition
vraie

suite du programme
Syntaxe en C:
L
************N
************N
************N
O
[# =
Le test se faisant
+

J!

>N

0 le bloc est excut au moins une fois.

$ les {} ne sont pas ncessaires lorsque le bloc ne comporte qu'une seule instruction.

"#
%(

4 % -1 %

,!E

%( ":

'%( )% " + " %+%(

$
!,

%(

4 % -1 )% ',&4+%( = '

!
taille et par ses lments.

%
Dclaration:

>
* Un tableau est caractris par sa

&
W

^N

Exemples:

] 9^N
! ] 9^N

Utilisation: Un lment du tableau est repr par son indice. En langage C les tableaux
commencent l'indice 0. L'indice maximum est donc dim 1.
Appel:

Exemples:

] ^ P 7N
! ] ^ P 6* <8N
=MQ M0
] ^>N
=MQ M0Y
! ] ^>N

&

Tableaux deux dimensions:

Dclaration:

^]

^N

Exemples:

]5^]7^N
! ] ^] 9^N

Utilisation: Un lment du tableau est repr par ses indices. En langage C les tableaux
commencent aux indices 0. Les indices maximum sont donc dim1 1, dim2 1.
Appel:

^]

Exemples:

] ^]5^ P 7N
! ] ^]E^ P 6* <8N
=MQ M0
] ^]E^>N
=MQ M0Y
! ] ^]E^>N

'

,' )%(

4 % -1

On peut initialiser les tableaux au moment de leur dclaration:

Exemples:
] 9^ P L 0 050<0 60

0650

<0 7607 <ON

! ]5^ P L *6 07*8<0K<09*98ON
] ^] ^ P LL 070 O0L<050 OON J

%( ":

'%( )% " + " %+%(

En langage C, les chanes de caractres sont des

analogue celle d'un tableau une dimension:
(
Exemple:

] 9^N

. Leur manipulation est donc

^N

Le compilateur rserve (dim 1) places en mmoire pour la chane de caractres: En effet, il

ajoute toujours le caractre '- =/R9/> la fin de la chane en mmoire.
#

1 ] 9^ P M4,'@,-+ XMN

On peut utiliser la fonction

et le format %s:
#
] 9^ P M4,'@,-+MN
=M3, " % %1 %$ Q R M0
>N
On utilisera si possible la fonction
non formate:
=
>N
est quivalent
=MQ R M0

>N

( On peut utiliser la fonction

et le format %s. Une chane tant un pointeur, on
n'crit pas le symbole &. On utilisera de prfrence la fonction D non formate.
#

] 9^N
=M%' +%+ -' %1 %$ M>N
=MQ M0
>N est quivalent

>N

+
$ scanf ne permet pas la saisie d'une chane comportant des espaces: les caractres saisis
partir de l'espace ne sont pas pris en compte (l'espace est un dlimiteur au mme titre que LF) mais
rangs dans le tampon d'entre. Pour saisir une chane de type "il fait beau", il faut utiliser gets.
A l'issue de la saisie d'une chane de caractres, le compilateur ajoute '\0' en mmoire aprs le dernier
caractre.
5*

,'"

,'( (-+ %( ":

'%( )% " + " %+%(

La bibliothque /
0 fournit une multitude de fonctions pratiques pour le traitement de chanes
de caractres. Voici quelques fonctions les plus frquemment utilises:
# _
=H I>

fournit la longueur de la chane

compter le '\0' final

copie <t> vers <s>

ajoute <t> la fin de <s>
compare <s> et <t> lexicographiquement et fournit un rsultat:
ngatif
si <s> prcde <t>
zro
si <s> est gal <t>
positif
si <s> suit <t>
W=H I0 H I0 H I> copie au plus <n> caractres de <t> vers <s>
=H I0 H I0 H I> ajoute au plus <n> caractres de <t> la fin de <s>

W=H I0 H I>
=H I0 H I>
=H I0 H I>

+
Comme le nom d'une chane de caractres reprsente une adresse fixe en mmoire, on ne peut
pas 'affecter' une autre chane au nom d'un tableau:

Il faut bien copier la chane caractre par caractre ou utiliser la fonction

respectivement
W:
La concatnation de chanes de caractres en C ne se fait pas par le symbole '+' comme en
langage algorithmique ou en Pascal. Il faut ou bien copier la deuxime chane caractre par
caractre ou bien utiliser la fonction
ou
.
La fonction
est dpendante du code de caractres et peut fournir diffrents rsultats
sur diffrentes machines.

"#

%( ,'"

,!E

,'(

$
1

* ' +,)-" ,'

En langage C les sous programmes s'appellent des

L'imbrication de fonctions n'est pas autorise en C: une fonction ne peut pas tre dclare l'intrieur
d'une autre fonction. Par contre, une fonction peut
une autre fonction. Cette dernire doit tre
dclare A
celle qui l'appelle.
Une fonction possde un et un seul point d'entre, mais ventuellement plusieurs points de sortie (
l'aide du mot
).
-

A
A

!
!

* )%"

/
D
+

,'

On dclare une fonction ainsi :

'
= ' " D 0 ' # D 0 *** 0 '
L
dclaration variables locales ;
instructions ;
return
;
O
'

=>
! D !

D >

est le type de la valeur renvoye par la fonction. ' " est le type du 1

argument arg1 ....

Les variables locales sont des variables qui ne sont connues qu lintrieur de la fonction.
est value lors de linstruction return (expression) ;, cest la valeur que renvoie
la fonction quand elle est appele depuis main().
%

$
=

>L J
J

0! N
P N
!P7 N
J F! N J A

B
A

A W

O
5

,'" ,'( ( '( . ((

.+, + &&%*

% )/ + -&%' ( % '% +%'3,2 ' + %' -

Une fonction ne renvoyant rien au programme est une fonction de type A

%
G
G

H
H

A
L

*#I
*#I

=>

=M!

R M>N

O
A
L

=>
!

=>N J
=M.,-+ ",'
#=>N

J
'-%+ + ..%+ -'% ,-":%$ M>N

O
)

# D

D M4

!
M

# D
*

%
G
G

H
H

A
L

*#I
*#I

=>

=M!

R M>N

O
A
L
!

=>
E

=>N
=M

J
R M>N

O
A
L

D
O

=>
=>N J
=M.,-+ ",'
#=>N

J
'-%+ + ..%+ -'% ,-":%$ M>N

%
G
G

H
H

A
L

=>

*#I
*#I
J

N
JA
!
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P J N
=M3, " (,' " ++%$ Q R M0
O
A
L

=>

=>N J
=M.,-+ ",'
#=>N

>N

J
'-%+ + ..%+ -'% ,-":%$ M>N

O
"
Les variables n et n2 ne sont connues que de la fonction carr on les appels des variables locaux.
%
G
G

5
H
H

A
L

=>

*#I
*#I
J

N
JA
!
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P J N
=M3, " (,' " ++%$ Q R M0

>N

O
A
L

! =>

N
JA
!
! J
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P J J N
=M3, " (,' "-4%$ Q R M0 >N
O
A
L

=>
#

# N
JA
!
=> J
=M" "- )- " ++%
.%+ R M>N
=M" "- )- "-4%
.%+ R M>N
=MR 3, +% ":, 1$ M>N
=MQ M0Y # >N

#= #
L

>
/ /$
=>N!
/ /$ ! =>N!

O
=MR .,-+ ",'
#=>N

\N
\N

'-%+ + ..%+ -'% ,-":%$ M>N

O
"
Les 2 variables locales n sont indpendantes l'une de l'autre.
La variable locale choix n'est connue que de main().
%
G
G

7
H
H
N

A
L

*#I
*#I
JA

=>

! D !

N JA
!
J
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P J N
=M3, " (,' " ++%$ Q R M0

>N

O
A
L

! =>

N JA
!
J
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P J J N
=M3, " (,' "-4%$ Q R M0 >N
O
A
L
#

=>

# N
JA
!
=> J
=M" "- )- " ++%
.%+ R M>N
=M" "- )- "-4%
.%+ R M>N
=MR 3, +% ":, 1$ M>N
=MQ M0Y # >N
[ #= # >
L
/ /$
=>N! \N
/ /$ ! =>N! \N
O
=MR .,-+ ",' '-%+ + ..%+ -'% ,-":%$ M>N
D #=>N
O

"
La variable globale n est connue de tout le programme (fonctions et main()).
La variable locale choix n'est connue que de main().
Le fichier den tte na pas chang.
2
5*

,'" ,' +%'3,2 ' -'% 3 %-+ - .+, + &&% % ( '( . (( %

)/ + -&%' (
Dans ce cas, la fonction, aprs excution, renvoie une valeur. Le type de cette valeur est dclar avec
la fonction. La valeur retourne est spcifie l'aide du mot rserv
.

%
G
G

6
H
H

*#I
*#I
!

=> J

L
N JA

L
=M%
=MQ M0Y
>N
O[# ==
I > YY =
=
>N
O
A
L

9 $ M>N
HP 9>>

=>
N
P

=>N

=M
=M.,-+ (,+
#=>N

$ Q R M0 >N
+ + ..%+ -'% ,-":% M>N

O
7*

,'"

,'( 3%" . ((

% )/ + -&%' (

Ce paragraphe traite directement du cas gnral: fonctions de type void ou non (renvoyant une valeur
ou non).
Ces fonctions utilisent les valeurs de certaines variables du programme les ayant appel: on passe ces
valeurs au moyen d'arguments dclars avec la fonction.
%
G
G

H
H
=

J
N JA
P J N
= >N

*#I
*#I
> J

J
J

O
<

A
L

=>

0 0
0
N
JA
!
J
=M%' +%+ -' ',&4+%$ M>N
=MQ M0Y >N
P
= >N
=M%' +%+ -' - +% ',&4+%$ M>N
=MQ M0Y >N
P
= >N
=M3, " %-+( " ++%($ Q Q R R M0
0
=M.,-+ (,+ + + ..%+ -'% ,-":%$ M>N
#=>N

>N

O
On peut ainsi appeler la fonction carre autant de fois que l'on veut avec des variables diffrentes.
x est un paramtre, ou argument: ce n'est pas une variable du programme.
S'il y a plusieurs arguments passer, il faut respecter la syntaxe suivante:
Exemples: void fonction1(int x, int y)
6* +%(-&% (-+ 3 +

4 %( %

void fonction2(int a, float b, char c)

,'"

,'(

On a donc vu qu'une variable D ! est dclare au dbut du programme et qu'elle est connue de
tout le programme.
A
! D !
9
!
/
D
0
A
*
On a vu aussi qu'une variable
(dclare au dbut d'une fonction ou de main()) n'est connue que
de cette fonction ou de main(). Une variable locale est encore appele
*
Les variables locales ne sont pas initialises (sauf si on le fait dans le programme) et elles perdent
leur valeur chaque appel la fonction.
On peut allonger la dure de vie d'une variable locale en la dclarant
* Lors d'un nouvel appel
la fonction, la variable garde la valeur obtenue la fin de l'excution prcdente. Une variable
est initialise 0 lors du premier appel la fonction.
Exemple:

devient

% . (( % )% . + &% +%( %' +% ,'"

.+, + &&% .+ '" .

,'( ,- %' +% ,'"

En langage C, le passage de paramtre se fait uniquement par adresse. Autrement dit,

A
A
!
=>
/
A
! *

,'( %

*%

Exemple: Fonction permettant d'changer la valeur de 2 variables:

(W
$
#include <stdio.h>
A
#=
0
W>
L
int tampon;
tampon = x;
x = y;
y = tampon;
O
A
=>
L
int a = 5 , b = 8;
#= 0!>N
printf(%a=%d\n%, a) ;
printf(%b=%d\n%, b) ;
O
. (( % )%( . + &% +%(
. + 3 %-+

(W
$
#include <stdio.h>
A
#= J 0
JW>
L
int tampon;
tampon = Jx;
Jx = Jy;
Jy = tampon;
O
A
=>
L
int a = 5 , b = 8 ;
#=Y 0Y!>N
printf(%a=%d\n%, a) ;
printf(%b=%d\n%, b) ;
O
. (( % )%( . + &% +%(
. + )+%((%

a et b sont des variables locales main(). La fonction

le fait donc en passant par l'adresse de ces variables.

# ne peut donc pas modifier leur valeur. On

Exprimenter ces deux exemples, noter les rsultats obtenus.

Dans un deuxime temps, afficher dans main() les adresses de a et de b et dans
et
y (programme de gauche), les adresses x et y (programme de droite).
!

# les adresses

# $% ! " #

+ ,

! &''()&'*'
!
!"# I

"
%

!*
&

!*
! .
! #!+

. ?
%
Ecrire un programme qui saisit 2 entiers et affiche successivement la somme, la diffrence, le produit
et le quotient de ces 2 entiers.

%
Ecrire un programme qui demande lutilisateur de donner le rayon dun cercle et lui retourne sa
surface et son primtre.

%
Ecrire un programme qui saisit deux entiers a et b et permute la valeur de ces deux entiers.

Ecrire un programme qui saisit un rel x et un entier n et affiche x la puissance n.

Ecrire un programme qui saisit un caractre c puis affiche son code ASCII en dcimal, en octal(base
huit) et en hexadcimal(base seize).

"

. ?

%
#include<stdio.h>
#include<conio.h>
void main()
{
int a,b;
printf("Entrer deux nombres entiers :");
scanf("%d %d",&a,&b);
printf("\nLa
printf("\nLa
printf("\nLe
printf("\nLe

somme de %d et %d vaut %d",a,b,a+b);

difference de %d et %d vaut %d",a,b,a'b);
produit de %d et %d vaut %d",a,b,a*b);
quotient de %d et %d vaut %f\n",a,b,(float)a/(float)b);

printf("Pour continuer frapper une touche...");

getch(); /* Attente d'une saisie clavier */
}

%
#include<stdio.h>
#include<conio.h>
void main()
{
/* il faut utiliser une variable tampon pour l'echange */
int a,b,tampon;
printf("Entrer 2 entiers a et b:");
scanf("%d %d",&a,&b);
tampon=a;
a=b;
b=tampon;
printf("a vaut maintenant %d\n",a);
printf("b vaut maintenant %d\n",b);
printf("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}

%
#include<stdio.h>
#include<math.h>
#include<conio.h>
#define Pi 4*atan(1)
void main()
{
float r;
printf("Entrer le rayon du cercle :");
scanf("%f",&r);
printf("La surface du cercle vaut %f \n",Pi*r*r);
printf("Le perimetre du cercle vaut %f\n",2*Pi*r);
printf("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}

#include<stdio.h>
#include<math.h>
#include<conio.h>
void main()
{
int n;
float x;
printf("\nEntrer un reel :");
scanf("%f",&x);
printf("Entrer une puissance entiere:");
scanf("%d",&n);
printf("%f a la puissance %d vaut %f\n",x,n,pow(x,n));
printf("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}

#include <stdio.h>
#include <conio.h>
void main()
{
char c;
printf("Entrer un caractre :");
scanf("%c",&c);
printf("%d\n",c);

/* affichage du code ASCII en decimal */

/* et retour la ligne */
printf("%o\n",c);
/* affichage du code ASCII en base huit
/* et retour la ligne */
printf("%x\n",c);
/* affichage du code ASCII en hexadecimal
/* et retour la ligne */
printf("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}

# $% ! " #

! &''()&'*'
+ ,
!
!"# I

"
%

!*
!* ! .
&
! #!+
-

. ?
( )

*+ ,

%
Considrez la squence d'instructions suivante:

! "

> Copiez la squence d'instructions en utilisant des tabulateurs pour marquer les blocs
appartenant ensemble.

!> Dterminez les rponses du programme pour chacun des couples de nombres suivants et
vrifiez l'aide de l'ordinateur.
A=10 et B=5
A=5 et B=5
A=5 et B=10
A=10 et B=10
A=20 et B=10
A=20 et B=20

%
Considrez la squence d'instructions suivante:

##
! "

> Copiez la squence d'instructions en utilisant des tabulateurs pour marquer les blocs
appartenant ensemble.

!> Pour quelles valeurs de A et B obtient on les rsultats:

!
!
! sur l'cran?
> Pour quelles valeurs de A et B n'obtient on pas de rponse sur l'cran?
> Notez vos rponses et choisissez vous mmes des valeurs pour A et B pour les vrifier l'aide
de l'ordinateur.

%
Ecrivez un programme qui saisit un caractre, et qui teste s'il s'agit d'une lettre majuscule, si oui il
renvoie cette lettre en minuscule, sinon il renvoie un message d'erreur.

Ecrivez un programme qui lit trois valeurs entires (A, B et C) au clavier et qui affiche la plus grande
des trois valeurs, en utilisant:
>

!>

et une variable d'aide MAX

$ %%% $

sans variable d'aide

> les oprateurs conditionnels et une variable d'aide MAX

> les oprateurs conditionnels sans variable d'aide

Ecrivez un programme qui lit trois valeurs entires (A, B et C) au clavier. Triez les valeurs A, B et C
par changes successifs de manire obtenir :
val(A) val(B) val(C)
Affichez les trois valeurs.

Ecrivez un programme qui lit deux valeurs entires (A et B) au clavier et qui affiche le signe du
produit de A et B sans faire la multiplication.

%
Ecrivez un programme qui lit deux valeurs entires (A et B) au clavier et qui affiche le signe de la
somme de A et B sans faire l'addition. Utilisez la fonction "& de la bibliothque
qui
renvoie la valeur absolue d'un flottant.

<

Ecrivez un programme qui calcule les solutions relles d'une quation du second degr
en discutant la formule:

Utilisez une variable d'aide ) pour la valeur du discriminant b2 4ac et dcidez l'aide de ), si
l'quation a une, deux ou aucune solution relle.
Utilisez des variables du type
pour A, B et C.
Considrez aussi les cas o l'utilisateur entre des valeurs nulles pour A; pour A et B; pour A, B et C.
Affichez les rsultats et les messages ncessaires sur l'cran.

Ecrivez un programme qui permet de saisir un entier entre 1 et 7 et affiche en toutes lettres le nom du
jour de la semaine qui lui correspond.

"

. ?

%
if (A>B) printf ("premier choix \n"); else
if (A>10) printf ("deuxime choix \n");
if (B<10) printf ("troisime choix \n");
else printf ("quatrime choix \n");

> Copiez la squence d'instructions en utilisant des tabulateurs pour marquer les blocs
appartenant ensemble.

if (A>B)
printf ("premier choix \n");
else
if (A>10)
printf ("deuxime choix \n");
if (B<10)
printf ("troisime choix \n");
else
printf ("quatrime choix \n");

!> Dterminez les rponses du programme pour chacun des couples de nombres suivants et
vrifiez l'aide de l'ordinateur.
A=10 et B=5 :

A=5 et B=5 :
A=5 et B=10 :

! "

A=10 et B=10 :

! "

A=20 et B=10 :

! "
A=20 et B=20 :

! "

%
Considrez la squence d'instructions suivante:
if (A>B)
if (A>10)
printf ("premier choix \n"); else if (B<10)
printf ("deuxime choix \n"); else
if (A==B) printf ("troisime choix \n");
else printf ("quatrime choix \n");

> Copiez la squence d'instructions en utilisant des tabulateurs pour marquer les blocs
appartenant ensemble.
if (A>B)
if (A>10)
printf ("premier choix \n");
else if (B<10)
printf ("deuxime choix \n");
else if (A==B)
printf ("troisime choix \n");
else
printf ("quatrime choix \n");

!> Le rsultat:
apparat pour (A>B) et (A>10)

apparat pour (10A>B)

apparat pour (10A>B10) et (A=B)

10>10 impossible
A>B et A=B impossible

! "

=> "troisime choix" n'apparat jamais

apparat pour (10A>B10) et (AB)

10>10 impossible

=> "quatrime choix" n'apparat jamais

> On n'obtient pas de rponses pour (AB). Si (A>B) alors la construction K

garantit que toutes les combinations sont traites et fournissent un rsultat.

%
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
printf("ENTRER UNE LETTRE:");
c = getchar();
if((c>='A') && (c<='Z'))
printf("CETTE LETTRE EN MINUSCULE: %c\n",c);
else
printf("CE N'EST PAS UNE LETTRE MAJUSCULE\n");
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

5
>

et une variable d'aide MAX

#include <stdio.h>
#include <conio.h>
void main()
{
'
( )
*
+
"
- - .

&
.

.'

( )#
( )#
' ( )
( )#'
/" 0"
"
"
( )
printf("Tapez une touche pour continuer");
getch();
}

<

K *** K

!> if else if ... else sans variable d'aide

int A, B, C;
printf("Introduisez trois nombres entiers :");
scanf("%d %d %d", &A, &B, &C);
printf("La valeur maximale est ");
if (A>B && A>C)
printf("%d\n",A);
else if (B>C)
printf("%d\n",B);
else
printf("%d\n",C);

> oprateurs conditionnels et une variable d'aide MAX

int A, B, C;
int MAX;
printf("Introduisez trois nombres entiers :");
scanf("%d %d %d", &A, &B, &C);
MAX = (A>B) ? A : B;
MAX = (MAX>C) ? MAX : C;
printf("La valeur maximale est %i\n", MAX);

> oprateurs conditionnels sans variable d'aide

int A, B, C;
printf("Introduisez trois nombres entiers :");
scanf("%d %d %d", &A, &B, &C);
printf("La valeur maximale est %d\n",
(A>((B>C)?B:C)) ? A : ((B>C)?B:C));

#include <stdio.h>
#include <conio.h>
void main()
{
/* Tri par ordre dcroissant de trois entiers
en changeant les valeurs
*/
int A, B, C, AIDE;
printf("Introduisez trois nombres entiers :");
scanf("%d %d %d", &A, &B, &C);
printf("Avant le tri : \tA = %d\tB = %d\tC = %d\n", A, B, C);
12 3"
"
"
$
21
4
*56 #
#
# *56
7
'
4
*56 #
# '
' # *56
7
12

' 21
'
4
*56 #
# '
' # *56
7

,
# # ' # printf("Tapez une touche pour continuer");
getch();
}

'

#include <stdio.h>
#include <conio.h>
void main()
{
/* Afficher le signe du produit de deux entiers sans
faire la multiplication
*/
int A, B;
printf("Introduisez deux nombres entiers :");
scanf("%d %d", &A, &B);
..
88
..
/
9
- 2 ..
88
..
/
9
- 2 :9"
/

2 -

+:

printf("Tapez une touche pour continuer");

getch();
}

%
#include <stdio.h>
#include <conio.h>
;
" %
void main()
{
/* Afficher le signe de la somme de deux
faire l'addition
*/
int A, B;
printf("Introduisez deux nombres entiers
scanf("%d %d", &A, &B);
..
88
..
.. "&
88
..
.. "&
/
9
"
- < ..
88
..
..
88
..
..
/
9
"
- < -

entiers sans

:");
"&
"&
"&
"&

"&
"&
:9"

/"
- < +:
printf("\n Tapez une touche pour continuer");
getch();
}

<

#include <stdio.h>
#include <conio.h>
;
" %
void main()
{
/* Calcul des solutions relles d'une quation du second degr */
int A, B, C;
float D; /* Discriminant */
printf("Calcul des solutions relles d'une quation du second \n");
printf("degr de la forme
ax^2 + bx + c = 0 \n\n");
printf("Introduisez les valeurs pour a, b, et c : ");
scanf("%d %d %d", &A, &B, &C);
/* Calcul du discriminant b^2'4ac */
5 #
=
> $ ?% 2 2'

59

/* Distinction des diffrents cas */

## .. ## .. '##
/* 0x = 0 */
@
:
:! "
%
## .. ##
/* Contradiction: c # 0 et c = 0 */
'
:! "
"
%
##
/* bx + c = 0 */
4
/"
:! "
9 :
,
# $'1
7
5
/* b^2'4ac < 0 */
'
:! "
A" "
:
%
/* b^2'4ac = 0 */

5##
4
'

:! "
-

"
$ 1 >2

7
/* b^2'4ac > 0 */
4
/

:
$ < !
$ $ !

# > # -

:! "
5
5

1 >2
1 >2

7
printf("\n tapez une touche pour continuer");
getch();
}

#include <stdio.h>
#include <conio.h>
void main()
{
int N;
string jour[];
printf("Introduisez le numro du jour entre 1 et 7 :");
scanf("%d", &N);
=

4
"
"
"
"
"
"
"

,
>,
E,
?,
G,
H,
J,
"

C
C
C
C
C
C
C
,

#
#
#
#
#
#
#

/
("
(
F
3
I"
5 "

&
&

"D
"D
& "D
& "D
& "D
& "D
& "D
F
*

12

7
/ C
"
"
- ,
printf("Tapez une touche pour continuer");
getch();
}

"

&

"D

21

# $% ! " #

! &''()&'*'
+ ,
!
!"# I

"
%

!*
!* ! .
&
! #!+
-

. ?
)

*+ ,

.
%

/ $

%
Saisir une suite de caractres, compter et afficher le nombre de lettres e et d'espaces. Utiliser les
proprits du tampon.

%
Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme, leur produit et
leur moyenne. Choisissez un type appropri pour les valeurs afficher. Le nombre N est entrer au
clavier. Rsolvez ce problme,
> en utilisant [#
!> en utilisant
> en utilisant

,
K [#

%
Calculez par des soustractions successives le quotient entier et le reste de la division entire de deux
entiers entrs au clavier.

Calculez par multiplications successives XN de deux entiers naturels X et N entrs au clavier.

Calculez la somme des N premiers termes de la srie harmonique :

1 + 1/2 + 1/3 + ... + 1/N

Calculez la somme, le produit et la moyenne d'une suite de chiffres non nuls entrs au clavier, sachant
que la suite est termine par zro. Retenez seulement les chiffres (0, 1 ... 9) lors de l'entre des
donnes et effectuez un signal sonore si les donnes sortent de ce domaine.

%
Calculez le nombre lu rebours d'un nombre positif entr au clavier en supposant que le fichier
d'entre standard contient une suite de chiffres non nuls, termine par zro (Contrlez s'il s'agit
vraiment de chiffres).
%

$ Entre: 1 2 3 4 0

Affichage: 4321

<

Calculez le nombre lu rebours d'un nombre positif entr au clavier en supposant que le fichier
d'entre standard contient le nombre inverser.
%

$ Entre: 1234

Affichage: 4321

Calculez le N ime terme UN de la suite de FIBONACCI qui est donne par la relation de rcurrence:
U1=1 U2=1 UN=UN 1 + UN 2 (pour N>2)
Dterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise pour UN le
type .

"

. ?

%
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
int compt_espace= 0,compt_e= 0;
printf("ENTRER UNE PHRASE:\n");
while((c=getchar())!='\n')

/*
/*
/*
/*
/*

{
if(c=='e')compt_e++;

*/
*/
*/
et recuperes par getchar lors */
des autres passages */

lors du 1er passage, getchar ne prend

en compte que le 1er caractere
les autres sont ranges dans le tampon

if(c==' ')compt_espace++;
}
printf("NOMBRE DE e: %d\n",compt_e);
printf("NOMBRE D'ESPACE: %d\n",compt_espace);
printf("POUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}

%
a) en utilisant [#

#include <stdio.h>
#include <conio.h>
void main()
{
int N;
/* nombre de donnes */
int NOMB;
/* nombre courant
*/
int I;
/* compteur */
long SOM;
/* la somme
des nombres entrs */
double PROD; /* le produit des nombres entrs */
printf("Nombre de donnes : ");
scanf("%d", &N);
IK(#
LMK5#
*#
=
* #B
4
- %
&
"
.BK(
IK( <# BK(
LMK5 2# BK(
*<<

7
printf("La somme
des
printf("Le produit des
printf("La moyenne des
printf("POUR CONTINUER
getch();

%d nombres est %ld \n", N, SOM);

%d nombres est %f\n", N, PROD);
%d nombres est %f\n", N, (float)SOM/N);
FRAPPER UNE TOUCHE ");

b) en utilisant

K [#

, Remplacez le bloc de traitement (en gras) de (a) par :

SOM=0;
PROD=1;
I=1;
do
55

{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
while(I<=N);

c) en utilisant

Remplacez le bloc de traitement (en gras) de (a) par :

for (SOM=0, PROD=1, I=1 ; I<=N ; I++)
{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
}

%
#include <stdio.h>
#include <conio.h>
void
{
int
int
int
int

main()
NUM;
DEN;
DIV;
RES;

/*
/*
/*
/*

numrateur
de la division entire */
dnominateur de la division entire */
rsultat de la division entire */
reste
de la division entire */

printf("Introduisez le numrateur
: ");
scanf("%d", &NUM);
printf("Introduisez le dnominateur : ");
scanf("%d", &DEN);
M6I#BN(
5*3#
=
M6I #56B
4
M6I$#56B
5*3<<
7
/* ou mieux encore : */
M6I#BN( 5*3#
M6I #56B
5*3<<
M6I$#56B
*/
printf(" %d divis par %d est %d reste %d\n", NUM, DEN, DIV, RES);
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

#include <stdio.h>
#include <conio.h>
void main()
{
int X, N;
int I;
&
M6IN

/*
/*
/*
/*

Les donnes
Le compteur
Type double
grandeur du

*/
*/
cause de la */
rsultat.
*/

4
printf("Entrez l'entier naturel X : ");
scanf("%d", &X);
7
=

) #
57

4
printf("Entrez l'exposant
scanf("%d", &N);

N : ");

7
=

/* Pour N=0, le rsultat sera automatiquement X^0=1 */

M6IN# %
*#
* #B
*<<
M6IN2#)
/* Attention: Pour X=0 et N=0 , 0^0 n'est pas dfini */
B## .. )##
+:
"
+:
A
"
:
O
M:

"

, -

P -

# -%

M6IN

printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

getch();
}

#include <stdio.h>
#include <conio.h>
void main()
{
int N;
/* nombre de termes calculer */
int I;
/* compteur pour la boucle */
" IK( /* Type float cause de la prcision du rsultat.
4
printf ("Nombre de termes: ");
scanf ("%d", &N);
7
=

B #
IK(# %
*#
* #B
*<<
IK( <#
"
1*
printf("La somme des %d premiers termes est %f \n", N, SOM);
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();

%
(

6
=

>$

#include <stdio.h>
#include <conio.h>
void main()
{
int X;
int N=0;
int SOM=0;
long PROD=1;

/*
/*
/*
/*
/*

Le chiffre courant
*/
Le compteur des donnes */
La somme actuelle
*/
Le produit actuel ' Type long */
cause de la grandeur du rsultat. */

56

*/

4
/* Saisie des donnes (pour perfectionnistes) */
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
)

88) Q
"
)

4
B<<
IK(<#)
LMK52#)
7
O) .. B
4/* Seulement si au moins un chiffre a
printf("La somme
des chiffres est %d
printf("Le produit des chiffres est printf("La moyenne des chiffres est -

t accept */
\n", SOM);
\n", PROD);
\n",
" IK(1B);

7
7
=
)
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

%
#include <stdio.h>
#include <conio.h>
void main()
{
int X;
int N=0;
long VALD=1;
long NOMB=0;

/*
/*
/*
/*

Le chiffre courant
*/
Le compteur des dcimales */
Valeur de la position dcimale courante */
Le nombre rsultat
*/

4
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
) #

.. ) #Q
"
)

4
BK( <# 3 /52)
B<<
3 /5 2#
7
/" 0"

&

7
=

printf("POUR CONTINUER FRAPPER UNE TOUCHE ");

getch();
}

En remplaant la ligne
NOMB += VALD*X;

par
5

BK(

NOMB += pow(10, N)*X;

on n'a plus besoin de la variable VALD. Il faut cependant inclure les fonctions de la bibliothque
/
0. D'autre part, le calcul de 10N serait alors rpt chaque excution de la boucle.
Finalement, cette variante est plus lente et plus volumineuse que la premire.

<

#include <stdio.h>
#include <conio.h>
void main()
{
int NOMB;
/* Le nombre inverser */
int NINV;
/* Le nombre invers
*/
/* Attention: en utilisant le type int, il est impossible */
/* d'inverser correctement des nombres comme 10033 ...
*/
4
printf("Entrez un nombre positif (<10000) : ", NOMB);
scanf("%d", &NOMB);
7
=

BK(

88 BK(

QQQQ

B*B3#
=
BK(
4
B*B3 2#
B*B3 <# BK( BK( 1#
7
/* Autre possibilit : */
/*
B*B3#
BK(
BK( 1#
B*B3 # B*B32
< BK( */
printf("Le nombre 'invers' est : %d\n", NINV);
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

#include <stdio.h>
#include <conio.h>
void
{
int
int
int

main()
U1, U2, UN;
N;
I;

/* pour parcourir la suite */

/* rang du terme demand
*/
/* compteur pour la boucle */

4
printf("Rang du terme demand : ");
scanf("%d", &N);
7
=

N #N>#
/* Initialisation des deux premiers termes */
B##
NB#N
B##>
NB#N>
4
*#E
* #B
*<<
4
NB # N <N>
N # N>
5<

N> # NB
7
7
printf("Valeur du terme de rang %d : %d\n", N, UN);
printf("POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}

Rang et terme maximal calculable en utilisant les dclarations :

U1, U2, UN; (spc. de format : %d) U23 = 28657

58

# $% ! " #

! &''()&'*'
+ ,
!
!"# I

"
%

!*
!* ! .
&
! #!+
-

. ?5
)

*+ ,

0 1

"

Bibliothque (string.h):
void *
(char *chaine1, char *chaine2)
int
void *
int

void *

concatne les 2 chanes, rsultat dans chaine1,

renvoie l'adresse de chaine1.
(char *chaine)
renvoie la longueur de la chaine ('\0' non comptabilis).
A(char *chaine)
inverse la chane et, renvoie l'adresse de la chaine inverse.
(char *chaine1,char *chaine2)
renvoie un nombre:
o positif si la chane1 est suprieure la chaine2 (au sens de l'ordre alphabtique)
o ngatif si la chane1 est infrieure la chane2
o nul si les chanes sont identiques.
W(char *chaine1,char *chaine2)
recopie chaine2 dans chaine1 et renvoie l'adresse de chane1.

Ces fonctions renvoient l'adresse de l'information recherche en cas de succs, sinon le pointeur NULL (c'est dire le
pointeur de valeur 0 ou encore le pointeur faux).
void *
void *
void *

# (chaine,caractre)
# (chaine,caractre)
(chane,sous chane)

recherche le caractre dans la chane.

idem en commenant par la fin.
recherche la sous chaine dans la chane.

Bibliothque (stdlib.h):
int
float
exemple:

(char *chane)
(char *chaine)

convertit la chane en entier

convertit la chane en rel

printf("ENTRER UN TEXTE: ");

gets(texte);
n = atoi(texte) ;
printf("%d",n); /* affiche 123 si texte vaut "123" */
/* affiche 0 si texte vaut "bonjour" */

void *itoa(int n,char *chane,int base) convertit un entier en chane:

79

itoa(12,texte,10);

base: base dans laquelle est exprim le nombre,

cette fonction renvoie l'adresse de la chane.
texte vaut "12"

?
crire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entres au clavier et affiche le tableau. Calculer et
afficher ensuite la somme des lments du tableau.

crire un programme qui calcule le produit scalaire de deux vecteurs d'entiers - et 3 (de mme
dimension).
%

$
1
8 E

>

1
$? 8 2 8 >
1

$E

G 8 # E2><>2 $E < $? 2G # $>

1

?
crire un programme qui dtermine la plus grande et la plus petite valeur dans un tableau d'entiers
. Afficher ensuite la valeur et la position du maximum et du minimum. Si le tableau contient
plusieurs
ou
, le programme retiendra la position du premier maximum ou
minimum rencontr.

?5
. !
$ Rechercher dans un tableau d'entiers une valeur 3
entre au clavier. Afficher la
position de 3
si elle se trouve dans le tableau, sinon afficher un message correspondant. La
valeur .,( qui est utilise pour mmoriser la position de la valeur dans le tableau, aura la valeur
1 aussi longtemps que 3
n'a pas t trouve.
A
$
0 0
Comparer successivement les valeurs du tableau avec la valeur donne.
0 0
0
"
$)
.
1
Comparer le nombre recherch la valeur au milieu du tableau,
s'il y a galit ou si le tableau est puis, arrter le traitement avec un message
correspondant.
si la valeur recherche prcde la valeur actuelle du tableau, continuer la recherche
dans le demi tableau gauche de la position actuelle.
si la valeur recherche suit la valeur actuelle du tableau, continuer la recherche dans le
demi tableau droite de la position actuelle.
crire le programme pour le cas o le tableau A est tri par ordre croissant.
;
$ Quel est l'avantage de la recherche dichotomique ?

?7
Ecrire un programme qui demande l'introduction du nom et du prnom de l'utilisateur et qui
affiche alors la longueur totale du nom sans compter les espaces. Employer la fonction
.
%

$
7

+ 0
C

I*B* I" "

I*B* I" " O

?6
crire un programme qui lit 5 mots, spars par des espaces et qui les affiche ensuite dans une
ligne, mais dans l'ordre inverse.
Les mots sont mmoriss dans 5 variables M1, ... ,M5.
%
0
O

"
0

"

?
crire un programme qui lit une ligne de texte (ne dpassant pas 200 caractres) la mmorise dans
une variable TXT et affiche ensuite:
> la longueur L de la chane.
!> le nombre de 'e' contenus dans le texte.
> toute la phrase rebours, sans changer le contenu de la variable TXT.
> toute la phrase rebours, aprs avoir invers l'ordre des caractres dans TXT:
%

$
0
O

"
"

O
0

?<
Ecrire un programme qui lit un texte TXT (de moins de 200 caractres) et qui enlve toutes les
apparitions du caractre 'e' en tassant les lments restants. Les modifications se feront dans la
mme variable TXT.
%
$
'
'

?8
Ecrire un programme qui lit un verbe rgulier en "er" au clavier et qui en affiche la conjugaison au
prsent de l'indicatif de ce verbe. Contrlez s'il s'agit bien d'un verbe en "er" avant de conjuguer.
Utiliser les fonctions D ,
,
et
.
%

$
3
C

&

? 9

Ecrire un programme qui lit deux chanes de caractres CH1 et CH2, les compare
lexicographiquement et affiche le rsultat:
%

$
*
*

+
+
'

"
"

"S
"S

,
'
, "&

"&

?
crire un programme qui permet de vrifier si un mot saisit est un palindrome. Un mot est dit
palindrome si la lecture du mot se fait gauche et droite. La taille maximale du mot est 30
caractres. %
$ aziza

",++%"
%

,' )- . '?5

#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
@TG U /* tableau donn */
int N;
/* dimension
*/
int I;
/* indice courant */
long SOM; /* somme des lments ' type long cause */
/* de la grandeur prvisible du rsultat. */
/* Saisie des donnes */
4
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
7=
B # .. B #G
*#

* B

*<<

4
6 :
"

.@T*U

7
/* Affichage du tableau */
printf("Tableau donn :\n");
*#
* B *<<
@T*U
/* Calcul de la somme */
IK(#
*#
* B *<<
IK( <# @T*U
/* Edition du rsultat */
printf("Somme de lments : - \n", SOM);
printf("\n Tapez une touche pour continuer");
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int U[50], V[50]; /* tableaux donns */
int N;
/* dimension
*/
int I;
/* indice courant
*/
long PS;
/* produit scalaire */
/* Saisie des donnes */
4
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
7=
B # .. B #G
printf("** Premier tableau **\n");
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &U[I]);
}
printf("** Deuxime tableau **\n");
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
75

scanf("%d", &V[I]);
}
12 '"
" "
21
LI#
*#
* B *<<
LI <#
9 NT*U23T*U
/* Edition du rsultat */
printf("Produit scalaire : - \n", PS);
printf("\n Tapez une touche pour continuer");
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int N;
/* dimension
*/
int I;
/* indice courant */
int MIN;
/* position du minimum */
int MAX;
/* position du maximum */
/* Saisie des donnes */
4
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
7=
B # .. B #G
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &A[I]);
}
/* Affichage du tableau */
printf("Tableau donn :\n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
12 M
"
21
(*B#
( )#
*#
* B *<<
4
T*U T( )U ( )#*
T*U T(*BU (*B#*
7
/* Edition du rsultat */
printf("Position du minimum : %d\n", MIN);
printf("Position du maximum : %d\n", MAX);
printf("Valeur
du minimum : %d\n", A[MIN]);
printf("Valeur
du maximum : %d\n", A[MAX]);
printf("\n Tapez une touche pour continuer");
getch();
}

?5

0 0
:
Comparer successivement les valeurs du tableau avec la valeur donne.
#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int VAL;
/* valeur rechercher
*/
int POS;
/* position de la valeur */
77

int N;
int I;

/* dimension
*/
/* indice courant */

/* Saisie des donnes */

4
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
7=
B # .. B #G
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &A[I]);
}
printf("Elment rechercher : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donn : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
12 M
"
" 0"
21
LKI # $
*#
* B .. LKI##$
*<<
T*U##3 /
LKI#*
/* Edition du rsultat */
LKI##$
/" 0"
:
0
"
"
"& " %
else
printf("La valeur %d se trouve la position %d. \n", VAL, POS);
printf("\n Tapez une touche pour continuer");
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
int A[50]; /* tableau donn */
int VAL;
/* valeur rechercher
*/
int POS;
/* position de la valeur */
int N;
/* dimension
*/
int I;
/* indice courant */
*BV (*/ INL 12
"
/* Saisie des donnes */
4
printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
7=
B # .. B #G
for (I=0; I<N; I++)
{
printf("Elment %d : ", I);
scanf("%d", &A[I]);
}
printf("Elment rechercher : ");
scanf("%d", &VAL );
/* Affichage du tableau */
printf("Tableau donn : \n");
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
12 *
"
"
"
*BV#
INL#B$
12 M
"
" 0"
21
76

21

21

LKI#$
=

*BV #INL

..

LKI##$

4
(*/# INL<*BV 1>
3 /
T(*/U
INL#(*/$
3 /
T(*/U
*BV#(*/<
LKI#(*/
7
/* Edition du rsultat */
if (POS=='1)
printf("La valeur recherche ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve la position %d. \n", VAL, POS);
printf("\n Tapez une touche pour continuer");
getch();
}

$2

Dans le pire des cas d'une recherche squentielle, il faut traverser tout le tableau avant de trouver la
valeur ou avant d'tre sr qu'une valeur ne se trouve pas dans le tableau.
Lors de la recherche dichotomique, on limine la moiti des lments du tableau chaque excution
de la boucle. Ainsi, la recherche se termine beaucoup plus rapidement.
La recherche dichotomique devient extrmement avantageuse pour la recherche dans de grands
tableaux (tris) : L'avantage de la recherche dichotomique par rapport la recherche squentielle
monte alors !
avec la grandeur du tableau trier.
%
$
Lors de la recherche dans un tableau de 1024 lments:
le pire des cas pour la recherche squentielle peut entraner 1024 excutions de la boucle.
le pire des cas pour la recherche dichotomique peut entraner 10 excutions de la boucle.
Lors de la recherche dans un tableau de 1 048 576 lments:
le pire des cas pour la recherche squentielle peut entraner 1 048 576 excutions de la boucle.
le pire des cas pour la recherche dichotomique peut entraner 20 excutions de la boucle.

?7

#include<stdio.h>
;
9%
#include<conio.h>
void main(){
{
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prnom: \n");
scanf("%s %s", NOM, PRENOM);
printf("\nBonjour %s %s !\n", NOM, PRENOM);
printf("Votre nom est compos de %d lettres.\n",
BK( <
LM6BK(
/* ou bien
printf("Votre nom est compos de %d lettres.\n",
" BK( LM6BK(
*/
printf("Tapez une touche pour continuer...");
getch();
7

?6

#include <stdio.h>
#include <conio.h>
void main()
{
char M1[30], M2[30], M3[30], M4[30], M5[30];
printf("Entrez 5 mots, spars par des espaces :\n");
"
- - - - (
(> (E (? (G
- - - - (G (? (E (> (
printf("Tapez une touche pour continuer...");
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
/* Dclarations */
char TXT[201]; /* chane donne
*/
int I,J; /* indices courants
*/
int L;
/* longueur de la chane
*/
int C;
/* compteur des lettres 'e' */
int AIDE; /* pour l'change des caractres */
/* Saisie des donnes */
printf("Entrez une ligne de texte (max.200 caractres) :\n");
gets(TXT); /* L'utilisation de scanf est impossible pour */
/* lire une phrase contenant un nombre variable de mots. */
12 " '
12 /" " !
12
:
/#
@)@T/U

" "

'
*#

12

A
21
R % 21

/<<

/
12 &
'#

21
A
A"

"S

A A
@)@T*U *<<
@)@T*U##A A '<<
/
"
"
W
* #
*$$
" @)@T*U
12
A A
12

" "

"

21

A A%
A

'

21

*#/$
"
12

* 0
*# F#/$

A
* F

" "
*<< F$$

@)@T*U
21
21

4
*56#@)@T*U
@)@T*U#@)@TFU
@)@TFU# *56
7
@)@
/* ou printf("%s\n",TXT); */
printf("Tapez une touche pour continuer...");
getch();
}

7<

21

?<

#include <stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
/* Dclarations */
char TXT[201]; /* chane donne
*/
int I,J,N;
/* indices courants */
/* Saisie des donnes */
printf("Entrez une ligne de texte (max.200 caractres) :\n");
9
@)@
12 6
12 '
12

A A
" "

,
* 0

" "

B#
*#
=
4

21
:

F
:

A A%

F 21
21

@)@
F#
* B
@)@T*U O# A A 4
@)@TFU # @)@T*U
F<<
7
*<<

7
12 @
"
"S
OO 21
@)@TFU#A A
/* Edition du rsultat */
@)@
printf("Tapez une touche pour continuer...");
getch();

?8

#include<stdio.h>
;
9%
#include<conio.h>
void main()
{
/* Dclarations */
char VERB[20]; /* chane contenant le verbe */
char AFFI[30]; /* chane pour l'affichage
*/
int L;
/* longueur de la chane
*/
/* Saisie des donnes */
printf("Verbe : ");
gets(VERB);
12 '
/#

A
A"9
A
0 &
A
36M
36M T/$>UO#A A 88 36M T/$ UO#A A
"'
A
"
0 &
4
12 '
"
36M T/$>U#A A

"

A% 21

12 ' C 9
%%% 21
VV*T U#A A
"
VV*
C
"
VV* 36M
"
VV*
VV*
% % %
78

A 21
9

%O

VV*T U#A A
"
VV*
"
VV* 36M
"
VV*
VV*
7
printf("Tapez une touche pour continuer...");
getch();
}

? 9

#include<stdio.h>
;
9%
#include<conio.h>
void main()
{
/* Dclarations */
char CH1[200], CH2[200]; /* chanes entres */
int RES; /* rsultat de la fonction strcmp */
printf("Introduisez la premire chane de caractres : "); gets(CH1);
printf("Introduisez la deuxime chane de caractres : "); gets(CH2);
12 '
" "
M6I #
M6I

"
' >

'

"9

"

21

'

' >

' >

'

M6I
-

:9"

'

' >

return 0;
}

#include<stdio.h>
;
9%
#include<conio.h>
void main(){
/* Dclarations */
char mot[30];
int n,i;
printf("Entrer un mot:");
scanf("%s",mot);
n=strlen(mot)'1;
//
#
=

T U##

T $ U

..

1>

<<
7
/*
11>
#$
4

12
<<

7=

"
12
T UO#

"

21
"
21
T $ U 88

##

1>

*/
if(mot[i]==mot[n'i])
printf("Le mot %s est palindrome \n",mot);
else
printf("Le mot %s n'est pas palindrome \n",mot);
printf("Tapez une touche pour continuer...");
getch();
}
69

# $% ! " #

+ ,

! &''()&'*'
!
!"# I

"
%

!*
! *- ! .
&
! #!+

. ?7
)

*+ ,
,

?
crire un programme se servant d'une fonction &,2%''% du type float pour afficher la
moyenne arithmtique de deux nombres rels entrs au clavier.

?
crire une fonction & ' et une fonction & 1 qui dterminent le minimum et le maximum de
deux nombres rels.
crire un programme se servant des fonctions & ' et & 1 pour dterminer le minimum et le
maximum de quatre nombres rels entrs au clavier.

?
crire la fonction @,- %`": deux paramtres ": et ": qui copie la chane de
caractres ": la fin de la chane ": sans utiliser de variable d'aide.
crire le programme principale permettant de saisir deux chanes et de faire appel la fonction
@,- `":.

?5
crire la fonction .
qui permet de vrifier si le nom en paramtre est palindrome ou
non. La fonction retourne A si c'est le cas et
sinon.
crire le programme principale permettant de saisir un nom et de faire appel la fonction
.
.

?7
crire un programme qui permet de remplir un tableau dentiers de dimension N (tel que N50) et
dafficher les nombres impairs.
'4 : Le programme doit comporter au minimum une fonction et deux procdures.

"
%

. ?7

#include<stdio.h>
#include<conio.h>
"

(KY6BB6

"

"

4
)<Y 1>
7
void main()
{
/* Variables locales */
float A,B;
/* Traitements */
printf("Introduire deux nombres : ");
scanf("%f %f", &A, &B);
printf("La moyenne arithmtique de %f et %f est - \n",
A, B, (KY6BB6
printf("Tapez une touche pour continuer");
getch();
}

);

#include <stdio.h>
#include<conio.h>
&

(*B

&

&

&

&

4
) Y
)
Y
7
&

( )

4
) Y
)
Y
7
0
"
4
/* Variables locales */
double A,B,C,D;
/* Traitements */
printf("Introduire 4 rels : ");
scanf("%lf %lf %lf %lf", &A, &B, &C, &D);
printf("Le minimum des 4 rels est - \n",
(*B (*B
printf("Le maximum des 4 rels est - \n",
( ) ( )
printf("Tapez une touche pour continuer");
getch();
7

(*B ' 5

);

( ) ' 5

);

#include<stdio.h>
#include<conio.h>

#include<string.h>
0
4
=
=
'

FKN@6Z'

"

2'

2'
12
' <<
2' > 12

"

2' >

"

0
4
'

' > W

FKN@6Z'

"

21

"

#
4

4
2'
# 2' >
' <<
' ><<

'

T <

U#' >T U

7
2'

#A

12

"

"S

'

21

'

< >U#A

0
4

"

>
'
' >
> <<

#
>#

21

2'

"
char Chaine1[30];
char Chaine2[30];
printf("Entrer chaine n1:");
gets(Chaine1);
printf("Entrer chaine n2:");
gets(Chaine2);
AJOUTE_CH(Chaine1,Chaine2);
printf("La nouvelle est chaine 1 est :%s",Chaine1);

?5

#include <stdio.h>
#include<conio.h>
#include<string.h>
L"

"

/ B

TU

4
int i,n;
n = strlen(LeNom)'1;
i=0;
while((LeNom[i]!= LeNom[n'i+1]) && (i<=n/2))
{
i++;
}
if(LeNom[i]!= LeNom[n'i+1])
return 0;
else
return 1;
7
0
"
4
/* Variable locale */
char nom[50];
/* Traitements */
printf("Introduire votre nom : ");
scanf("%s", nom);
if( L"
==0)
printf("Le nom n'est pas palindrome");
else
printf("Le nom est palindrome");
printf("Tapez une touche pour continuer");
getch();
7
65

2' >

?7

#include<stdio.h>
#include<conio.h>
@"

@"&

"

12

"

"

"&

"

21

4
int Taille;
do
{
printf("Taille du tableau (N<=50) =");
scanf("%d",&Taille);
}while(Taille<0 || Taille>50);
return Taille;
7
0
4

"9

@"

2@

12

int i;
for(i=0;i<Taille;i++)
{
printf("Elment n %d :",i+1);
scanf("%d",&TAB[i]);
}
7
0
4

"9

@"

TU

int i;
for(i=0;i<Taille;i++)
{
if(TAB[i] % 2 !=0)
printf("% d ",TAB[i]);
}
7
0
4

"
int N;
int T[50];
N=TailleTableau();
Remplissage(N,&T);
Affichage(N,T);
printf("Tapez une touche pour continuer...");
getch();

67

"9

"&

"

21

! "#$
%
,

)!

&'

)* *+

%1 &%'
5" =5

>

acrire un programme qui permet de saisir deux chaines CH1 et CH2, de les concatner ensembles et dafficher la
nouvelle chaine CH3 obtenue.
%

$
'()TRAVAILLER PLUS
'*)GAGNER PLUS
'+)TRAVAILLER PLUSGAGNER PLUS

5# =

>

acrire un programme qui permet de saisir deux chaines dates

On suppose que ces dernires sont deux dates valides et que

et

de la forme

Dterminer et afficher le nombre de jours de diffrence entre ces deux dates.

%

$
()19/12/2008
*)05/06/2009
Le nombre de jours de diffrence est : 168 jours

'4 $ Les deux dates sont de types char de 10 caractres; pour extraire le jour, le mois et lanne vous devez employer la
fonction prdfinie
de la bibliothque (stdlib.h) qui permet de convertir une chaine en entier.
int

(char *chane) convertit la chane en entier

$
printf("ENTRER UN TEXTE: ");
gets(texte);
n = atoi(texte) ;
printf("%d",n); /* affiche 12 si texte vaut "12" */

56 =8

>

acrire un programme qui lit deux chaines CH1 et CH2, de compter et dafficher le nombre
doccurrences de CH2 dans CH1.
%

$
": Ptre bon en algorithmique est quivalent tre bon en atelier de programmation.
": Ptre bon
Le nombre doccurrences est : 2

66

"

B
&

$
&

%
? =5 >
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main(){
char ch1[30];
char ch2[30];
char ch3[60];
int i,j,LongeurCh1,LongeurCh2;
printf("Chaine 1=");gets(ch1);
printf("Chaine 2=");gets(ch2);
LongeurCh1=strlen(ch1);
LongeurCh2=strlen(ch2);
11
"
"
for(i=0;i<LongeurCh1;i++)
ch3[i]=ch1[i];
11
"
"
for(j=0;j<LongeurCh2;j++)
ch3[j+i]=ch2[j];
11
"
"
ch3[j+i]='\0';
printf("\n La nouvelle chaine : %s \n",ch3);
printf("Tapez une touche pour continuer...");
getch();

}
%
? =5 >
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
[ B & F
5 (
&F
=
(
4
"
,
"
E ,
"
G ,
"
J ,
"
\ ,
"
,
"
> ,
"
> ,

(
&F
&F
&F
&F
&F
&F
&F

#E
#E
#E
#E
#E
#E
#E
&F
&F

"
"
"
"

?
H
Q

,
,
,
,

&F
&F
&F
&F

4
&
&
&
&
&
&
&
- ?
#>Q

#>\
&
#E &
#E &
#E &
#E &

"D
"D
"D
"D
"D
"D
"D
##

"D
"D
"D
"D
"D

7
&F
7

void main()4
char Date1[10];
char Date2[10];
char C1_JJ[3],C1_MM[3],C1_AAAA[5];
char C2_JJ[3],C2_MM[3],C2_AAAA[5];
int JJ1,MM1,AAAA1;
int JJ2,MM2,AAAA2;
int i,j,nbAnnee,NombreDeJours;
printf("Date1=");gets(Date1);
printf("Date2=");gets(Date2);
116
"
F
A" :
5"
C1_JJ[0]=Date1[0];C1_JJ[1]=Date1[1];C1_JJ[2]='\0';
C1_MM[0]=Date1[3];C1_MM[1]=Date1[4];C1_MM[2]='\0';
C1_AAAA[0]=Date1[6];C1_AAAA[1]=Date1[7];
C1_AAAA[2]=Date1[8];C1_AAAA[3]=Date1[9];C1_AAAA[4]='\0';
116
"
F
A" :
5" >
C2_JJ[0]=Date2[0];C2_JJ[1]=Date2[1];C2_JJ[2]='\0';
C2_MM[0]=Date2[3];C2_MM[1]=Date2[4];C2_MM[2]='\0';
C2_AAAA[0]=Date2[6];C2_AAAA[1]=Date2[7];
C2_AAAA[2]=Date2[8];C2_AAAA[3]=Date2[9];C2_AAAA[4]='\0';
11' 0
JJ1=atoi(C1_JJ);MM1=atoi(C1_MM);AAAA1=atoi(C1_AAAA);
JJ2=atoi(C2_JJ);MM2=atoi(C2_MM);AAAA2=atoi(C2_AAAA);
nbAnnee=AAAA2'AAAA1;
NombreDeJours=0;
if (AAAA2==AAAA1)
{
if (MM1==MM2)
NombreDeJours=JJ2'JJ1;
else
{
for(i=MM1+1;i<=MM2'1;i++)
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,AAAA1);
NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1,AAAA1)'JJ1;
}
}
else
{
11 & C
0"
C ! AW "
A" :
5"
for(i=MM1+1;i<=12;i++)
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,AAAA1);
11 & C
:
<
>$
if (nbAnnee!=1)
{
for(j=AAAA1+1;j<=AAAA2'1;j++)
{
for(i=1;i<=12;i++)
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,j);
}
}
11 & C
C" 0
C ! AW
: :
5" >
for(i=MM2'1;i>=1;i'')
NombreDeJours=NombreDeJours+GetNombreJoursDuMois(i,AAAA2);
NombreDeJours=NombreDeJours+JJ2+GetNombreJoursDuMois(MM1,AAAA1)'JJ1;
}

printf("\n Le nombre de jours de diffrences est %d \n",NombreDeJours);

printf("Tapez une touche pour continuer...");
getch();

6<

%
? =8 >
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main(){
char ch1[100];
char ch2[100];
int i,j;
int LongeurCh1,LongeurCh2,nbOcc;
printf("Entrer ch1:");gets(ch1);
printf("Entrer ch2:");gets(ch2);
LongeurCh1=strlen(ch1);
LongeurCh2=strlen(ch2);
nbOcc=0;
i=0;
=
/ 9
'
4
C#
=
T UO# >TCU ..
<<
=

T U##

>TCU

..

'

'

..

C /

<<
C<<
7
C##/

9
' >
&K <<

7
printf("\n Le nombre d'occurrences de %s dans %s est :
%d\n",ch2,ch1,nbOcc);
printf("Tapez une touche pour continuer");
getch();

68

' >

! "#$
.
,

)!

&'

)* *+

%1 &%'
5" =5

>

acrire une fonction '!" & E

qui permet de compter le nombre des lettres en majuscules.

Ecrire le programme principal qui permet de saisir une chaine CH, et dafficher le rsultat lcran.
%

$
') , aculte des (ciences @uridiques %conomiques et de

estion de @endouba,

)5

5# =6

>

acrire un programme qui permet de remplir un tableau contenant des notes (avec 0 note20),
dont la dimension du tableau est 5n30. On suppose que les notes ont le mme coefficient.
De calculer la moyenne et dafficher le rsultat lcran.
%

$
5
0

*7

6* 7

* 7
3

*7
4

( "" 3

56 = 9

>

acrire un programme qui permet de saisir deux chaines CH1 et CH2, dextraire de ces dernires que
les chiffres, deffectuer la somme des deux nombres et enfin afficher le rsultat lcran.
%

$
'() ,'7E
'*) ,

2 ,

6c,

-( ) .*+/
-* ) +*

La somme des deux nombres est : 5268

'4 $ vous devez employer la fonction prdfinie
de la bibliothque (stdlib.h) qui permet de
convertir une chaine en entier.
int
(char *chane)
convertit la chane en entier
$

ch="12" ;
nb = atoi(ch) ; /* nb=12 */

"

B
&

$
&

C
D

%
? =5 >
#include <stdio.h>
#include <conio.h>
;
9%
int NbCarMajus(char ch[])
{
int i,n,occ;
n=strlen(ch);
occ=0; /* initialisation du compteur des majuscules */
for(i=0;i<n;i++)
{
if((ch[i]>='A') && (ch[i]<='Z'))
occ++; /* incrmentation du compteur */
}
return occ;
}
void main()
{
char ch[50];
printf("Taper une chaine:");gets(ch);
printf("Le nombre des lettres majuscules : %d\n",NbCarMajus(ch));
printf("Pour sortir frapper une touche ");
getch();
}
%
? =6 >
#include <stdio.h>
#include <conio.h>
int TailleTab()
{
int taille;
do{
printf("Entrer la taille du tableau:");
scanf("%d",&taille);
}while((taille<5) || (taille>30));
return taille;
}
void Remplissage(int *TAB,int n)
{
int i;
float note;
for(i=0;i<n;i++)
{
do{
printf("Entre la note n
%d:",i+1);
scanf("%d",&note);
}while((note<0) || (note>20));
TAB[i]=note;
}
}
float calculer(int TAB[],int n)
{
int i;
float som;
for(i=0;i<n;i++)
som+=TAB[i];
return som/n;
}

void main()
{
int n;
float moy;
int T[100];
n=TailleTab(); /* Affectation de la taille du tableau */
Remplissage(&T,n); /* remplissage du tableau */
moy=calculer(T,n); /* calcul et affectation de la moyenne */
printf("La moyenne est : %f\n",moy); /* Affichage de la moyenne */
printf("Pour sortir frapper une touche ");
getch();
}
%

? = 9

#include
#include
#include
#include

>

<stdio.h>
<conio.h>
<string.h>
<stdlib.h>

int extraire(char ch[])

{
int i,j;
char nbr[];
int n = strlen(ch); /* taille de la chaine */
j='1;
for(int i=0;i<n;i++) /* parcours de la chaine */
{
if(ch[i]>='0' && (ch[i]<='9'))
{
j++;
nbr[j]=ch[i]; /* ajout du nombre dans la nouvelle chaine nbr */
}
}
return atoi(nbr); /* convertion du nombre en numrique */
}
int somme(int nb1,int nb2)
{
return nb1+nb2;
}
void main()
{
char ch1[100];
char ch2[100];
int som;
printf("Entrer chaine ch1=");gets(ch1);
printf("Entrer chaine ch2=");gets(ch2);
som=somme(extraire(ch1),extraire(ch2)); /* appel des deux fonctions */
printf("La somme est : %d\n",som); /* Affichage de la somme */
printf("Pour sortir frapper une touche ");
getch();
}

ibliographie

2me dition, septembre 2004 Editions Dunod

4
d* c
D#
)
&* +
)
#4
,
Norme ANSI, 2me dition, 2004

"
)
W
5
# notions de programmation acquises par la pratique
2me dition, Avril 2002 Editions Dunod
.

2A

&

#K. e
#
!
!
4 me dition, Mars 2005 Editions Dunod
#
!
1 re dition, juin 2005 Editions O'Reilly