Cours Initiation au Langage C

Initiation au Langage C

Alexandre Meslé

16 juin 2009

Table des matières

Chapitre 1

Un programme exécutable est une suite d’instructions exécutée par le processeur. Ces instructions sont très difficile à comprendre, si par exemple, vous ouvrez avec un éditeur de texte (notepad, emacs, etc) un fichier exécutable, vous verrez s’afficher un charabia incompréhensible :

00000000

0000001f

0000003e

0000005d

0000007c

0000009b

000000ba

000000d9

000000f8

00000117

00000136

00000155

00000174

00000193

000001b2

000001d1

000001f0

0000020f

0000022e

0000024d

0000026c

0000028b

000002aa

000002c9

000002e8

00000307

Il n’est pas envisageable de créer des programmes en écrivant des suites de chiffres et de lettres. Nous allons donc utiliser des langages de programmation pour ce faire.

Un programme C est un ensemble d’instructions qui se saisit dans un fichier .c à l’aide d’un éditeur (ex. : Notepad), ce type de fichier s’appelle une source. Les instructions qui y sont écrites s’appellent du code ou encore le code source. Un compilateur est un logiciel qui lit le code source et le convertit en un code exécutable, c’est-à-dire un ensemble d’instructions compréhensible par le processeur. La compilation d’une source se fait en deux étapes : la compilation proprement dite et le linkage. On utilise en général le terme compilation en englobant les deux étapes précédemment citées.

–    La compilation à proprement parler produit un fichier objet, dont l’extension est .obj.

–    Les sources peuventêtre réparties dans plusieurs fichiers, ceux-ci doivent tous être compilés séparément.

Ensuite, le linkage des différents fichiers objets est assemblage produisant un exécutable .exe. Certains environnement de développement servent d’éditeur, et prennent en charge la compilation et le linkage (eclipse, dev-C++).

Allez sur , cliquez sur télécharger. Installez Dev-C++. Ouvrez un nouveau fichier source. Copiez-collez le code cidessous dans l’éditeur :

#include<stdio .h>

#include<conio .h>

int main()

{ printf (”Hello World!\n” );

getch ();

return 0;

}

Sauvegardez ce fichier sous le nom helloWorld.c. Dans le menu Exécuter, cliquez sur Compiler. Remarquez que la compilation a produit un fichier . Vous avez deux fa¸cons de l’exécuter : – double-cliquez directement sur – Dans le menu Exécuter, cliquez sur exécuter.

Importation des bibliothèques

#include<stdio .h>

#include<conio .h>

Selon ce que l’on souhaite faire dans notre programme, on peut avoir besoin de différentes fonctions.

Celles-ci sont disponibles dans des bibliothèques. Par exemple :

–    stdio.h propose des fonctions de saisie et d’affichage

–    conio.h propose d’autre fonctions d’entrées-sorties

Corps du programme

int main()

{

                             printf (”Hello world          ! ” );

getch ();

return 0;

}

On place dans les accolades du main les instructions que l’on souhaite voir s’exécuter :

int main()

{

<instructionsAExecuter>return 0;

}

Remarquez que chaque ligne se termine par un points-virgule. Pour afficher une variable de type aphanumérique en C, on utilise printf(<valeur à afficher>);. Les littéraux de type alphanumériques en C s’écrivent entre doubles quotes. getch(); nous sert à suspendre l’exécution du programme jusqu’à ce que l’utilisateur appuie sur une touche.

Un commentaire est une séquence de caractères ignorée par le compilateur, on s’en sert pour expliquer des portions de code. Alors ayez une pensée pour les pauvres programmeurs qui vont reprendre votre code après vous, le pauvre correcteur qui va essayer de comprendre votre pensée profonde, ou bien plus simplement à vous-même au bout de six mois, quand vous aurez complètement oublié ce que vous aviez dans la tête en codant. On délimite un commentaire par /* et */. Par exemple,

int main()

{

/?

Ceci     est       un commentaire       :

L ’ instruction ci?dessous affiche ’ ’ Hello morld ! ’ ’ Ces phrases sont ignorées par le compilateur .

?/ printf (”Hello world !\n” );

return 0;

}

Une variable est un emplacement de la mémoire dans lequel est stockée une valeur. Chaque variable porte une nom et c’est ce nom qui sert à identifié l’emplacement de la mémoire représenté par cette variable. Pour utiliser une variable, la première étape est la déclaration.

Déclarer une variable, c’est prévenir le compilateur qu’un nom va être utilisé pour désigner un emplacement de la mémoire. En C, on déclare les variables juste après l’accolade suivant main() (pour le moment). On place les instructions à exécuter à la suite de la déclaration de variables.

main()

{

<declaration de variables>

<instructions a executer>

}

Nous ne travaillerons pour le moment que sur les variables de type numérique entier. Le type qui y correspond, en C, est int. On déclare les variables entières de la manière suivante :

int<var 1 >, <var 2 >,                         . . . , <var n >;

Cette instruction déclare les variables var 1, var 2, , var n de type entier. Par exemple,

#include<stdio .h>

int main()

{

int variable1 , variable2 ; int autrevariable1 , autrevariable2 ; return 0;

}

On appelle bloc le contenu des accolades du main.

Si on souhaite affecter à la variable v une valeur, on utilise l’opérateur =. Par exemple,

int main()

{

int v ; v = 5;

return 0;

}

Les opérations arihmétiques disponibles sont l’addition (+), la soustraction (-), la multiplication (*), la division entière dans l’ensemble des entiers relatifs (quotient : /, reste : %).

int main()

{

int v , w, z ; v = 5; w = v + 1;

z = v + w / 2; v = z % 3; v = v ? 2; return 0;

}

Traduisons en C l’instruction Saisir <variable> que nous avons vu en algorithmique. Pour récupérer la saisie d’un utilisateur et la placer dans une variable <variable>, on utilise l’instruction suivante : scanf (”%d” , &<variable >);

scanf suspend l’exécution du programme jusqu’à ce que l’utilisateur ait saisi une valeur et pressé la touche return. La valeur saisie est alors affetée à la variable <variable>. N’oubliez surtout pas le &, sinon des choses absurdes pourraient se produire!

Traduisons maintenant l’instruction Afficher variable en C. Cette instruction permet d’afficher la valeur d’une variable.

printf (”%d” , <variable >);

Cette instruction affiche la valeur contenue dans la variable variable (ne vous laissez pas impressionner par l’apparente complexité de cette instruction!). Nous avons étendu, en algorithmique, l’instruction Afficher en intercalant des valeurs de variables entre les messages affichés. Il est possible de faire de même en C :

printf (”la                valeur de la                 variable v est %d” , v );

Cette instruction substitue à %d la valeur de la variable v. Il est possible de l’étendre à volonté :

printf (” les             valeurs      des                     variables x , y et z sont %d, %d et %d” , x , y ,                      z );

Cette instruction substitue à chaque %d les valeurs des trois variables x, y et z. Par exemple, le programme suivant

#include<stdio .h>

int main()

{

int a , b, c ; a = 1; b = 2; c = 3

                                                                                             ”c est %d. ” , a , b,            c );

return 0;

}

affiche

La valeur de a est 1, celle de b est 2, et celle de c est 3.

Trois types de base servent à représenter les entiers :

nom	taille (t)	nombre de valeurs (28t)	chaˆ?ne de format
short	1 octet	28 valeurs	%hd
int	2 octets	216 valeurs	%d
long	4 octets	232 valeurs	%ld

Entiers non signés

Par défaut, les entiers permettent de stocker des valeurs de signe quelconque. Si on préfixe un type entier par unsigned, on le restreint à des valeurs uniquement positives. Dans ce cas, on a

nom	taille (t)	nombre de valeurs (28t)	valeur min	valeur max	format
unsigned short	1 octet	28 valeurs	0	28 ? 1	%hu
unsigned int	2 octets	216 valeurs	0	216 ? 1	%u
unsigned long	4 octets	232 valeurs	0	232 ? 1	%lu

La plage de valeur d’un unsigned short, encodée en binaire, est

{0000 0000,0000 0001,0000 0010,0000 0011, ,1111 1110,1111 1111}

Entiers signés

Si par contre les données sont signées, on a comme plage de valeurs

nom	taille (t)	nombre de valeurs (28t)	plus petite valeur	plus grande valeur
short	1 octet	28 valeurs	?27	27 ? 1
int	2 octets	216 valeurs	?215	215 ? 1
long	4 octets	232 valeurs	?231	231 ? 1

La plage de valeur d’un short, encodée en binaire, est aussi

{0000 0000,0000 0001,0000 0010,0000 0011, ,1111 1110,1111 1111}

Même si les codages sont les mêmes, la signification ne l’est pas, les nombres entiers positifs sont codés sur l’intervalle :

Et les nombres négatifs sur l’intervalle

{1000 0000,1000 0001,1000 0010,1000 0011, ,1111 1100,1111 1101,1111 1110,1111 1111}

Les nombres négatifs sont disposés du plus grand jusqu’au plus petit, l’intervalle précédent code les valeurs :

Les opérations arithmétiques sont exécutées assez bêtement, si vous calculez 0111 1111 + 0000 0001, ce qui correspond à (2⁷ ? 1) + 1, le résultat mathématique est 2⁷, ce qui se code 1000 0000, ce qui est le codage de ?2⁷. Soyez donc attentifs, en cas de dépassement de capacité d’un nombre entier, vous vous retrouverez avec des nombres qui ne veulent rien dire. Si vous souhaitez faire des calculs sur des réels, un type flottant sera davantage adapté.

Les flottants servent à représenter les réels. Leur nom vient du fait qu’on les représente de fa¸con scientifique : un nombre décimal (à virgule) muni d’un exposant (un décalage de la virgule). Trois types de base servent à représenter les flottants :

nom	taille	chaˆ?ne de format
float	4 octet	%f
double	8 octets	%f
long double	10 octets	%Lf

Il est conventionel d’écrire des littéraux flottants avec un point, par exemple l’approximation à 10^?2 près de ? s’ecrit 3.14. Il est aussi possible d’utiliser la notation scientifique, par exemple le décimal 1 000 s’écrit 1e3, à savoir 1.10³.Nous nous limiterons à la description du type float, les autres types obéissent à des règles similaires.

Représentation en mémoire d’un float

Le codage d’un nombre de type float (32 bits) est découpé en trois parties :

partie	taille
le bit de signe	1 bit
l’exposant	8 bits
la mantisse	23 bits le plus grand flottant est , donc le plus petit est . Un char sert à représenter le code ASCII d’un caractère, il est donc codé sur 1 octet. Il est possible d’affecter à une telle variable toute valeur du code ASCII entourée de simples quotes. Par exemple, l’affectation suivante place dans a le code ASCII du caractère ’B’. char a ; a = ’B’ ; De la même fac¸on que l’on code des nombres entiers sur 1 octet avec un short, un char contient avant tout un nombre codé sur 1 octet. Pour afficher le caractère corrspondant au code ASCII stocké dans un char, on utilise la chaˆ?ne de format %c, et pour afficher le code ASCII lui-même on utilise la chaˆ?ne de format %d. Si on souhaite manipuler des char comme des nombres, le type unsigned char permet de coder des valeurs positives sur 1 octet, alors que char code aussi bien des nombres positifs que négatifs. Par conséquent, les caractères de code ASCII 255 et 128 correspondent aux unsigned char de valeurs 255 et 128 et aux char de valeurs ?1 et ?128. Une constante est une valeur portant un nom, contrairement aux variables, elles ne sont pas modifiables. Les constantes en C sont non typées, on les définit dans l’entête de la source, juste en dessous des #include. La syntaxe est #define <NOM CONSTANTE> <valeurConstante>, par exemple #define N 25 définit une constante N qui a la valeur 25. Au début de la compilation, un programme appelé préprocesseur effectue un rechercher/remplacer et substitue à toutes les occurences de <NOM CONSTANTE> la valeur <valeurConstante>. Faites donc très attention au fait que dans l’exemple présent, le préprocesseur va remplacer tous les N par des 25. Donc si une variable s’appelle N, le préprocesseur va le remplacer par un 25! Si par exemple vous écrivez #include<stdio .h> #define N 25 int main() { int N; N = 12; printf (”N = %d” , N); return 0; } #include<stdio .h> #define N 25 int main() { int 25; 25 = 12; printf (”N = %d” , 25); return 0; } Vous remarquez que les seules exceptions sont les valeurs délimitées par des ". Opérandes et arité Lorsque vous effectuez une opération, par exemple 3 + 4, le + est un opérateur, 3 et 4 sont des opérandes. Si l’opérateur s’applique à 2 opérandes, on dit qu’il s’agit d’un opérateur binaire, ou bien d’arité 2. Un opérateur d’arité 1, dit aussi unaire, s’applique à un seul opérande, par exemple -x, le x est l’opérande et le - unaire est l’opérateur qui, appliqué à x, nous donne l’opposé de celui-ci, c’est-à-dire le nombre qu’il faut additionner à x pour obtenir 0. Il ne faut pas le confondre avec le - binaire, qui appliqué à x et y, additionne à x l’opposé de y. En C, les opérateurs sont unaires ou binaires, et il existe un seul opérateur ternaire. Associativité Si vous écrivez une expression de la forme a + b + c, ou` a, b et c sont des variables entières, vous appliquez deux fois l’opérateur binaire + pour calculer la somme de 3 nombres a, b et c. Dans quel ordre ces opérations sont-elles effectuées? Est-ce que l’on a (a + b) + c ou a + (b + c)? Cela importe peu, car le + entier est associatif, ce qui signifie qu’il est possible de modifier le parenthèsage d’une somme d’entiers sans en changer le résultat. Attention : l’associativité est une rareté! Peu d’opérateurs sont associatifs, une bonne connaissance des règles sur les priorités et le parenthèsage par défaut est donc requise. Formes préfixes, postfixes, infixes Priorités Les règles des priorités en C sont nombreuses et complexes, nous ne ferons ici que les esquisser. Nous appelerons parenthèsage implicite le parenthèsage adopté par défaut par le C, c’est à dire l’ordre dans lequel il effectue les opérations. La première règle à retenir est qu’un opérateur unaire est toujours prioritaire sur un opérateur binaire. Négation arithmétique La négation arithmétique est l’opérateur - qui à une opérande x, associe l’opposé de x, c’est-à-dire le nombre qu’il faut additionner à x pour obtenir 0. Négation binaire La négation binaire ~ agit directement sur les bits de son opérande, tous les bits à 0 deviennent 1, et vice-versa. Par exemple, ~127 (tous les bits à 1 sauf le premier) est égal à 128 (le premier bit à 1 et tous les autres à 0). Priorités Tous les opérateurs unaires sont de priorité équivalente, le parenthèsage implicite est fait le plus à droite possible, on dit que ces opérateurs sont associatifs à droite. Par exemple, le parenthèsage implicite de l’expression ~-~i est ~(-(~i)). C’est plutôt logique : si vous parvenez à placer les parenthèses différement, prevenez-moi parce que je ne vois pas comment faire Opérations de décalages de bits L’opération a >> 1 effectue un décalage des bits de la représentation binaire de a vers la droite. Tous les bits sont décalés d’un cran vers la droite, le dernier bit disparaˆ?t, le premier prend la valeur 0. L’opération a << 1 effectue un décalage des bits de la représentation binaire de a vers la gauche. Tous les bits sont décalés d’un cran vers la gauche, le premier bit disparaˆ?t et le dernier devient 0. Par exemple, 32 << 2 associe à 0010 0000 << 2 la valeur dont la représentation binaire 1000 0000 et 32 >> 3 associe à 0010 0000 >> 3 la valeur dont la représentation binaire 0000 0100. Opérations logiques sur la représentation binaire 60 & 15 donne 12, autrement formulé 0011 1100 ET 0000 1111 = 0000 1100. L’opérateur | associe à deux opérandes le OU logique de leurs représentations binaires par exemple 60 | 15 donne 63, autrement formulé 0011 1100 OU 0000 1111 = 0011 1111. L’opérateur ^ associe à deux opérandes le OU exclusif logique de leurs représentations binaires par exemple 60 ^ 15 donne 51, autrement formulé 0011 1100 OU EXCLUSIF 0000 1111 = 0011 0011. Deux ^ successifs s’annulent, en d’autres termes a^b^b=a. Affectation Ne vous en déplaise, le = est bien un opérateur binaire. Celui-ci affecte à l’opérande de gauche (appelée Lvalue par le compilateur), qui doit être une variable, une valeur calculée à l’aide d’une expression, qui est l’opérande de droite. Attention, il est possible d’effectuer une affectation pendant l’évaluation d’une expression. Par exemple, a = b + (c = 3); Cette expression affecte à c la valeur 3, puis affecte à a la valeur b + c. Priorités Tous les opérateurs binaires ne sont pas de priorités équivalentes. Ceux de priorité la plus forte sont les opérateurs arithmétiques (*, /, %, +, -), puis les opérateus de décalage de bit (<<, >>), les opérateurs de bit (&, ^, |), et enfin l’affectation =. Représentons dans une tableau les opérateurs en fonction de leur priorité, pla¸cons les plus prioritaire en haut et les moins prioritaires en bas. Parmi les opérateurs arithmétiques, les multiplications et divisions sont prioritaires sur les sommes et différence : noms opérateurs produit *, /, % sommes +, - Les deux opérateurs de décalage sont de priorité équivalente : noms opérateurs décalage binaire >>, << L’opérateur & est assimilé à un produit, | à une somme. Donc , & est prioritaire sur |. Comme ^ se trouve entre les deux, on a noms opérateurs ET binaire & ^ OU binaire | Il ne nous reste plus qu’à assembler les tableaux : noms opérateurs produit *, /, % somme +, - décalage binaire >>, << ET binaire & OU Exlusif binaire ^ OU binaire | affectation = Quand deux opérateurs sont de même priorité le parenthèsage implicite est fait le plus à gauche possible, on dit que ces opérateurs sont associatifs à gauche. Par exemple, le parenthèsage implicite de l’expression a - b - c est (a ? b) ? c et certainement pas a - (b - c). Ayez donc cela en tête lorsque vous manipulez des opérateurs non associatifs! La seule exception est le =, qui est associatif à droite. Par exemple, a = b = c ; se décompose en b = c suivi de a = b. Le C étant un langage de paresseux, tout à été fait pour que les programmeurs aient le moins de caractères possible à saisir. Je vous préviens : j’ai placé ce chapitre pour que soyez capable de décrypter la bouillie que pondent certains programmeurs, pas pour que vous les imitiez! Alors vous allez me faire le plaisir de faire usage des formes contractées avec parcimonie, n’oubliez pas qu’il est très important que votre code soit lisible. Unaires Il est possible d’incrémenter (augmenter de 1) la valeur d’une variable i en écrivant i++, ou bien ++i. De la même fa¸con on peut décrémenter (diminuer de 1) i en écrivant i-- (forme postfixe), ou bien --i (forme préfixe). Vous pouvez décider d’incrémenter (ou de décrémenter) la valeur d’une variable pendant un calcul, par exemple, a = 1; b = (a++) + a ; a = 1; b = (++a) + a ; On opère une pré-incrémentation, ++a donne lieu à une incrémentation avant l’évaluation de a, donc la valeur 4 est affectée à b. On peut de fa¸con analogue effectuer une pré-decrémentation ou a postdecrémentation. Soyez très attentifs au fait que ce code n’est pas portable, il existe des compilateurs qui évaluent les opérandes dans le désordre ou diffèrent les incrémentations, donnant ainsi des résultats autres que les résultats théoriques exposés précédement. Vous n’utiliserez donc les incrémentation et decrémentation contractées que lorsque vous serez certain que l’ordre d’évaluation des opérandes ne pourra pas influer sur le résultat. Binaires Toutes les affectations de la forme variable = variable operateurBinaire expression peuvent être contractées sous la forme variable operateurBinaire= expression. Par exemple, avant après a = a + b a += b a = a - b a -= b a = a * b a *= b a = a / b a /= b a = a % b a %= b a = a & b a &= b a = a ^ b a ^= b a = a | b a |= b Vous vous douterez que l’égalité ne peut pas être contractée Le fonctionnement par défaut Nous ordonnons de fa¸con grossière les types de la fa¸con suivante : long double > double > float > unsigned long > long > unsigned int > int > unsigned short > short > char. Dans un calcul ou` les opérandes sont de types hétérogènes, l’opérande dont le type T est de niveau le plus élévé (conformément à l’ordre énoncé ci-avant) est sélectionné et l’autre est converti dans le type T. Le problème Il se peut cependant que dans un calcul, cela ne convienne pas. Si par exemple, vous souhaitez calculer l’inverse d’un nombre entier x, et que vous codez int i = 4; printf (”L ’ inverse de %d est %d” , i , 1/ i ); int i = 4; printf (”L ’ inverse de %d est %f \n” , i , 1/ i ); se révèlera aussi d’une inefficacité notoire : non seulement vous vous taperez un warning, mais en plus printf lira un entier en croyant que c’est un flottant. Alors comment on se sort de là? Ici la bidouille est simple, il suffit d’écrire le 1 avec un point : int i = 4; printf (”L ’ inverse de %d est %f \n” , i ,                              1./ i ); Le compilateur, voyant un opérande de type flottant, convertit lors du calcul l’autre opérande, i, en flottant. De ce fait, c’est une division flottante et non entière qui est effectuée. Allons plus loin : comment faire pour appliquer une division flottante à deux entiers? Par exemple : int i = 4 ,                j= 5; printf (”Le quotient de %d et %d est %f \n” , i ,                                    j ,     i / j ); Cette fois-ci c’est inextricable, vous pouvez placer des points ou` vous voudrez, vous n’arriverez pas à vous débarasser du warning et ce programme persistera à vous dire que ce quotient est -0.000000! Une solution particulièrement crade serait de recopier i et j dans des variables flottantes avant de faire la division, une autre méthode de bourrin est de calculer (i + 0.)/j. Mais j’espère que vous réalisez que seuls les boeufs procèdent de la sorte. Le cast Le seul moyen de vous sortir de là est d’effectuer un cast, c’est à dire une conversion de type sur commande. On caste en pla¸cant entre parenthèse le type dans lequel on veut convertir juste avant l’opérande que l’on veut convertir. Par exemple, int i = 4 ,                j= 5; printf (”Le quotient de %d et %d est %f \n” , i ,                                    j ,      ( float ) i / j ); int i = 4 ,                j= 5; printf (”Le quotient de %d et %d est %f \n” , i ,                                    j ,       ( float )( i / j )); Vous constaterez très rapidement que c’est une alternative peu intelligente. En effet, le résulat est flottant, mais comme la division a lieu avant toute conversion, c’est le résultat d’une division entière qui est converti en flottant, vous avez donc le même résultat que si vous n’aviez pas du tout casté. Ajoutons le cast au tableau des priorités de nos opérateurs : noms opérateurs opérateurs unaires cast, -, ~, ++, -- produit *, /, % somme +, - décalage binaire >>, << ET binaire & OU Exlusif binaire ^ OU binaire | affectation = On appelle traitement conditionnel un portion de code qui n’est pas exécutée systématiquement, c’est à dire des instructions dont l’exécution est conditionnée par le succès d’un test. Principe En algorithmique un traitement conditionnel se rédige de la sorte : siconditionalors               instructions fin Si la condition est vérifiée, alors les instructions sont exécutées, sinon, elles ne sont pas exécutées. L’exécution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors et le finSi. Un traitement conditionnel se code de la sorte : if (<condition >) { <instructions > } Notez bien qu’il n’y a pas de point-virgule après la parenthèse du if. Comparaisons La formulation d’une condition se fait souvent à l’aide des opérateurs de comparaison. Les opérateurs de comparaison disponibles sont : –  == : égalité –  != : non-égalité –  <, <= : inférieur à, respectivement strict et large –  >, >= : supérieur à, respectivement strict et large #include<stdio .h> int main() { int i ; printf (” Saisissez une valeur : ” ); scanf (”%d” , &i ); if ( i == 0) {                                                  printf (”Vous avez          saisi        une valeur         nulle \n. ” ); } printf (”Adios             ! ” ); return 0; } Si au moment ou` le test i == 0 est évalué, la valeur de i est bien 0, alors le test sera vérifié et l’instruction printf("Vous avez saisi une valeur nulle\n.") sera bien exécutée. Si le test n’est pas vérifié, les instructions du bloc suivant le if sont ignorées. Si Alors Sinon Il existe une forme étendue de traitement conditionnel, on la note en algorithmique de la fac¸on suivante : siconditionalors instructions sinon autresinstructions fin Les instructions délimitées par alors et sinon sont exécutées si le test est vérifié, et les instructions délimitées par sinon et finSi sont exécutées si le test n’est pas vérifié. On traduit le traitement conditionnel étendu de la sorte : if (<condition >) { <instructions1 > } else { <instructions2 > } Par exemple, #include<stdio .h> int main() { int i ; printf (” Saisissez une valeur : ” ); scanf (”%d” , &i ); if ( i == 0) {                                                  printf (”Vous avez          saisi        une valeur         nulle \n. ” ); } else {                                                      printf (”La valeur que vous                saisi , ”                                                     ”a savoir %d, n ’ est pas               nulle .\n” ,        i ); return 0; } Notez la présence de l’opérateur de comparaison ==. N’utilisez jamais = pour comparer deux valeurs!. Connecteurs logiques On formule des conditions davantage élaborées en utilisant des connecteurs et et ou. La condition A et B est vérifiée si les deux conditions A et B sont vérifiées simultanément. La condition A ou B est vérifiée si au moins une des deux conditions A et B est vérifiée. Le et s’écrit && et le ou s’écrit ||. Par exemple, voici un programme C qui nous donne le signe de i × j sans les multiplier. #include<stdio .h> int main() { int i ,              j ; printf (” Saisissez deux valeurs : ” ); scanf (”%d %d” , &i , &j ); printf (”Le produit de ces deux valeurs est ” ); if (( i < 0 && j < 0) | | ( i >= 0 && j>= 0)) { printf (” positif \n. ” ); } else { printf (” négatif ” ); } printf (”.\n” ); return 0; } Accolades superflues Lorsqu’une seule instruction d’un bloc if doit être exécutée, les accolades ne sont plus nécessaires. Il est possible par exemple de reformuler le programme précédent de la sorte : #include<stdio .h> int main() { int i ,              j ; printf (” Saisissez deux valeurs : ” ); scanf (”%d %d” , &i , &j ); printf (”Le produit de ces deux valeurs est ” ); if (( i < 0 && j < 0) | | ( i >= 0 && j>= 0)) printf (” positif \n. ” ); else printf (” négatif ” ); printf (”.\n” ); return 0; } Opérateur ternaire En pla¸cant l’instruction suivante à droite d’une affectation, <variable> = (<condition >) ? <valeur> : <autrevaleur> ; on place valeur dans variable si condition est vérifié, autrevaleur sinon. Par exemple, max = ( i>j ) ? i                :    j    ;                    printf (”%d\n” , ( i> ( l = ( j>k) ? j                     : k)) ? i         :     l ); j = (j>k)? j : k) place dans l la plus grande des valeurs j et k, donc (i > (l = (j > k)? j : k))? i : l est la plus grande des valeurs i, j et k. La plus grande de ces trois valeurs est donc affichée par cette instruction. Le switch en C s’écrit, avec la syntaxe suivante : switch(<nomvariable >) { case<valeur1> : <instructions1 > ; break ; case<valeur2> : <instructions2 > ; break ; /? . . . ?/case<valeurn> : <instructionsn > ; break ; default : /? instructions ?/ } N’oubliez surtout pas les break! Si par exemple, nous voulons afficher le nom d’un mois en fonction de son numéro, on écrit switch(numeroMois) { case 1 : printf (” janvier ”)                      ; break ; case 2 : printf (” fevrier ”)                      ; break ; case 3 : printf (”mars”)               ; break ; case 4 : printf (” avril ”)                ; break ; case 5 : printf (”mai”)               ; break ; case 6 : printf (”juin”)                 ; break ; case 7 : printf (” j u i l l e t ”)                  ; break ; case 8 : printf (”aout”)                ; break ; case 9 : printf (”septembre”)                   ; break ; case 10 : printf (”octobre”)                        ; break ; case 11 : printf (”novembre”)                    ; break ; case 12 : printf (”decembre”)                    ; break ; printf (”Je connais pas ce mois . . . ” ); } Une variable booléenne ne peut prendre que deux valeurs : vrai et faux. Il n’existe pas de type booléen à proprement parler en C. On utilise des int pour simuler le comportement des booléens. On représente la valeur booléenne faux avec la valeur entière 0, toutes les autres valeurs entières servent à représenter vrai. Utilisation dans des if Lorsqu’une condition est évaluée, par exemple lors d’un test, cette condition prend à ce moment la valeur vrai si le test est vérifié, faux dans le cas contraire. La valeur entière 0 représente la constante faux et toutes les autres sont des constantes vrai. Observons le test suivant : if (8) { // . . . 1 est un littéral de type entier dont le valeur est non nulle, donc il représente le booléen vrai. De ce fait, le test if (8) est toujours vérifié. Par contre le test if (0) n’est jamais vérifié. La valeur vrai Même si tout entier non nul a la valeur vrai, on prend par défaut la valeur 1. Lorsqu’une condition est évaluée, elle prend la valeur 1 si elle est vérifié, 0 dans le cas contraire. par exemple, x = (3>2); On remarque que (3>2) est une condition. Pour décider quelle valeur doit être affectée à x, cette condition est évaluée. Comme dans l’exemple ci-dessus la condition est vérifiée, alors elle prend la valeur 1, et cette valeur est affectée à x. Connecteurs logiques binaires Les connecteurs || et && peuvent s’appliquer à des valeurs (ou variables) entières. Observons l’exemple suivant : x = (3 && 0)             | |     (1); Il s’agit de l’affectation à x de l’évaluation de la condition (3 && 0) || (1). Comme 3 est vrai et 0 est faux, alors leur conjonction est fausse. Donc (3 && 0) a pour valeur 0. La condition 0 || 1 est ensuite évaluée et prend la valeur vrai. Donc la valeur 1 est affectée à x. Parmi les connecteurs logiques se trouve!, dit opérateur de négation. La négation d’une expression est vraie si l’expression est fausse, fausse si l’expression est vraie. Par exemple, x = !(3==2); Comme 3 == 2 est faux, alors sa négation!(3 == 2) est vraie. Donc la valeur 1 est affectée à x. Complètons notre tableau des priorités en y adjoignant les connecteurs logiques et les opérateurs de comparaison : noms opérateurs opérateurs unaires cast, -, ~,!, ++, -- produit *, /, % somme +, - décalage binaire >>, << comparaison >, <, >=, <= égalité ==,!= ET binaire & OU Exlusif binaire ^ OU binaire | connecteurs logiques &&, || Macro-instructions Le C nous permet de placer à peu près n’importe quoi dans les constantes. Si par exemple, on est lassé d’écrire des instructions de retour à la ligne, il suffit de définir #define RC printf (”\n”) Dans ce cas, toutes les occurrences de RC dans le code seront remplacées par des printf("\n"). Par exemple #include<stdio .h> #define BEGIN { #define END } #define RC printf (”\n”) #define AFFICHE DEBUT printf (”Debut”) #define AFFICHE FIN printf (”Fin”) #define AFFICHE MLILIEU printf (”Milieu”) #define RETOURNE 0 return 0 int main() BEGIN AFFICHE DEBUT; RC; AFFICHE MLILIEU; RC; AFFICHE FIN; RC; RETOURNE 0; END affiche Debut Milieu Fin Macros paramétrées Il est possible de paramétrer les instructions du préprocesseur. Par exemple, #define TROIS FOIS N(n) (3 ? (n)) va remplacer toutes les occurences de TROIS FOIS N( ) par (3 * ( )) en substituant aux points de suspension la valeur se trouvant entre les parenthèses de la constante. Par exemple #include<stdio .h> #define RC printf (”\n”) #define DECLARER INT( i ) int i int main() { DECLARER INT(k ); printf (” Saisissez un entier : ” ); SAISIR INT(k ); printf (”Vous avez saisi ” ); AFFICHER INT(k ); RC; return 0; } affiche Saisissez un entier : 4 Vous avez saisi 4 Nous souhaitons créer un programme qui nous affiche tous les nombres de 1 à 10, donc dont l’exécution serait la suivante : 1 2 3 4 5 6 7 8 9 10 Une fac¸on particulièrement vilaine de procéder serait d’ecrire 10 printf successifs, avec la lourdeur des copier/coller que cela impliquerait. Nous allons étudier un moyen de coder ce type de programme avec un peu plus d’élégance. Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cette ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une boucle s’appelle une itération, ou plus informellement un passage dans la boucle. Lorsque l’on s’apprête à exécuter la première itération, on dit que l’on rentre dans la boucle, lorsque la dernière itération est terminée, on dit qu’on sort de la boucle. Il existe trois types de boucle : –    while –    do while –    for Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue ultérieurement. while En C, la boucle tant que se code de la fa¸con suivante : while(<condition >) { <instructions > } Les instructions du corps de la boucle sont délimitées par des accolades. La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on exécute les instructions de la boucle. Un fois que la condition n’est plus vérifiée, l’exécution se poursuit après l’accolade fermante. Affichons par exemple tous les nombres de 1 à 5 dans l’ordre croissant, #include<stdio .h> int main() { int i = 1; while( i <= 5) { printf (”%d ” ,    i ); i++; } printf (”\n” ); return 0; } do while Voici la syntaxe de cette boucle : do { <instructions > } while(<condition >); La fonctionnement est analogue à celui de la boucle tant que à quelques détails près : –    la condition est évaluée après chaque passage dans la boucle. –    On exécute le corps de la boucle tant que la condition est vérifée. En C, la boucle répéter jusqu’à est en fait une boucle répéter tant que, c’est-à-dire une boucle tant que dans laquelle la condition est évaluée à la fin. Une boucle do while est donc exécutée donc au moins une fois. Reprennons l’exemple précédent avec une boucle do while : #include<stdio .h> int main() { int i = 1; do { printf (”%d ” ,    i ); i++; } while( i <= 5); printf (”\n” ); return 0; } De la même fac¸on que pour la boucle while, le compteur est initialisé avant le premier passage dans la boucle. Un des usages les plus courant de la boucle do while est le contrôle de saisie : #include<stdio .h> int main() { int i ; do { printf (” Saisissez un entier positif ou nul : ” ); scanf (”%d” , &i ); if ( i < 0)                            printf (”J ’ ai        dit       positif        ou nul     !      ‘\n” ); } while( i < 0); return 0; } for Cette boucle est quelque peu délicate. Commenc¸ons par donner sa syntaxe : for(<initialisation > ; <condition> ; <pas>) { <instructions > } <initialisation >while(<condition >) { <instructions > <pas> } On re-écrit l’affiche des 5 premiers entiers de la sorte en utilisant le fait que <initialisation> = i = 1, <condition> = i <= 5 et <pas> = i++. On obtient : #include<stdio .h> int main() { int i ; for ( i = 1 ; i <= 5 ; i++) printf (”%d ” , i ); printf (”\n” ); return 0; } On utilise une boucle for lorsque l’on connait en entrant dans la boucle combien d’itérations devront être faites. Par exemple, n’utilisez pas une boucle pour pour contrôler une saisie! De la même fac¸on qu’il est possibl de supprimer des accolades autour d’une instruction d’un bloc if, on peut supprimer les accolades autour du corps d’une boucle si elle ne contient qu’une seule instruction. Considérons un programme dont l’exécution donne : Saisissez dix valeurs : 1    : 4 2    : 7 3    : 34 4    : 1 5    : 88 6    : 22 7    : 74 8    : 19 9    : 3 10    : 51 Saissez une valeur 22 22 est la 6-eme valeur saisie Comment programmer cela sans utiliser 10 variables pour stocker les dix premières valeurs saisies? Une tableau est un regroupement de variables de même type, il est identifié par un nom. Chacune des variables du tableau est numérotée, ce numéro s’appelle un indice. Chaque variable du tableau est donc caractérisée par le nom du tableau et son indice. Si par exemple, T est un tableau de 10 variables, alors chacune d’elles sera numérotée et il sera possible de la retrouver en utilisant simultanément le nom du tableau et l’indice de la variable. Les différentes variables de T porteront des numéros de 0 à 9, et nous appellerons chacune de ces variables un élément de T. Une variable n’étant pas un tableau est appelée variable scalaire, un tableau par opposition à une variable scalaire est une variable non scalaire. <type> <nomdutableau>[<taille >]; Par exemple, int T[ 4 ] ; déclare un tableau T contenant 4 variables de type int. Il est possible d’initialiser les éléments d’un tableau à la déclaration, on fait cela comme pour des variables scalaires : <type> <nom>[<taille >] = <valeur d initialisation >; La seule chose qui change est la fa¸con d’écrire la valeur d’initialisation, on ecrit entre accolades tous les éléments du tableau, on les dispose par ordre d’indice croissant en les séparant par des virgules. La syntaxe générale de la valeur d’initialisation est donc : <type> <nom>[<taille >] = {<valeur 0 >, <valeur 1 >,                                            . . . , <valeur n ?1>}; Par exemple, on crée un tableau contenant les 5 premiers nombres impairs de la sorte : int T[5] = {1 , 3 , 5 , 7 ,                         9}; Les éléments d’un tableau à n éléments sont indicés de 0 à n ? 1. On note T[i] l’élément d’indice i du tableau T. Les cinq éléments du tableau de l’exemple ci-avant sont donc notés T[0], T[1], T[2], T[3] et T[4]. Nous pouvons maintenant mettre en place le programme du début du cours. Il est nécessaire de stocker 10 valeurs de type entier, nous allons donc déclarer un tableau E de la sorte : int E[ 10] ; La déclaration ci-dessus est celle d’un tableau de 10 int appelé E. Il convient ensuite d’effectuer les saisies des 10 valeurs. On peut par exemple procéder de la sorte : Les divers copier/coller necéssaires pour rédiger un tel code sont d’une laideur à proscrire. Nous procéderons plus élégament en faisant une boucle : printf (” Saisissez dix valeurs : \n” ); for ( i = 0 ; i < 10 ; i++) { printf (”%d” ,              i +1); scanf (”%d” , &E[ i ] ) ; } Ce type de boucle s’appelle un parcours de tableau. En règle générale on utilise des boucles pour manier les tableaux, celles-ci permettent d’effectuer un traitement sur chaque élément d’un tableau. Ensuite, il faut saisir une valeur à rechercher dans le tableau : printf (” Saissez une valeur \n” ); scanf (”%d” , &t ); Nous allons maintenant rechercher la valeur t dans le tableau E. Considérons pour ce faire la boucle suivante : while (E[ i ] != t ) i++; Cette boucle parcourt le tableau jusqu’à trouver un élément de E qui ait la même valeur que t. Le problème qui pourrait se poser est que si t ne se trouve pas dans le tableau E, alors la boucle pourrait ne pas s’arrêter. Si i prend des valeurs strictement plus grandes que 9, alors il se produira ce que l’on appelle un débordement d’indice. Vous devez toujours veiller à ce qu’il ne se produise pas de débordement d’indice! Nous allons donc faire en sorte que la boucle s’arrête si i prend des valeurs strictement supérieures à 9. while ( i < 10 && E[ i ] != t ) i++; Il existe donc deux fa¸cons de sortir de la boucle : –    En cas de débordement d’indice, la condition i < 10 ne sera pas vérifiée. Une fois sorti de la boucle, i aura la valeur 10. –    Dans le cas ou` t se trouve dans le tableau à l’indice i, alors la condition E[i]!= t ne sera pas vérifiée et on sortira de la boucle. Un fois sorti de la boucle, i aura comme valeur l’indice de l’élément de E qui est égal à t, donc une valeur comprise entre 0 et 9. if ( i == 10) printf (”%d ne fait pas partie des dix valeurs saisies ” , t ); else                 printf (”%d est           la %d?eme valeur           saisie ” , t ,         i +1); Si (i == 10), alors nous sommes sorti de la boucle parce que l’élément saisi par l’utilisateur ne trouve pas dans le tableau. Dans le cas contraire, t est la i+1-ème valeur saisie par l’utilisateur. On additionne 1 à l’indice parce que l’utilisateur ne sait pas que dans le tableau les éléments sont indicés à partir de 0. Récapitulons : #include<stdio .h> #define N 10 #define SAISIR INT(num, nom) \ { \ printf (”%d : ” , num); \            scanf (”%d” , &(nom));        \ } int main() { int E[N] ,       i ,     t ; printf (” Saisissez dix valeurs : \n” ); for ( i = 0 ; i < N ; i++) SAISIR INT( i +1, E[ i ] ) ; printf (” Saissez une valeur \n” ); scanf (”%d” , &t ); i = 0; while ( i < N && E[ i ] != t ) i++; if ( i == N) printf (”%d ne fait pas partie des dix valeurs saisies ” , t ); else printf (”%d est la %d?eme valeur saisie ” , t , i +1); printf (”\n” ); return 0; } Etant donné le programme dont l’exécution est tracée ci dessous : Saisissez une phrase : Les framboises sont perchees sur le tabouret de mon grand-pere. Vous avez saisi : Les framboises sont perchees sur le tabouret de mon grand-pere. Cette phrase commence par une majuscule. Cette phrase se termine par un point. Comment faire pour saisir et manier des séquences de caractères de la sorte? Par exemple, la phrase ”Toto” sera codée de la sorte : ’T’ ’o’ ’t’ ’o’ 0 Prenez bien note du fait que le dernier caractère de la chaine est suivi d’un caractère nul. Comme une chaˆ?ne de caractères est un tableau de char, on le déclare : char<nom chaine>[<taille chaine >]; Par exemple, on déclare une chaine c de 200 caractères de la sorte : char c [200]; Attention! Le nombre maximal de lettres qu’il sera possible de placer dans c ne sera certainement pas 200 mais 199, car il faut placer après le dernier caractère de la chaˆ?ne un caractère nul! On initialise une chaˆ?ne à la déclaration, et seulement à la déclaration de la sorte : char<nom chaine>[<taille chaine >] = <valeur initialisation >; Ou` la valeur d’initiallisation contient la juxtaposition de caractères formant la chaˆ?ne entourée de guillemets (double quotes). Par exemple, char c [50] = ”Toto” ; Cette instruction déclare une chaˆ?ne de caratères c initialisée à "Toto". Les 5 premiers éléments du tableau seront occupés par les 4 caractères de la chaˆ?ne ainsi que par le caratère nul, les autres contiendront des valeurs non significatives. Observez bien l’exemple suivant : char c [4] = ”Toto” ; Cette déclaration engendrera un warning à la compilation et probablement une erreur à l’exécution car l’affectation du caractère nul à la 5-ème position du tableau donnera lieu à un débordement d’indice. Du fait qu’une chaine de caractère est un tableau, il est aisé d’en isoler un élément. Ainsi c[i] est le i+1-ème élément de la chaˆ?ne c. On teste donc si le premier caratère de c est une majuscule de la sorte : if (c [0] >= ’A’ && c [0] <= ’Z ’ ) printf (”Cette phrase commence par une majuscule .\n” ); else printf (”Cette phrase ne commence pas par une majuscule .\n” ); int i = 0; while(c [ i ] != 0) printf (”%c” , c [ i ++]); Notez que le corps de la boucle while est itéré jusqu’à ce que le caractère nul soit rencontré. Il est donc impératif que votre chaˆ?ne se termine par le caractère nul et que le caractère nul se trouve dans la plage d’indices du tableau. Est-ce que le code suivant est correct? char c [ 26 ]; int i ; for ( i = 0 ;           i < 26 ,        i++) c [ i ] = ’a ’ + i ; Si la question vous est posée, vous pouvez présumer que ce code n’est pas correct. Le fait que chaque élément du tableau contienne un caractère non nul ne peut que corroborer cette présomption Si l’on souhaite placer l’alphabet dans une chaˆ?ne, on procède de la sorte : char c [ 27 ]; int i ; for ( i = 0 ;           i < 26 ,        i++) c [ i ] = ’a ’ + i ; c [26] = 0; Notez bien que le tableau contient 27 éléments si l’on compte le caractère nul, et que celui-ci est placé à la fin du tableau juste après la boucle. Nous avons vu qu’il était possible d’utiliser le fait qu’une chaˆ?ne est un tableau pour l’afficher. Il existe une méthode plus simple, en utilisant printf avec la chaˆ?ne de format "%s". Par contre soyez attentifs au fait que si votre chaˆ?ne ne contient pas de caractère nul ou que le caractère nul se trouve en dehors de la plage d’indice de votre chaˆ?ne, il faudra vous attendre aux pires horreurs à l’exécution! Dans le code donné en exemple nous pouvons donc écrire l’instruction d’affichage de la chaˆ?ne saisie par l’utilisateur :             printf (”Vous avez           saisi        :\n%s” , c ); #include<stdio .h> #define N 20 int main() { char chaine [N] ; int i ; printf (” Saisissez une phrase   :\n” ); gets ( chaine ); for ( i = 0 ;               chaine [ i ] != 0 ;           i++)                             printf (”chaine[%d] = %c ( code ASCII : %d)\n” , i ,                     chaine [ i ] ,        chaine [ i ] ) ;                        printf (”chaine[%d] = %c ( code ASCII : %d)\n” , i ,                     chaine [ i ] ,        chaine [ i ] ) ; return 0; } Tout d’abord compilons ce programme : [[email protected] chaines]$ gcc -Wall mauvaiseSaisie.c -o mauvaiseSaisie.c /home/klaus/tmp/ccyKd0hf.o: In function ‘main’: mauvaiseSaisie.c:(.text+0x24): warning: the ‘gets’ function is dangerous and should not be used. La première réaction du compilateur est une insulte. A-t-il raison? Testons ce programme : [[email protected] chaines]$ ./mauvaiseSaisie Saisissez une phrase : Les framboises sont perchees sur le tabouret de mon grand pere. chaine[0] = L (code ASCII : 76) chaine[1] = e (code ASCII : 101) chaine[2] = s (code ASCII : 115) chaine[3] =           (code ASCII : 32) chaine[4] = f (code ASCII : 102) chaine[5] = r (code ASCII : 114) chaine[6] = a (code ASCII : 97) chaine[7] = m (code ASCII : 109) chaine[8] = b (code ASCII : 98) chaine[9] = o (code ASCII : 111) chaine[10] = i (code ASCII : 105) chaine[11] = s (code ASCII : 115) chaine[12] = e (code ASCII : 101) chaine[13] = s (code ASCII : 115) chaine[14] =        (code ASCII : 32) chaine[15] = s (code ASCII : 115) chaine[16] = o (code ASCII : 111) chaine[17] = n (code ASCII : 110) chaine[18] = t (code ASCII : 116) chaine[19] =               (code ASCII : 32) chaine[20] = (code ASCII : 20) chaine[21] = (code ASCII : 0) Erreur de segmentation fgets(<chaine >, <taille >, stdin ); La taille de la chaˆ?ne saisie est limitée par <taille>, caractère nul compris. Le résultat est placé dans <chaine>. Tous les caractères supplémentaires saisis par l’utilisateur ne sont pas placés dans <chaine>, seuls les (<taille> ? 1) premiers caractères sont récupérés par fgets. Nous saisirons donc la phrase de notre programme de la sorte : fgets (c , 200 , stdin ); Lorsque vous saisissez des caractères avec fgets, les caractères ignorés ne sont pas éliminés du buffer. Cela signifie qu’ils iront parasiter la prochaine saisie. Il convient donc tout d’abord de vérifier s’il reste des caractères dans buffer et de les éliminer si nécessaire. Commen¸cons par le premier point : comment s’assurer que tous les caractères saisis ont été lus? La réponse est très simple : grâce au caractère d’échappement ’\n’. La saisie est validée par le caratère d’échappement, il s’agit donc toujours du dernier caractère saisi. Le buffer a donc été entirèrement lu si caractère d’échappement a été lu. Si ce caractère a été lu, alors il figure juste avant le caractère nul dans la chaˆ?ne. On le repère donc de la sorte : while(c [ i ] != 0) i++; if (c [ i ?1] !=         ’\n ’ )                   printf (”La saisie           est       incomplete” ); else                   printf (”La saisie           est       complete” ); while( getchar () !=          ’\n ’ ); Le point-virgule à la fin de l’instruction indique au compilateur que la boucle n’a pas de corps. Cette boucle lit le buffer jusqu’à ce que le caractère d’échappement ait été lu. Pour davantage de lisibilité, on définit une macro-instruction vidant le buffer :                 #define CLEAR BUFFER while( getchar () !=               ’\n ’ ) Vérifiez bien avant de lancer cette instruction que le buffer n’est pas vide, sinon le programme bouclera jusqu’à ce que l’utilisateur ait saisi un caractère d’échappement. string.h Cette bibliothèque propose des fonctions de maniement de chaˆ?nes de caractères, à savoir : –    strcmp : comparer deux chaˆ?nes. –    strlen : longueur d’une chaˆ?ne de caractère –    strsubs : rechercher une sous-chaˆ?ne –    strcat : concaténer deux chaˆ?nes –    strcpy : copier une chaˆ?ne Il vous est conseillé d’examiner de quelle fac¸on fonctionnent ces fonctions, et comment elles gèrent le caractère nul. #include<stdio .h> #define N 10 #define CLEAR BUFFER while( getchar () !=                        ’\n ’ ) int main() { char chaine [N] ; int i ; printf (” Saisissez une phrase :\n” ); fgets ( chaine , N, stdin ); i = 0; while( chaine [ i ] != 0) i++; if ( i > 0 && chaine [ i ?1] !=              ’\n ’ ) CLEAR BUFFER; else chaine [ i ?1] = 0; printf (”Vous avez saisi :\n%s\n” , chaine ); if ( chaine [0] >= ’A’ && chaine [0] <= ’Z ’ ) printf (”Cette phrase commence par une majuscule .\n” ); else printf (”Cette phrase ne commence pas par une majuscule .\n” ); i = 0; while( chaine [ i ] != 0 && chaine [ i ] !=               ’ . ’ ) i++; if ( chaine [ i ] == ’ . ’ ) if ( chaine [ i +1] == 0) printf (”Cette phrase ne se termine pas par un point .\n” ); return 0; } Une procédure est un ensemble d’instructions portant un nom. Pour définir une procédure, on utilise la syntaxe : void nomprocedure () { /? instructions ?/ } Une procédure est une nouvelle instruction, il suffit pour l’exécuter d’utiliser son nom. Par exemple, pour exécuter (on dit aussi appeler ou invoquer) une procédure appelée pr, il suffit d’écrire pr();. Les deux programmes suivants font la même chose. Le premier est écrit sans procédure : #include<stdio .h> int main() { printf (”Bonjour\n” ); return 0; } Et dans le deuxième, le printf est placé dans la procédure afficheBonjour et cette procédure est appelée depuis le main. #include<stdio .h> void afficheBonjour () { printf (”Bonjour\n” ); } int main() { afficheBonjour (); return 0; } Vous pouvez définir autant de procédures que vous le voulez et vous pouvez appeler des procédures depuis des procédures : #include<stdio .h> void afficheBonjour () { printf (”Bonjour\n” ); } void afficheUn () { printf (”1\n” ); } void afficheDeux () { printf (”2\n” ); } void afficheUnEtDeux () { afficheUn (); afficheDeux (); } void afficheAuRevoir () { printf (”Au revoir \n” ); } int main() { afficheBonjour (); afficheUnEtDeux (); afficheAuRevoir (); return 0; } Ce programme affiche : Bonjour 1 2 Au revoir Regardez bien le programme suivant et essayez de déterminer ce qu’il affiche. #include<stdio .h> void procedure1 () { printf (”debut procedure 1\n” );           printf (” fin           procedure 1\n” ); } void procedure2 () { printf (”debut procedure 2\n” ); procedure1 ();           printf (” fin           procedure 2\n” ); } void procedure3 ()           printf (” fin           procedure 3\n” ); } int main() { printf (”debut main\n” ); procedure2 (); procedure3 (); printf (” fin main\n” ); return 0; } La réponse est debut main debut procedure 2 debut procedure 1 fin procedure 1 fin procedure 2 debut procedure 3 debut procedure 1 fin procedure 1 debut procedure 2 debut procedure 1 fin procedure 1 fin procedure 2 fin procedure 3 fin main Vous remarquez au passage que main est aussi une procédure. main est exécutée automatiquement au lancement du programme. Une procédure est un bloc d’instructions et est sujette aux mêmes règles que main. Il donc possible de déclarer des variables : void nomprocedure () { /? declaration               de            variables ?/ /? instructions ?/ } Attention, ces variables ne sont accessibles que dans le corps de la procédure, cela signifie qu’elle naissent au moment de leur déclaration et qu’elles sont détruites une fois la dernière instruction de la procédure exécutée. C’est pour cela qu’on les apelle des variables locales. Une variable locale n’est visible qu’entre sa déclaration et l’accolade fermant la procédure. Par exemple, ce code est illégal : #include<stdio .h> void maProcedure () { char a = b; } int main() { char b = ’k ’ ; printf (”%c , %c\n” , a , b ); return 0; } En effet, la variable b est déclarée dans la procédure main, et n’est donc visible que dans cette même procédure. Son utilisation dans maProcedure est donc impossible. De même, la variable a est déclarée dans maProcedure, elle n’est pas visible dans le main. Voici un exemple d’utilisation de variables locales : #include<stdio .h> void unADix() { int i ; for ( i = 1 ; i <= 10 ; i++ ) printf (”%d\n” , i ); } int main() { unADix (); return 0; } int main() { int i ; printf (” Veuillez s a i si r un entier : ” ); scanf ( ’ ’%d ’ ’ , &i ); /? Appel d ’une         procedure         affichant       la      valeur     de    i . ?/ return 0; } Comment définir et invoquer une procédure afficheInt permettant d’afficher cet entier saisi par l’utilisateur? Vous conviendrez que la procédure suivante ne passera pas la compilation void afficheInt () { printf ( ’ ’%d ’ ’ ,               i ); } En effet, la variable i est déclarée dans le main, elle n’est donc pas visible dans afficheInt. Pour y remédier, on définit afficheInt de la sorte : void afficheInt ( int i ) { printf ( ’ ’%d ’ ’ ,               i ); } i est alors appelé un paramètre, il s’agit d’une variable dont la valeur sera précisée lors de l’appel de la procédure. On peut aussi considérer que i est une valeur inconnue, et qu’elle est initialisée lors de l’invocation de la procédure. Pour initialiser la valeur d’un paramètre, on place cette valeur entre les parenthèses lors de l’appel de la procédure, par exemple : afficheInt(4) lance l’exécution de la procédure afficheInt en initialisant la valeur de i à 4. On dit aussi que l’on passe en paramètre la valeur 4. La version correcte de notre programme est : #include<stdio .h> void afficheInt ( int { printf (”%d” ,    i ); } int main() { int i ; i ) printf (” Veuillez scanf (”%d” , &i ); afficheInt ( i ); printf (”\n” ); s a i si r un entier : ” ); return 0; } Attention, notez bien que le i de afficheInt et le i du main sont deux variables différentes, la seule chose qui les lie vient du fait que l’instruction afficheInt(i) initialise le i de afficheInt à la valeur du i du main. Il serait tout à fait possible d’écrire : #include<stdio .h> { printf (”%d” ,    j ); } int main() { int i ;	j )
printf (” Veuillez scanf (”%d” , &i ); afficheInt ( i ); printf (”\n” );	s a i si r un entier	: ” );

return 0;

}

Dans cette nouvelle version, l’instruction afficheInt(i) initialise le j de afficheInt à la valeur du i du main.

Il est possible de passer plusieurs valeurs en paramètre. Par exemple, la procédure suivante affiche la somme des deux valeurs passées en paramètre :

void afficheSomme ( int a , int b)

{

printf ( ’ ’%d ’ ’ , a + b );

}

L’invocation d’une telle procédure se fait en initialisant les paramètres dans le même ordre et en séparant les valeurs par des virgules, par exemple afficheSomme(3, 4) invoque afficheSomme en initialisant a à 3 et b à 4. Vous devez intialiser tous les paramètres et vous devez placer les valeurs dans l’ordre.

Récapitulons :

#include<stdio .h>

void afficheSomme ( int a , int b)

{

printf (”%d” , a + b );

}

int main()

{

int i ,       j ;

printf (” Veuillez s a i si r deux entiers :\na = ” ); scanf (”%d” , &i ); printf (”b = ” ); scanf (”%d” , &j ); printf (”a + b = ” ); afficheSomme ( i , j );

printf (”\n” );

return 0;

}

La procédure ci-avant s’exécute de la fac¸on suivante :

Veuillez saisir deux entiers :

a = 3 b = 5 a + b = 8

Lors de l’appel afficheInt(r) de la procédure void afficheInt(int i), r est le paramètre effectif et i le paramètre formel. Notez bien que i et r sont deux variables distinctes. Par exemple, qu’affiche le programme suivant?

#include<stdio .h>

void incr ( int v)

{ v++; }

main()

{

int i ; i = 6;

incr ( i ); printf (”%d\n” , i );

}

La variable v est initialisée à la valeur de i, mais i et v sont deux variables différentes. Modifier l’une n’affecte pas l’autre.

Le principe

Invocation

La syntaxe pour appeler une fonction est : v = nomfonction ( parametres );

L’instruction ci-dessus place dans la variable v la valeur retournée par la fonction nomfonction quand lui passe les paramètres parametres. Nous allons plus loin dans ce cours définir une fonction carre qui retourne le carré de valeur qui lui est passée en paramètre, alors l’instruction

v = carre (2);

placera dans v le carré de 2, à savoir 4. On définira aussi une fonction somme qui retourne la somme de ses paramètres, on placera donc la valeur 2 + 3 dans v avec l’instruction

v = somme(2 ,          3);

Définition

On définit une fonction avec la syntaxe suivante :

typeValeurDeRetour nomFonction( listeParametres )

{

}

La fonction carre sera donc définie comme suit :

int carre ( int i )

{

/? instructions

?/ }

Une fonction ressemble beaucoup à une procédure. Vous remarquez que void est remplacé par int, void signifie aucune type de retour, une procédure est donc une fonction qui ne retourne rien. Un int est adapté pour représenter le carré d’un autre int, j’ai donc choisi comme type de retour le type int. Nous définirons la fonction somme comme suit :

int somme( int a , int b)

{

/? instructions

?/ }

L’instruction servant à retourner une valeur est return. Cette instruction interrompt l’exécution de la fonction et retourne la valeur placée immédiatement après. Par exemple, la fonction suivante retourne toujours la valeur 1.

int un()

{

return 1;

}

Lorsque l’on invoque cette fonction, par exemple

v = un ();

La valeur 1, qui est retournée par un est affectée à v. On définit une fonction qui retourne le successeur de son paramètre :

int successeur ( int i )

{

return i + 1;

}

Cette fonction, si on lui passe la valeur 5 en paramètre, retourne 6. Par exemple, l’instruction

v = successeur (5);

affecte à v la valeur 6. Construisons maintenant nos deux fonctions :

{

return i ? i         ;

}

int somme( int a , int b)

{

return a + b ;

}

Vous noterez qu’une fonction ne peut pas retourner un tableau, une fonction ne peut retourner que des valeurs scalaires. Vous comprendrez pourquoi en étudiant les pointeurs.

En C, lorsque vous invoquez une fonction, toutes les valeurs des paramètres effectifs sont recopiés dans les paramètres formels. On dit dans ce cas que le passage de paramètre se fait par valeur. Vous ne pouvez donc, a priori, communiquer qu’une seule valeur au programme appelant. Effectivement :

–    seule la valeur de retour vous permettra de commnuniquer une valeur au programme appelant. – une fonction ne peut retourner que des valeurs scalaires.

Lorsque vous passez un tableau en paramètre, la valeur qui est recopiée dans le paramètre formel est l’adresse de ce tableau (l’adresse est une valeur scalaire). Par conséquent toute modification effectuée sur les éléments d’un tableau dont l’adresse est passée en paramètre par valeur sera repercutée sur le paramètre effectif (i.e. le tableau d’origine). Lorsque les modifications faites sur un paramètre formel dans un sous-programme sont repércutées sur le paramètre effectif, on a alors un passage de paramètre par référence. Nous retiendrons donc les trois règles d’or suivantes :

–    Les variables scalaires se passent en paramètre par valeur

–    Les variables non scalaires se passent en paramètre par référence

–    Une fonction ne peut retourner que des valeurs scalaires

Une structure, appelé enregistrement dans d’autres langages, est une variable contenant plusieurs variables, appelées champs. Si une structure t contient un char et un int, chacun de ces champs portera un nom, par exemple i et c. Dans ce cas, t.c désignera le char de t et t.i l’int de t.

Pour créer un type structuré, on utilise la syntaxe suivante :

struct nomdutype

{ typechamp_1 nomchamp_1; typechamp_2 nomchamp_2; typechamp_n nomchamp_n; };

On précise donc le nom de ce type structuré, et entre les accolades, la liste des champs avec pour chacun d’eux son type. Vous remarquez que le nombre de champs est fixé d’avance. On n’accède pas à un champ avec un indice mais avec un nom. Considérons par exemple le type structuré suivant :

struct point

{

double abs ; double ord ;

};

Ce type permet de représenter un point dans R², avec respectivement uns abscisse et une ordonnée. struct point est maintenant un type, il devient possible de déclarer un point p comme tout autre variable :

struct point p;

On accède aux champs d’une variable structurée à l’aide de la notation pointée nomvariable.nomduchamp

Ainsi, le champ ord de notre variable p sera accessible avec p.ord et le champ abs de notre variable p sera accessible avec p.abs. Voici un exemple de programme illustrant ce principe :

#include<stdio .h>

struct point

{

double abs ; double ord ;

};

main()

{

struct point p; p. ord = 2;

p. abs = p. ord + 1;

printf (”p = (%f , %f )\n” , p. abs , p. ord );

}

Ce programme affiche : p = (3.000000, 2.000000)

Attention, l’opérateur d’accès au champ . est prioritaire sur tous les autres opérateurs unaires, binaires et ternaires! Il faudra vous en rappeler quand on étudiera les listes chaˆ?nées.

Typedef

On se débarasse du mot clé struct en renommant le type, on utilisera par exemple la syntaxe suivante :

#include<stdio .h>

typedef struct point

{

main()

{

point p;

p. ord = 2;

p. abs = p. ord + 1;

printf (”p = (%f , %f )\n” , p. abs , p. ord );

} point est donc le nom de ce type structuré.

Rien de nous empêche de créer des tableaux de structures, par exemple :

#include<stdio .h>#define N 10

typedef struct point

{

double abs ; double ord ; }point ;

main()

{ point p[N] ; int i ;

p [ 0 ] . ord = 0; p [ 0 ] . abs = 1;

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

{

p[ i ] . ord = p[ i ? 1]. ord + 1.; p[ i ] . abs = p[ i ? 1]. abs + 2.;

}

for ( i = 0 ;           i < N ;         i++)

{

printf (”p[%d] = (%f , %f )\n” , i , p[ i ] . abs , p[ i ] . ord );

}

}

Ce programme affiche :

p[0] = (1.000000, 0.000000) p[1] = (3.000000, 1.000000) p[2] = (5.000000, 2.000000) p[3] = (7.000000, 3.000000) p[4] = (9.000000, 4.000000) p[5] = (11.000000, 5.000000) p[6] = (13.000000, 6.000000) p[7] = (15.000000, 7.000000) p[8] = (17.000000, 8.000000) p[9] = (19.000000, 9.000000)

Lorsqu’on les passe en paramètre, les structures se comportent comme des variables scalaires, cela signifie qu’on ne peut les passer en paramètre que par valeur. Par contre, un tableau de structures est nécessairement passé en paramètre par référence. Réecrivons le programme précédent avec des sousprogrammes :

#include<stdio .h>#define N 10

typedef struct point

{

double abs ; double ord ; }point ;

void initTableauPoints ( point p [] , int n)

{

int i ;

p [ 0 ] . ord = 0; p [ 0 ] . abs = 1;

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

{

p[ i ] . ord = p[ i ? 1]. ord + 1.; p[ i ] . abs = p[ i ? 1]. abs + 2.;

}

}

void affichePoint ( point p)

{

printf (”(%f , %f )” , p. abs , p. ord );

}

void afficheTableauPoints ( point p [] , int n)

{

int i ;

for ( i = 0 ;                    i < n ;         i++)

{

}

}

main()

{ point p[N] ; initTableauPoints (p, N);

afficheTableauPoints (p, N);

}

Comme une structure se comporte comme une variable scalaire, il est possible de retourner une structure dans une fonction, il est donc possible de modifier le programme ci-avant de la sorte :

#include<stdio .h>#define N 10

typedef struct point

{

double abs ; double ord ; }point ;

point nextPoint ( point                  previous )

{ point   result ;

result . ord = previous . ord + 1.; result . abs = previous . abs + 2.;

return result ;

}

void initTableauPoints ( point p [] , int n)

{

int i ;

p [ 0 ] . ord = 0; p [ 0 ] . abs = 1;

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

p[ i ] = nextPoint (p[ i ? 1]);

}

void affichePoint ( point p)

{

printf (”(%f , %f )” , p. abs , p. ord );

}

void afficheTableauPoints ( point p [] , int n)

{

int i ;

for ( i = 0 ;                    i < n ;         i++)

{

printf (”p[%d] = ” , i ); affichePoint (p[ i ] ) ; printf (”\n” );

}

}

main()

{ point p[N] ; initTableauPoints (p, N);

afficheTableauPoints (p, N);

}

La notion de pointeur est très importante en C, elle va vous permettre de comprendre le fonctionnement d’un programme, de programmer de fa¸con davantage propre et performante, et surtout de concevoir des programmes que vous ne pourriez pas mettre au point sans cela.

Une des premières choses à comprendre quand on programme, c’est qu’une variable est un emplacement de la mémoire dans lequel vous allez placer une valeur. En programmant, vous utilisez son nom pour y lire ou écrire une valeur. Mais ce qui se passe au coeur de la machine est quelque peu plus complexe, les noms que l’on donne aux variables servent à masquer cette complexité.

Ce système est ouvert, dans le sens ou` vous pouvez décider d’utiliser l’adresse d’une variable au lieu d’utiliser son nom. Pour ce faire, on utilise des pointeurs.

Un pointeur est une variable qui contient l’adresse mémoire d’une autre variable.

Déclaration

T? est le type d’une variable contenant l’adresse mémoire d’une variable de type T. Si une variable p de type T? contient l’adresse mémoire d’une variable x de type T, on dit alors que ppointe versx (ou bien surx). &x est l’adresse mémoire de la variable x. Exposons cela dans un exemple,

#include<stdio .h>

void main()

{

int x = 3; int? p; p = &x ;

}

x est de type int. p est de type int?, c’est à dire de type pointeur deint, p est donc faite pour contenir l’adresse mémoire d’un int. &x est l’adresse mémoire de la variable x, et l’affectation p = &x place l’adresse mémoire de x dans le pointeur p. A partir de cette affectation, p pointe sur x.

Affichage

La chaˆ?ne de format d’une adresse mémoire est ”%X”. On affiche donc une adresse mémoire (très utile pour débugger :-) comme dans l’exemple ci-dessous,

#include<stdio .h>

void main()

{

int x = 3; int? p; p = &x ;

printf (”p contient la valeur %X, qui n ’ est autre que l ’ adresse %X de x” , p, &x );

}

Accès à la variable pointée

Le lecteur impatient se demande probablement à quoi peuvent servir toutes ces étoiles? Quel peut bien être l’intérêt des pointeurs?

Si p pointe sur x, alors il est possible d’accéder à la valeur de x en passant par p. Pour le compilateur, ?p est la variable pointée par p, cela signifie que l’on peut, pour le moment du moins, utiliser indifférement ?p ou x. Ce sont deux fa¸cons de se référer à la même variable, on appelle cela de l’aliasing. Explicitons cela sur un exemple,

#include<stdio .h>

void main()

{

?p = 4; printf (”x = %d\n” , x );

}

L’affectation p = &x fait pointer p sur x. A partir de ce moment, ?p peut être utilisé pour désigner la variable x. De ce fait, l’affectation x = 4 peut aussi être écrite ?p = 4. Toutes les modifications opérées sur ?p seront répercutées sur la variable pointée par p. Donc ce programme affiche

x = 3 x = 4

Récapitulons

Qu’affiche, à votre avis, le programe suivant?

#include<stdio .h>

void main()

{

int x = 3; int y = 5; int? p; p = &x ; printf (”x = %d\n” , x );

?p = 4; printf (”x = %d\n” , x );

p = &y ;

printf (”?p = %d\n” , ?p );

?p = ?p + 1;

printf (”y = %d\n” , y );

}

x est initialisé à 3 et y est initialisé à 5. L’affectation p = &x fait pointer p sur x, donc ?p et x sont deux écritures différentes de la même variable. Le premier printf affiche la valeur de x : plus précisément x = 3. Ensuite, l’affectation ?p = 4 place dans la valeur pointée par p, à savoir x, la valeur 4. Donc le deuxième printf affiche x = 4. L’affectation p = &y fait maintenant pointer p sur y, donc la valeur de ?p est la valeur de la variable pointée y. le troisième printf affiche donc *p = 5. N’oubliez pas que comme p pointe sur y, alors ?p et y sont deux alias pour la même variable, de ce fait, l’instruction ?p = ?p + 1 peut tout à fait s’écrire y = y + 1. Cette instruction place donc dans y la valeur 6, le quatrième printf affiche donc y = 6. Ce programme affiche donc :

x = 3 x = 4 *p = 5 y = 6

Il est possible d’aller plus loin dans l’utilisation des pointeurs en les employant pour manipuler des tableaux. Tout d’abord, éclaircissons quelques points.

Démystification (et démythification) du tableau en C

J’ai par ailleurs, une assez mauvaise surprise pour vous. Vous utilisez sans le savoir des pointeurs depuis que vous utilisez des tableaux. Etant donné la déclaration int T[50], vous conviendrez que les désignations {T[0], ,T[49]} permettent de se référer aux 50 éléments du tableau T. Mais vous est-il déjà arrivé, en passant un tableau en paramètre, d’écrire T sans écrire d’indice entre crochets? Par exemple,

#include<stdio .h>

void initTab ( int K[] , int n)

{

int i ;

for ( i = 0 ;            i < n ;         i++)

K[ i ] = i + 1;

}

void afficheTab ( int K[] , int n)

{

int i ;

for ( i = 0 ; i < n ; i++) printf (”%d\n” , K[ i ] ) ;

}

int main()

{

int T[ 50 ]; initTab (T,         50); afficheTab (T,         50);

return 0;

}

Vous remarquez que lorsque l’on passe un tableau en paramètre à un sous-programme, on mentionne seulement son nom. En fait, le nom d’un tableau, T dans l’exemple ci-avant, est l’adresse mémoire du premier élément de ce tableau. Donc, T est une variable contenant une adresse mémoire, T est par conséquent un pointeur. Lorsque dans un sous-programme auquel on a passé un tableau en paramètre, on mentionne un indice, par exemple K[i], le compilateur calcule l’adresse du i-ème élément de K pour lire ou écrire à cette adresse.

Utilisation des pointeurs

Commen¸cons par observer l’exemple suivant :

#include<stdio .h>

main()

{

char t [1 0] ; char? p; t [0] = ’a ’ ;

p = t ;

          printf (” le              premier element du tableau                est %c .\n” , ?p );

}

le premier element du tableau est a.

Calcul des adresses mémoire

Tout d’abord, je tiens à rappeler qu’une variable de type char occupe un octet en mémoire. Considérons maintenant les déclarations

char t[10] ;

et

char ? p = t ;

Nous savons que si p pointe vers t[0], il est donc aisé d’accéder au premier élément de t en utilisant le pointeur p. Mais comment accéder aux autres éléments de t? Par exemple T[1]? Souvenez-vous que les éléments d’un tableau sont juxtaposés, dans l’ordre, dans la mémoire. Par conséquent, si p est l’adresse mémoire du premier élément du tableau t, alors (p+1) est l’adresse mémoire du deuxième élément de ce tableau. Vous êtes conviendrez que ?p est la variable dont l’adresse mémoire est contenue dans p. Il est possible, plus généralement, d’écrire ?(p+1) pour désigner la variable dont l’adresse mémoire est (p+1), c’est à dire (la valeur contenue dans p) + 1. Illustrons cela dans un exemple, le programme

#include<stdio .h>

main()

{

char t [1 0] ; char? p; t [1] = ’b ’ ;

p = t ;

          printf (” le              deuxieme element du tableau                  est %c .\n” , ?(p+1));

}

affiche

le deuxième element du tableau est b.

En effet, p+1 est l’adresse mémoire du deuxième élément de t, il est donc possible d’utiliser indifférement ?(p+1) et t[1]. Plus généralement, on peut utiliser ?(p+i) à la place de t[i]. En effet, (p+i) est l’adresse du i-ème élément de t, et ?(p + i) est la variable dont l’adresse mémoire est (p + i). Par exemple, #include<stdio .h>

#define N 26

main()

{

char t [N] ; char v = ’A’ ; char? p; int i ; p = t ;

/?      i n i t i a l i s a t i o n            du           tableau ?/for ( i = 0 ;      i < N ;     i++)

?(p + i ) = v++;

/? affichage du tableau ?/for ( i = 0 ; i < N ; i++)

printf (”\n” );

}

Ou encore, en utilisant des sous-programmes,

#include<stdio .h>#define N 26

void initTab (char? k , int n)

{

int i ; int v = ’A’ ; for ( i = 0 ; i < n ; i++)

?(k + i ) = v++;

}

void afficheTab (char? k , int n)

{

int i ;

for ( i = 0 ;            i < n ;         i++)

printf (”%c ” , ?(k + i )); printf (”\n” ); }

main()

{

char t [N] ; initTab (t , N);

afficheTab (t , N);

}

Ces deux sous-programmes affichent

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z Arithmétique des pointeurs

Supposons que le tableau t contienne des int, sachant qu’un int occupe 2 octets en mémoire. Est-ce que (t + 1) est l’adresse du deuxième élément de t?

Mathématiquement, la réponse est non, l’adresse du deuxième élément est t+(la taille d⁰un int) = (t+2). Etant donné un tableau p d’éléments occupant chacun n octets en mémoire, l’adresse du i-ème élément est alors p + i × n.

Cependant, la pondération systématique de l’indice par la taille occupée en mémoire par chaque élément est d’une part une lourdeur dont on se passerait volontier, et d’autre part une source d’erreurs et de bugs. Pour y remédier, le compilateur prend cette partie du travail en charge,on ne pondérera donc pas les indices! Cela signifie, plus explicitement, que quel que soit le type des éléments du tableau p, l’adresse mémoire du i-ème élément de p est p + i. On le vérifie expérimentalement en exécutant le programme suivant :

#include<stdio .h>#define N 30

void initTab ( int? k , int n)

{

int i ; ?k = 1;

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

?(k + i ) = ?(k + i ? 1) + 1;

}

void afficheTab ( int? k , int n)

{

int i ;

for ( i = 0 ;            i < n ;         i++)

printf (”%d ” , ?(k + i )); printf (”\n” );

}

main()

{

int t [N] ; initTab (t , N);

}

La lecture du chapitre précédent, si vous y avez survécu, vous a probablement mené à une question que les élèves posent souvent : ”Monsieur pourquoi on fait c¸a?”. C’est vrai! Pourquoi on manipulerait les tableaux avec des pointeurs alors que dans les exemples que je vous ai donné, on peut le faire sans les pointeurs? Dans la mesure ou` un tableau est un pointeur, on peut, même à l’intérieur d’un sous-programme auquel un tableau a été passé en paramètre, manipuler ce tableau avec des crochets. Alors dans quel cas utiliserons-nous des pointeurs pour parcourir les tableaux?

De la même fac¸on qu’il existe des cas dans lesquels on connait l’adresse d’une variable scalaire mais pas son nom, il existe des tableaux dont on connait l’adresse mais pas le nom.

Un problème de taille

Lorsque l’on déclare un tableau, il est obligatoire de préciser sa taille. Cela signifie que la taille d’un tableau doit être connue à la compilation. Alors que faire si on ne connait pas cette taille? La seule solution qui se présente pour le moment est le surdimensionnement, on donne au tableau une taille très (trop) élevée de sorte qu’aucun débordement ne se produise.

Nous aimerions procéder autrement, c’est à dire préciser la dimension du tableau au moment de l’exécution. Nous allons pour cela rappeler quelques principes. Lors de la déclaration d’un tableau t, un espace mémoire alloué au stockage de la variable t, c’est à dire la variable qui contient l’adresse mémoire du premier élément du tableau. Et un autre espace mémoire est alloué au stockage des éléments du tableau. Il y a donc deux zones mémoires utilisées.

La fonction malloc

Vous pouvez demander au système d’exploitation de l’espace mémoire pour y stocker des valeurs. La fonction qui permet de réserver n octets est malloc(n). Si vous écrivez malloc(10), l’OS réserve 10 octets, cela s’appelle une allocation dynamique, c’est à dire une allocation de la mémoire au cours de l’exécution. Si vous voulez réserver de l’espace mémoire pour stocker un int par exemple, il suffit d’appeler malloc(2), car un int occupe 2 octets en mémoire.

En même temps, c’est bien joli de réserver de l’espace mémoire, mais ¸ca ne sert pas à grand chose si on ne sait pas ou` il se trouve! C’est pour ¸ca que malloc est une fonction. malloc retourne l’adresse mémoire du premier octet de la zone réservée. Par conséquent, si vous voulez créer un int, il convient d’exécuter l’instruction : p = malloc(2) ou` p est de type int?. Le malloc réserve deux octets, et retourne l’adresse mémoire de la zone allouée. Cette affectation place donc dans p l’adresse mémoire du int nouvellement créé.

Cependant, l’instruction p = malloc(2) ne peut pas passer la compilation. Le compilateur vous dira que les types void? et int? sont incompatibles (incompatible types in assignement). Pour votre culture générale, void? est le type ”adresse mémoire” en C. Alors que int? est le type ”adresse mémoire d’un int”. Il faut donc dire au compilateur que vous savez ce que vous faites, et que vous êtes suˆr que c’est bien un int que vous allez mettre dans la variable pointée. Pour ce faire, il convient d’effctuer ce que l’on appelle un cast, en ajoutant, juste après l’opérateur d’affectation, le type de la variable se situant à gauche de l’affectation entre parenthèses. Dans l’exemple ci-avant, cela donne : int? p = (int?)malloc(2).

Voici un exemple illustrant l’utilisation de malloc.

#include<stdio .h>

#include<malloc .h>

main()

{

int? p;

printf (”%d\n” , ?p );

}

Vous remarquez que nous sommes bien dans un cas ou` l’on connait l’adresse d’une variable mais pas son nom. Le seul moyen de manier la variable allouée dynamiquement est d’utiliser un pointeur.

La fonction free

Lorsque que l’on effectue une allocation dynamique, l’espace réservé ne peut pas être alloué pour une autre variable. Une fois que vous n’en avez plus besoin, vous devez le libérer explicitement si vous souhaitez qu’une autre variable puisse y être stockée. La fonction de libération de la mémoire est free. free(v) ou` v est une variable contenant l’adresse mémoire de la zone à libérer. A chaque fois que vous allouez une zone mémoire, vous devez la libérer! Un exemple classique d’utilisation est :

#include<stdio .h>

#include<malloc .h>

main()

{

int? p;

p = ( int ?) malloc (2); ?p = 28;

printf (”%d\n” , ?p ); free (p ); }

Notez bien que la variable p, qui a été allouée au début du main, a été libéré par le free(p).

La valeur NULL

La pointeur p qui ne pointe aucune adresse a la valeur NULL. Attention, il n’est pas nécessairement initialisé à NULL, NULL est la valeur que, conventionnellement, on décide de donner à p s’il ne pointe sur aucune zone mémoire valide. Par exemple, la fonction malloc retourne NULL si aucune zone mémoire adéquate n’est trouvée. Il convient, à chaquemalloc, de vérifier si la valeur retournée par malloc est différente de NULL. Par exemple,

#include<stdio .h>

#include<malloc .h>

main()

{

int? p;

p = ( int ?) malloc (2);

if (p == NULL) exit (0);

?p = 28;

printf (”%d\n” , ?p ); free (p ); }

L’allocation dynamique d’un tableau

Lors de l’allocation dynamique d’un tableau, il est nécessaire de déterminer la taille mémoire de la zone de la zone à occuper. Par exemple, si vous souhaitez allouer dynamiquament un tableau de 10 variables de type char. Il suffit d’exécuter l’instruction malloc(10), car un tableau de 10 char occupe 10 octets en mémoire. Si par contre, vous souhaitez allouer dynamiquement un tableau de 10 int, il conviendra d’exécuter malloc(20), car chaque int occupe 2 octets en mémoire.

Pour se simplifier la vie, le compilateur met à notre disposition la fonction sizeof, qui nous permet de calculer la place prise en mémoire par la variable d’un type donné. Par exemple, soit T un type, la valeur sizeof(T) est la taille prise en mémoire par une variable de type T. Si par exemple on souhaite allouer dynamiquement un int, il convient d’exécuter l’instruction malloc(sizeof(int)). Attention, sizeof prend en paramètre un type!

Si on souhaite allouer dynamiquement un tableau de n variables de type T, on exécute l’instruction malloc(n?sizeof(T)). Par exemple, pour allouer un tableau de 10 int, on exécute malloc(10?sizeof(int)). Voici une variante du programme d’un programme précédent :

#include<stdio .h>

#include<malloc .h>#define N 26

void initTab ( int? k , int n)

{

int i ;

for ( i = 0 ;            i < n ;         i++)

?(k + i ) = i + 1;

}

void afficheTab ( int? k , int n)

{

int i ;

for ( i = 0 ;            i < n ;         i++)

printf (”%d ” , ?(k + i )); printf (”\n” );

}

int main()

{

int? p;

p = ( int ?) malloc (N?sizeof ( int ));

if (p == NULL) return ?1;

initTab (p, N); afficheTab (p, N); free (p );

return 0;

}

Permutation de deux variables

A titre de rappel, observez attentivement le programme suivant :

#include<stdio .h>

void echange ( int x , int y)

{

int t = x ;

x = y ; y = t ;

}

void main()

{

int a = 1; int b = 2;

printf (”a = %d, b = %d\n” , a , b );

echange (a , b );

printf (”a = %d, b = %d\n” , a , b );

}

A votre avis, affiche-t-il

a = 1, b = 2 a = 2, b = 1 ou bien

a = 1, b = 2 a = 1, b = 2

Méditons quelque peu : la question que l’on se pose est ”Est-ce que le sous-programme echange échange bien les valeurs des deux variables a et b”? Il va de soi qu’il échange bien les valeurs des deux variables x et y, mais comme ces deux variables ne sont que des copies de a et b, cette permutation n’a aucun effet sur a et b. Cela signifie que la fonction echange ne fait rien, on aurait pu écrire à la place un sous-programme ne contenant aucune instruction, l’effet aurait été le même. Ce programme affiche donc

a = 1, b = 2 a = 1, b = 2

Remarques

Ceux dont la mémoire n’a pas été réinitialisé pendant les vacances se souviennent certainement du fait qu’il était impossible de passer en paramètre des variables scalaires par référence. J’ai menti, il existe un moyen de passer des paramètres par référence, et vous aviez des indices vous permettant de vous en douter! Par exemple, l’instruction scanf(”%d”,&x) permet de placer une valeur saisie par l’utilisateur dans x, et scanf est un sous-programme Vous conviendrez donc que la variablexa été passée en paramètre par référence. Autrement dit, que la valeur de x est modifiée dans le sous-programme scanf, donc que la variable permettant de désigner x dans le corps de ce sous-programme n’est pas une copie de x, mais la variable x elle-même, ou plutôt un alias de la variablex.

Vous pouvez d’ores et déjà retenir que

nomsousprogramme( ,&x, )

nomsousprogramme( ,x, )

passe en paramètre la valeur de x, alors que

nomsousprogramme( ,&x, )

passe en paramètre l’adresse de x, c’est-à-dire un moyen de retrouver la variable x depuis le sousprogramme et de modifier sa valeur.

Cependant, si vous écrivez echange(&a,&b), le programme ne compilera pas En effet, le sous-programme echange prend en paramètre des int et si vous lui envoyez des adresses mémoire à la place, le compilateur ne peut pas ”comprendre” ce que vous voulez faire Vous allez donc devoir modifier le sous-programme echange si vous voulez lui passer des adresses mémoire en paramètre.

Utilisation de pointeurs

On arrive à la question suivante : dans quel type de variable puis-je mettre l’adresse mémoire d’une variable de type entier? La réponse est int?, un pointeur sur int. Observons le sous-programme suivant,

void echange ( int? x , int? y)

{

int t = ?x ; ?x = ?y ;

?y = t ;

}

x et y ne sont pas des int, mais des pointeurs sur int. De ce fait le passage en paramètre des deux adresses &a et &b fait pointer x sur a et y sur b. Donc ?x est un alias de a et ?y est un alias de b. Nous sommes, comme décrit dans l’introduction de ce chapitre dans un cas dans lequel on connait l’adresse d’une variable, mais pas son nom : dans le sous-programme echange, la variable a est inconnue (si vous l’écrivez, c¸a ne compilera pas ), seul le pointeur ?x permet d’accéder à la variable a.

Il suffit donc, pour écrire un sous-programme prenant en paramètre des variables passées par référence, de les déclarer comme des pointeurs, et d’ajouter une ? devant à chaque utilisation.

Supposons que l’on dispose d’un programme permettant saisir 10 entiers dans un tableau.

#include<stdio .h>

int main()

{

int t [10] ,       i ;

for ( i = 0;           i < 10 ;         i++)

{

printf (” Saisir un entier : ” ); scanf (”%d” , t + i );

}

printf (”\n” );

return 0;

}

Le problème qui se pose est que lorsque l’on sort de ce programme, les données saisies sont perdues. Si l’on souhaite les avoir à disposition pour d’une exécution ultérieure, il convient d’utiler une mémoire persistante, c’est-à-dire qui conserve les données entre deux exécutions. On utilise pour ce faire un fichier. Un fichier est une mémoire stockée de fa¸con permanente sur un disque et à laquelle on accède avec un nom. Les données dans un fichier se présentent de fa¸con séquentielle, et donc se lisent ou s’écrivent du début vers la fin.

Nous survolerons dans ce cours un ensemble de fonctions de stdio.h permettant de manier des fichiers.

Pour plus détails, il est très hautement recommandé de se reporter à la documentation.

Pour accéder au contenu d’un fichier en lecture ou en écriture, on utilise les deux fonctions fopen et fclose.

La fonction fopen

fopen permet, comme son nom l’indique, d’ouvrir un fichier. Son prototype est FILE *fopen(const char

*path, const char *mode) :

–    path est une chaˆ?ne de caractère contenant le chemin (relatif ou absolu) et le nom du fichier. Si le fichier est dans le répertoire dans lequel s’exécute le programme, alors le nom du fichier suffit.

–    mode est une chaˆ?ne de caractère contenant "r" pour ouvrir le fichier en mode lecture, "w" en mode

écriture, etc.

–    FILE* est un type permettant de référencer un fichier ouvert, fopen retourne NULL s’il est impossible d’ouvrir le fichier (par exemple si le nom est incorrect). La valeur retournée devra être placée dans une variable de type FILE*, c’est cette valeur qui permettra par la suite d’accéder au contenu du fichier.

La fonction fclose

fclose sert à fermer un fichier. Son prototype est int fclose(FILE *fp) :

–    fp est la variable de type FILE* permettant de référencer le fichier à fermer.

Utilisation

Si l’on souhaite par exemple lire dans un fichier s’appelant "" :

#include<stdio .h>

int main()

{

FILE? f ; f = fopen (”toto . txt” , ”r” ); if ( f == NULL)

{

                     printf (”Erreur                   lors de l ’ ouverture du fichier                   toto . txt\n” );

return ?1;

}

/?

Lecture      dans     le      fi ch ier

. . .

?/

if ( fclose ( f ) != 0)

{

                     printf (”Erreur            lors de la               fermeture du fichier              toto . txt\n” );

return ?1;

}

return 0;

}

Il existe plusieurs fac¸ons de lire dans un fichier : caractère par caractère, ligne par ligne, par paquets de caractères, etc. Chaque lecture se faisant à l’aide d’une fonction appropriée. Lors d’un traitement se faisant à partir d’une lecture dans un fichier, on appelle de fa¸con itérée une fonction de lecture faisant avancer un curseur dans un fichier jusqu’à ce que la fin du fichier soit atteinte.

L’écriture fonctionne de fac¸on analogue, à un détail près : il est inutile d’écrire le caractère de fin de fichier, il est ajouté automatiquement lors du fclose.

Caractère par caractère

La fonction int fgetc(FILE* stream) retourne un caractère lu dans le fichier f. Bien que le caractère lu soit un octet, il est retourné dans un int. Le caractère EOF indique que la fin du fichier a été atteinte. Par exemple,

#include<stdio .h>

int main()

{

FILE? f ; char c ;

f = fopen (”toto . txt” , ”r” ); if ( f == NULL)

{

                     printf (”Erreur                   lors de l ’ ouverture du fichier                   toto . txt\n” );

return ?1;

}

while (( c = fgetc ( f )) != EOF)

if ( fclose ( f ) != 0)

{

                     printf (”Erreur            lors de la               fermeture du fichier              toto . txt\n” );

return ?1;

}

return 0;

}

On écrit un caractère dans un fichier à l’aide de la fonction int fputc(int c, FILE* stream).

#include<stdio .h>

int main()

{

FILE? f ; char c [7] = ”Toto ! ” ;

int i ;

f = fopen (”toto . txt” , ”w” ); if ( f == NULL)

{

                     printf (”Erreur                   lors de l ’ ouverture du fichier                   toto . txt\n” );

return ?1;

}

for ( i = 0 ; i < 6 ; i++) fputc (c [ i ] , f );

if ( fclose ( f ) != 0)

{

                     printf (”Erreur            lors de la               fermeture du fichier              toto . txt\n” );

return ?1;

}

return 0;

}

Par chaˆ?nes de caractères

Les deux fonctions char *fgets(char *s, int size, FILE *stream) et int fputs(const char *s, FILE *stream) permettent de lire et d’écrire des chaˆ?nes de caractères dans des fichiers, voir la documentation pour plus de détails.

Par paquets

Les deux fonctions size t fread(void *ptr, size t size, size t nmemb, FILE *stream) et size t fwrite(const void *ptr, size t size, size t nmemb, FILE *stream) sont très utiles lorsque l’on veut sauvegarder un tableau dans un fichier, ou recopier un fichier dans un tableau (voir la documentation pour plus de détails). Voici tout de même deux exemples :

#include<string .h>#include<stdio .h>

struct personne

{ char nom[3 0] ;

int age ;

};

int main( int argv , char?? argc )

{

FILE? f ; struct personne            repertoire [3] =

fwrite ( repertoire , 3 , sizeof ( struct personne ) , f ); fclose ( f );

return 0;

}

#include<string .h>#include<stdio .h>

struct personne

{ char nom[3 0] ;

int age ;

};

int main( int argv , char?? argc )

{

FILE? f ;

int i , n = 0;

struct personne          repertoire [ 3 ] ;

f = fopen (”toto . txt” , ”r” ); if ( f == NULL) return 1;

while( fread ( repertoire + n,                   1 , sizeof ( struct personne ) ,           f ))

n++;

for ( i = 0 ;             i < n ;         i++)

                                printf (”%s %d\n” ,           repertoire [ i ] . nom,            repertoire [ i ] . age );

fclose ( f );

return 0;

}

Plusieurs problèmes surviennent lorsque l’on utilise des tableaux pour stocker des valeurs :

–    En cas de redimensionnement, il faut refaire une allocation dynamique et recopier tout le tableau.

–    En cas d’insertion ou de suppression d’un élément, il faut décaler vers la gauche ou vers la droite tous les successeurs.

–    Concaténer ou fusionner des tableaux est une opération lourde au niveau mémoire.

–    Tous les éléments doivent être stockés dans des zones contigu¨es, l’allocation est donc un lourd travail lorsque la mémoire est fragmentée.

–    Bref, de nombreuses opérations sont lourdes en temps d’exécution.

Nous définirons dans ce cours un autre moyen de stocker les données en formant un ensemble ordonné, le listes chaˆ?nées.

Soit T un type structuré défini comme suit :

typedef struct T

{

int i ;

char c ;

}T;

#include<stdio .h>

#include<malloc .h>

#include<stdlib .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct point

{

double abs ; double ord ;

}point ;

/??????????????????????????????????????????????????????????????/

point nextPoint ( point? previous )

{ point   result ; result . ord = (? previous ). ord + 1.; result . abs = (? previous ). abs + 2.;

return result ;

}

/??????????????????????????????????????????????????????????????/void initTableauPoints ( point? p, int n)

{

int i ; (?p ). ord = 0; (?p ). abs = 1;

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

?(p + i ) = nextPoint (p + i ? 1);

}

/??????????????????????????????????????????????????????????????/

void affichePoint ( point? p)

{

               printf (”(%f , %f )” , (?p ). abs ,              (?p ). ord );

}

/??????????????????????????????????????????????????????????????/

void afficheTableauPoints ( point? p, int n)

{

int i ;

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

{

printf (”p[%d] = ” , i ); affichePoint (p + i ); printf (”\n” );

}

}

/??????????????????????????????????????????????????????????????/

int main()

{

point? p;

p = ( point ?) malloc (N ? sizeof ( point ));

if (p == NULL) exit (0);

initTableauPoints (p, N); afficheTableauPoints (p, N); free (p );

return 0;

}

L’écriture (?p).i permet de désigner le champ i de la variable pointée par p. Cette écriture, peu commode, peut être remplacée par p? > i, par exemple :

#include<stdio .h>

#include<malloc .h>

#include<stdlib .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct point

{

double abs ;

double ord ;

}point ;

/??????????????????????????????????????????????????????????????/

{ point result ; result . ord = previous?>ord + 1.; result . abs = previous?>abs + 2.;

return result ;

}

/??????????????????????????????????????????????????????????????/

void initTableauPoints ( point? p, int n)

{

int i ;

p?>ord = 0; p?>abs = 1;

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

?(p + i ) = nextPoint (p + i ? 1);

}

/??????????????????????????????????????????????????????????????/

void affichePoint ( point? p)

{

printf (”(%f , %f )” , p?>abs , p?>ord );

}

/??????????????????????????????????????????????????????????????/

void afficheTableauPoints ( point? p, int n)

{

int i ;

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

{

printf (”p[%d] = ” , i ); affichePoint (p + i ); printf (”\n” );

}

}

/??????????????????????????????????????????????????????????????/

main()

{

point? p;

p = ( point ?) malloc (N ? sizeof ( point ));

if (p == NULL) exit (0);

initTableauPoints (p, N); afficheTableauPoints (p, N); free (p ); }

Attention! Les opérateurs d’accès aux champs . et -> ont une priorité supérieure à celles de tous les autres opérateurs du langage! Si vous manipulez un tableau de structures t et que vous souhaitez accéder au champ t du i-ème élément, est-il intelligent d’écrire *(i + t).c? Absolument pas! . est prioritaire sur *, donc le parenthèsage implicite est *((i + t).c), essayez de vous représenter ce que cela fait, et vous comprendrez pourquoi votre programme plante! En écrivant (i + t)->c, vous obtenez une expression équivalente à (*(i + t)).c, qui est déjà bien plus proche de ce que l’on souhaite faire.

Considérons le type suivant :

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

On appelle cette forme de type un type récursif, c’est-à-dire qui contient un pointeur vers un élément du même type. Observons l’exemple suivant :

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/

int main()

{

maillon m, p; maillon? ptr ; m. data = 1;

m. next = &p;

p. data = 2;

p. next = NULL;

for ( ptr = &m ;             ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

return 0;

}

m et p sont deux maillons, et m->next pointe vers p, cela signifie que lorsque l’on initialise ptr à &m, alors ptr pointe sur m. Donc, lors de la première itération de la boucle for, la valeur prt->data est m.data, à savoir 1. Lorsque le pas de la boucle est exécuté, ptr re¸coit la valeur ptr->next, qui n’est autre que m->next, ou encore &p. Donc ptr pointe maintenant sur p. Dans la deuxième itération de la boucle, ptr->data est la valeur p.data, à savoir 2. Ensuite le pas de la boucle est exécuté, et ptr prend la valeur ptr->next, à savoir p->next, ou encore NULL. Comme ptr == NULL, alors la boucle s’arrête. Ce programme affiche donc :

data = 1 data = 2

La fa¸con de renseigner les valeurs des pointeurs next observée dans l’exemple précédent s’appelle le chaˆ?nage. Une liste de structures telle que chaque variable structurée contienne un pointeur vers vers une autre variable du même type s’appelle une liste chaˆ?née. Utilisons un tableau pour stocker les

éléments d’une liste chaˆ?née à 10 éléments.

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/

void printData ( maillon? ptr )

{

printf (”data = %d\n” , ptr?>data );

}

/??????????????????????????????????????????????????????????????/

int main()

{

maillon? l ; int i ;

l = ( maillon ?) malloc (N ? sizeof ( maillon )); if ( l == NULL) exit (0);

l?>data = 0;

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

{

( l + i)?>data = i ;

( l + i ? 1)?>next = l + i ;

}

( l + N ? 1)?>next = NULL; printData ( l );

free ( l );

return 0;

}

Les 10 maillons de la liste chaˆ?née ont été placés dans le tableau l, la première boucle dispose le chaˆ?nage des éléments dans le même ordre que dans le tableau, l’affichage de la liste est fait dans le sous-programme printfData, et seul le chaˆ?nage y est utilisé. Comme le champ data du i-ème élément de la liste contient la valeur i, alors ce programme affiche :

data = 0 data = 1 data = 2 data = 3 data = 4 data = 5 data = 6 data = 7 data = 8 data = 9

Pour modifier l’ordre de parcours des maillons, il suffit de modifier le chaˆ?nage, par exemple,

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ; struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/

void printData ( maillon? ptr )

{

for (    ;         ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

}

/??????????????????????????????????????????????????????????????/

int main()

{

maillon? l ; int i ;

l = ( maillon ?) malloc (N ? sizeof ( maillon )); if ( l == NULL) exit (0);

l?>data = 0;

( l + 1)?>data = 1;

( l + N ? 2)?>next = l + 1; ( l + N ? 1)?>next = NULL;

for ( i = 2 ;           i < N ;         i+=1)

{

( l + i)?>data = i ;

( l + i ? 2)?>next = l + i ;

} printData ( l );

free ( l );

}

Ce programme affiche

data = 0 data = 2 data = 4 data = 6 data = 8 data = 1 data = 3 data = 5 data = 7 data = 9

malloc

Pour le moment, nous avons stocké les éléments dans un tableau, les maillons étaient donc regroupés dans des zones mémoire contigu¨es. Il est possible de stocker les maillons dans les zones non contigu¨es, tous peuvent être retrouvés à l’aide du chaˆ?nage. Par exemple,

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

void printData ( maillon? ptr )

{

for (    ;         ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

}

/??????????????????????????????????????????????????????????????/

void freeLL ( maillon? l )

{

maillon? n;

while( l != NULL)

{

n = l?>next ; free ( l ); l = n;

}

}

/??????????????????????????????????????????????????????????????/

int main()

{

maillon?	l ;
maillon?	current ;
maillon? int i ;	previous ;

l = ( maillon ?) malloc ( sizeof ( maillon )); if ( l == NULL) exit (0);

l?>data = 0; previous = l ;

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

{ current = ( maillon ?) malloc ( sizeof ( maillon )); if ( current == NULL) exit (0);

current?>data = i ; previous?>next = current ;

previous = current ;

}

current?>next = NULL; printData ( l ); freeLL ( l );

return 0;

}

Ce programme affiche

data = 0 data = 1 data = 2 data = 3 data = 4 data = 5 data = 6 data = 7 data = 8 data = 9

Pour plus de clarté, on placera l’initialisation de la liste dans une fonction :

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

{

int data ; struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/void printLL ( maillon? ptr )

{

for (    ;         ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

}

/??????????????????????????????????????????????????????????????/

maillon? initLL ( int n)

{

maillon?	f i r s t ;
maillon?	current ;
maillon? int i ;	previous ;

f i r s t = ( maillon ?) malloc ( sizeof ( maillon )); if ( f i r s t == NULL) exit (0);

first ?>data = 0; previous = f i r s t ;

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

{ current = ( maillon ?) malloc ( sizeof ( maillon )); if ( current == NULL) exit (0);

current?>data = i ; previous?>next = current ;

previous = current ;

}

current?>next = NULL;

return f i r s t ;

}

/??????????????????????????????????????????????????????????????/

void freeLL ( maillon? l )

{

maillon? n;

while( l != NULL)

{

n = l?>next ; free ( l ); l = n;

}

}

/??????????????????????????????????????????????????????????????/

int main()

{

maillon? l ; l = initLL (N);

printLL ( l ); freeLL ( l );

return 0;

}

Observons de quelle fa¸con il est possible d’effectuer certaines opérations sur une liste chaˆ?née. Les sousprogrammes ci-dessous ont été pensé et combinés pour être les plus simples possibles

Création d’un maillon

maillon? creeMaillon ( int n)

{

maillon? l ; l = ( maillon ?) malloc ( sizeof ( maillon )); if ( l == NULL) exit (0);

l?>data = n; l?>next = NULL;

return l ;

}

Insertion au début d’une liste chaˆ?née

maillon? insereDebutLL ( maillon? l , int n)

{

         maillon?            f i r s t = creeMaillon (n );

first ?>next = l ;

return f i r s t ;

}

Création d’une liste chaˆ?née {0, ,n ? 1}

maillon? initLL ( int n)

{

for ( i = n ? 1 ; i >= 0 ; i??) l = insereDebut ( l , i );

return l ;

}

Un maillon d’une liste doublement chaˆ?née contient deux pointeurs, un vers le maillon précédent, et un vers le maillon suivant.

typedef struct dmaillon

{

int data ; struct dmaillon? previous ; struct dmaillon? next ;

}dmaillon ;

Aussi paradoxal que cela puisse paraˆ?tre, bon nombre d’opérations sont davantage aisées sur des listes doublement chaˆ?nées. Pour se faciliter la tâche, nous manipulerons les listes chaˆ?nées à l’aide de deux pointeurs, un vers son premier élément, et un vers son dernier :

typedef struct dLinkedList

{

struct dmaillon?          f i r s t ; struct dmaillon? last ;

}dLinkedList ;

Le soin d’ecrire les opérations sur ces listes vous est laissé dans le TP

Chapitre 2

Exercice 1 - Saisie et affichage

Saisir une variable entière, afficher sa valeur.

Exercice 2 - Permutation de 2 variables

Saisir deux variables et les permuter avant de les afficher.

Exercice 3 - Permutation de 4 valeurs

Ecrire un programme demandant à l’utilisateur de saisir 4 valeurs A,B,C,D et qui permute les variables de la fac¸on suivante :

noms des variables valeurs avant la permutation valeurs après la permutation

Exercice 4 - Permutation de 5 valeurs

On considère la permutation qui modifie cinq valeurs de la fa¸con suivante :

noms des variables valeurs avant la permutation valeurs après la permutation

Ecrire un programme demandant à l’utilisateur de saisir 5 valeurs que vous placerez dans des variables appelées A, B, C, D et E. Vous les permuterez ensuite de la fa¸con décrite ci-dessus.

Exercice 5 - Saisie et affichage

Saisir une variable de type float, afficher sa valeur.

Exercice 6 - Moyenne arithmétique Saisir 3 valeurs, afficher leur moyenne.

Exercice 7 - Surface du rectangle

Demander à l’utilisateur de saisir les longueurs et largeurs d’un rectangle, afficher sa surface.

Demander à l’utilisateur de saisir deux valeurs a et b, afficher ensuite la différence entre la moyenne

?

arithmétiqueet la moyenne géométrique ab. Pour indication, sqrt(f) est la racine carrée du flottant f, cette fonction est disponible en important #include<math.h>.

Exercice 9 - Cartons et camions

Nous souhaitons ranger des cartons pesant chacun k kilos dans un camion pouvant transporter M kilos de marchandises. Ecrire un programme C demandant à l’utilisateur de saisir M et k, que vous représenterez avec des nombres flottants, et affichant le nombre (entier) de cartons qu’il est possible de placer dans le camion. N’oubliez pas que lorsque l’on affecte une valeur flottante à une variable entière, les décimales sont tronquées.

Exercice 10 - Prise en main

Affectez le caractère ’a’ à une variable de type char, affichez ce caractère ainsi que son code ASCII.

Exercice 11 - Successeur

Ecrivez un programme qui saisit un caractère et qui affiche son successeur dans la table des codes ASCII.

Exercice 12 - Casse

Ecrivez un programme qui saisit un caractère miniscule et qui l’affiche en majuscule.

Exercice 13 - Codes ASCII

Quels sont les codes ASCII des caractères ’0’, ’1’, , ’9’

Exercice 14 - Codage d’adresses IP

Une adresse IP est constituée de 4 valeurs de 0 à 255 séparées par des points, par exemple 192.168.0.1, chacun de ces nombres peut se coder sur 1 octet. Comme une variable de type long occupe 4 octets en mémoire, il est possible de s’en servir pour stocker une adresse IP entière. Ecrivez un programme qui saisit dans des unsigned short les 4 valeurs d’une adresse IP, et place chacune d’elle sur un octet d’une variable de type long. Ensuite vous extrairez de cet entier les 4 nombres de l’adresse IP et les afficherez en les séparant par des points.

Exercice 15 - Permutation circulaire des bits

Exercice 16 - Permutation de 2 octets

Permutez les deux octets d’une variable de type unsigned short saisie par l’utilisateur.

Exercice 17 - Inversion de l’ordre de 4 octets

Inversez l’ordre des 4 octets d’une variable de type long saisie par l’utilisateur. Utilisez le code du programme sur les adresses IP pour tester votre programme.

Exercice 18 - Pièces de monnaie

Nous disposons d’un nombre illimité de pièces de 0.5, 0.2, 0.1, 0.05, 0.02 et 0.01 euros. Nous souhaitons,

étant donné une somme S, savoir avec quelles pièces la payer de sorte que le nombre de pièces utilisée soit minimal. Par exemple, la somme de 0.96 euros se paie avec une pièce de 0.5 euros, deux pièces de 0.2 euros, une pièce de 0.05 euros et une pièce de 0.01 euros.

1.    Le fait que la solution donnée pour l’exemple est minimal est justifié par une idée plutôt intuitive. Expliquez ce principe sans excès de formalisme.

2.    Ecrire un programme demandant à l’utilisateur de saisir une valeur comprise entre 0 et 0.99. Ensuite, affichez le détail des pièces à utiliser pour constituer la somme saisie avec un nombre minimal de pièces.

Exercice 19 - Modification du dernier bit

Modifiez le dernier bit d’une variable a saisie par l’utilisateur.

Exercice 20 - Associativité de l’addition flottante

L’ensemble des flottants n’est pas associatif, cela signifie qu’il existe trois flottants a, b et c, tels que (a + b) + c 6= a + (b + c). Trouvez de tels flottants et vérifiez-le dans un programme.

Exercice 21 - Permutation sans variable temporaire Permutez deux variables a et b sans utiliser de variables temporaires.

Exercice 1 - Majorité

Saisir l’âge de l’utilisateur et lui dire s’il est majeur.

Exercice 2 - Valeur Absolue

Saisir une valeur, afficher sa valeur absolue.

Exercice 3 - Admissions

Exercice 4 - Assurances

Une compagnie d’assurance effectue des remboursements sur lesquels est ponctionnée une franchise correspondant à 10% du montant à rembourser. Cependant, cette franchise ne doit pas excéder 4000 euros. Demander à l’utilisateur de saisir le montant des dommages, afficher ensuite le montant qui sera remboursé ainsi que la franchise.

Exercice 5 - Valeurs distinctes parmi 2

Afficher sur deux valeurs saisies le nombre de valeurs disctinctes.

Exercice 6 - Plus petite valeur parmi 3

Afficher sur trois valeurs saisies la plus petite.

Exercice 7 - Recherche de doublons

Ecrire un algorithme qui demande à l’utilisateur de saisir trois valeurs et qui lui dit s’il s’y trouve un doublon.

Exercice 8 - Valeurs distinctes parmi 3

Afficher sur trois valeurs saisies le nombre de valeurs disctinctes.

Exercice 9 -ax + b = 0

Saisir les coefficients a et b et afficher la solution de l’équation ax + b = 0.

Exercice 10 -ax² + bx + c = 0

Saisir les coefficients a, b et c, afficher la solution de l’équation ax² + bx + c = 0.

Dans le problème suivant, vous serez confronté au problème dit de saisie bufferisée (ce néologisme est très vilain). Explication : lorsque vous saisissez des valeurs au clavier, elles sont placées dans le tampon de saisie (buffer). Une fois que vous avez saisi ¡entrée¿, (le caractère ’\n’), les données sont lues directement dans le buffer par scanf. Mais cette fonction ne lira que le caractère qui a été saisi, et le ’\n’ qui a validé la saisie restera dans le buffer jusqu’à la prochaine saisie d’un caractère. L’instruction getchar(); lit un octet dans le buffer. Donc, à chaque fois que vous avez placé un ’\n’ dans le buffer, pensez à le vider avec un getchar();.

Exercice 11 - Calculatrice

Ecrire un programme demandant à l’utilisateur de saisir

–  deux valeurs a et b, de type int;

On indice les cases d’un échiquer avec deux indices i et j variant tous deux de 1 à 8. La case (i,j) est sur la ligne i et la colonne j. Par convention, la case (1,1) est noire.

Exercice 12 - Couleurs

Ecrire un programme demandant à l’utilisateur de saisir les deux coordonnées i et j d’une case, et lui disant s’il s’agit d’une case blanche ou noire.

Exercice 13 - Cavaliers

Ecrire un programme demandant à l’utilisateur de saisir les coordonnées (i,j) d’une première case et les coordonnées (i⁰,j⁰) d’une deuxième case. Dites-lui ensuite s’il est possible de déplacer un cavalier de (i,j)

à (i⁰,j⁰).

Exercice 14 - Autres pièces

Même exercice avec la tour, le fou, la dame et le roi. Utilisez un switch et présentez le programme de la sorte :

Quelle piece souhaitez-vous deplacer ?

0    = Cavalier

1    = Tour 2 = Fou

3    = Dame

4    = Roi

3

Saisissez les coordonnees de la case de depart :

A = 2

A = 1

Saisissez les coordonnees de la case d’arrivee :

A = 6

A = 5

Le mouvement (2, 1) -> (6, 5) est valide.

Exercice 15 - Opérations sur les heures

Ecrire un programme qui demande à l’utilisateur de saisir une heure de début (heures + minutes) et une heure de fin (heures + minutes aussi). Ce programme doit ensuite calculer en heures + minutes le temps écoulé entre l’heure de début et l’heure de fin. Si l’utilisateur saisit 10h30 et 12h15, le programme doit lui afficher que le temps écoulé entre l’heure de début et celle de fin est 1h45. On suppose que les deux heures se trouvent dans la même journée, si celle de début se trouve après celle de fin, un message d’erreur doit s’afficher. Lors la saisie des heures, séparez les heures des minutes en demandant à l’utilisateur de saisir :

–    heures de début

–    minutes de début

–    heures de fin

–    minutes de fin

Exercice 16 - Le jour d’après

Allez sur \%C3\%A9e_bissextilepourconnatrelesrglesexactes, je vous avais dit que les années étaient bissextiles si et seulement si elles étaient divisible par 4, après vérification, j’ai constaté que c’était légèrement plus complexe. Je vous laisse vous documenter et retranscrire ces règles de la fac¸on la plus simple possible.

Exercice 17 - Intervalles bien formés

Demandez à l’utilisateur de saisir les deux bornes a et b d’un intervalle [a,b]. Contrôler les valeurs saisies.

Exercice 18 - Appartenance

Demandez-lui ensuite de saisir une valeur x, dites-lui si x ? [a,b]

Exercice 19 - Intersections

Demandez-lui ensuite de saisir les bornes d’un autre intervalle [a⁰,b⁰]. Contrôlez la saisie. Dites-lui ensuite si

–    [a,b] ? [a⁰,b⁰]

–    [a⁰,b⁰] ? [a,b] – [a⁰,b⁰] ? [a,b] = ?.

Exercice 20 - Rectangles

Nous représenterons un rectangle R aux cotés parallèles aux axes des abscisses et ordonnées à l’aide des coordonnées de deux points diamétralement opposés, le point en haut à gauche, de coordonnées (xHautGauche,yHautGauche), et le point en bas à droite, de coordonnées (xBasDroite,yBasDroite). Demander à l’utilisateur de saisir ces 4 valeurs, contrôlez la saisie.

Exercice 21 - Appartenance

Demandez à l’utilisateur de saisir les 2 coordonnées d’un point (x,y) et dites à l’utilisateur si ce point se trouve dans le rectangle R.

Exercice 22 - Intersection

Demandez à l’utilisateur de saisir les 4 valeurs

(xHautGauche⁰,yHautGauche⁰,xBasDroite⁰,yBasDroite⁰)

permettant de spécifier un deuxième rectangle R⁰. Précisez ensuite si

–    R ? R⁰ – R⁰ ? R

–    R ? R⁰ = ?

Exercice 23 - L’échiquer

Même exercice mais en utilisant le plus possible les spécifications suivantes :

#include<stdio .h>

#include<stdlib .h>

/?????????????????????????????????????????????????/

#define CAVALIER 0

#define TOUR 1

#define FOU 2

#define DAME 3

/?????????????????????????????????????????????????/

#define MAIN int main() \

{

/?????????????????????????????????????????????????/

#define FINMAIN return 0;\

}

/?????????????????????????????????????????????????/

#define SI if (

/?????????????????????????????????????????????????/

#define ALORS ){

/?????????????????????????????????????????????????/

#define SINON } else {

/?????????????????????????????????????????????????/

#define FINSI }

/?????????????????????????????????????????????????/

#define SUIVANT( var) switch( var ) {

/?????????????????????????????????????????????????/

#define FINSUIVANT( def ) default :                                    def }

/?????????????????????????????????????????????????/

#define CAS( valeur ,                                                            instructions ) case valeur               :                       instructions \ break;

/?????????????????????????????????????????????????/

#define PIECES LIST \ printf (”%hu = Cavalier\n” , CAVALIER); \ printf (”%hu = Tour\n” , TOUR); \ printf (”%hu = Fou\n” , FOU); \ printf (”%hu = Dame\n” , DAME); \ printf (”%hu = Roi\n” , ROI)

/?????????????????????????????????????????????????/

#define CHECKCOORD( i ) \

SI i<1 ||                        i>8 ALORS \

                        printf (”coordonnee                     invalide\n” ); \

return 1; \

FINSI

/?????????????????????????????????????????????????/

#define GET VAR(A, B) \ printf (”A = ” ); \ scanf (”%hu” , &B); \ CHECKCOORD(B);

/?????????????????????????????????????????????????/

#define PRINT VALID printf (”valide”)

/?????????????????????????????????????????????????/

#define FATAL ERROR printf (”System Error .                                             It                  is recommended that ” \

”you format your hard disk . ” ); \ return 1;

/?????????????????????????????????????????????????/

#define CONDITIONAL PRINT(cond) \

SI cond ALORS \

PRINT VALID; \

SINON \

PRINT INVALID; \

FINSI

Exercice 24 - conversion numérique ? fran¸cais (très difficile)

Ecrire un programme saisissant un unsigned long et affichant sa valeur en toutes lettres. Rappelons que 20 et 100 s’accordent en nombre s’ils ne sont pas suivis d’un autre mot (ex. : quatre-vingts, quatre-vingtun). Mille est invariable (ex. : dix mille) mais pas million (ex. : deux millions) et milliard (ex. : deux milliards). Depuis 1990, tous les mots sont séparés de traits d’union (ex. : quatre-vingt-quatre), sauf autour des mots mille, millions et milliard (ex. : deux mille deux-cent-quarante-quatre, deux millions quatre-cent mille deux-cents). (source : ). Par exemple,

Saisissez un nombre = 1034002054

1034002054 : un milliard trente-quatre millions deux mille cinquante-quatre

Vous prendrez soin de respecter les espacements, les tirets, et de ne pas faire de fautes d’orthographe. Vous userez et abuserez de macros-instructions pour simplifier le plus possible votre code.

Exercice 1

Qu’affiche le programme suivant?

#include<stdio .h>#define N 5

int main()

{

int a = 1 , b = 0;

while(a <= N)

b += a++;

printf (”%d, %d\n” , a , b );

return 0;

}

Exercice 2

Qu’affiche le programme suivant?

#include<stdio .h>

#define M 3 #define N 4

int main()

{

int a , b,           c = 0 , d;

for (a = 0 ; a < M ; a++)

{

d = 0; for (b = 0 ; b < N ; b++) d+=b; c += d

}

printf (”a = %d, b = %d, c = %d, d = %d” , a , b, c , d ); return 0;

}

Exercice 3

int main()

{

int a , b, c , d; a = 1; b = 2; c = a/b; d = (a==b)?3:4;

printf (”c = %d, d = %d\n” , c , d );

a     = ++b;b %= 3; printf (”a = %d, b = %d\n” , a , b );

b     = 1;

for (a = 0 ; a <= 10 ; a++)

c      = ++b;

printf (”a = %d, b = %d, c = %d, d = %d\n” , a , b, c , d ); return 0;

}

Les exercices suivants seront rédigés avec les trois types de boucle : tant que, répéter jusqu’à et pour.

Exercice 4 - Compte à rebours

Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant toutes les valeurs n,n ? 1, ,2,1,0.

Exercice 5 - Factorielle

Ecrire un programme calculant la factorielle (factorielle n = n! = 1 × 2 × × n et 0! = 1) d’un nombre saisi par l’utilisateur.

Pour les exercices suivants, vous choisirez la boucle la plus simple et la plus lisible.

Exercice 6 - Table de multiplication

Ecrire un programme affichant la table de multiplication d’un nombre saisi par l’utilisateur.

Exercice 7 - Tables de multiplications

Ecrire un programme affichant les tables de multiplications des nombres de 1 à 10 dans un tableau à deux entrées.

Exercice 8 - Puissance

Ecrire un programme demandant à l’utilisateur de saisir deux valeurs numériques b et n (vérifier que n est positif) et affichant la valeur bⁿ.

Exercice 9 - Approximation de 2 par une série

On approche le nombre 2 à l’aide de la série. Effectuer cette approximation en calculant un grand nombre de terme de cette série. L’approximation est-elle de bonne qualité?

Exercice 10 - Approximation de e par une série

Mêmes questions qu’à l’exercice précédent en e à l’aide de la série .

Exercice 11 - Approximation de e^x par une série

Calculer une approximation de e^x à l’aide de la série.

Exercice 12 - Conversion d’entiers en binaire

Exercice 13 - Conversion de décimales en binaire

Ecrire un programme qui affiche les décimales d’un double en binaire.

Exercice 14 - Inversion de l’ordre des bits

Ecrire un programme qui saisit une valeur de type unsigned short et qui inverse l’ordre des bits. Vous testerez ce programme en utilisant le précédent.

Exercice 15 - Joli carré

Ecrire un programme qui saisit une valeur n et qui affiche le carré suivant (n = 5 dans l’exemple) :

n = 5

X X X X X

X X X X X

X X X X X

X X X X X

X X X X X

Exercice 16 - Racine carrée par dichotomie

?

Ecrire un algorithme demandant à l’utilisateur de saisir deux valeurs numériques x et p et affichant x avec une précision p. On utilisera une méthode par dichotomie : à la k-ème itération, on cherche x dans l’intervalle [min,sup], on calcule le milieu m de cet intervalle (à vous de trouver comment le calculer).

Si cet intervalle est suffisament petit (à vous de trouver quel critère utiliser), afficher m. Sinon, vérifiez

?

si x se trouve dans [inf,m] ou dans [m,sup], et modifiez les variables inf et sup en conséquence. Par exemple, calculons la racine carrée de 10 avec une précision 0.5, ? ?

–    Commen¸cons par la chercher dans [0,10], on a m = 5, comme 5²> 10, alors 5 > 10, donc 10 se trouve dans l’intervalle [0,5].

–    On recommence, m = 2.5, comme      10, alors                10, on poursuit la recherche dans [

                                                                                                          ?            ?

–    On a m = 3.75, comme 3.75²> 10, alors 3.75 >               10?et     10?? [2.5,3.75]

–    On a m = 3.125, comme 3.125²< 10, alors 3.125 <       10 et       10 ? [3.125,3.75]

            mattion à 0.5 près de     10.

Une calculatrice de poche prend de fa¸con alternée la saisie d’un opérateur et d’une opérande. Si l’utilisateur saisit 3, + et 2, cette calculatrice affiche 5, l’utilisateur a ensuite la possibilité de se servir de 5 comme d’une opérande gauche dans un calcul ultérieur. Si l’utilisateur saisit par la suite ? et 4, la calculatrice affiche 20. La saisie de la touche = met fin au calcul et affiche un résultat final.

Exercice 17 - Calculatrice de poche

Implémentez le comportement décrit ci-dessus.

Exercice 18 - Puissance

Ajoutez l’opérateur $ qui calcule a^b, vous vous restreindrez à des valeurs de b entières et positives.

Exercice 19 - Opérations unaires

Ajoutez les opérations unaires racine carrée et factorielle.

Qu’affichent les programmes suivants?

Exercice 1

char C[ 4 ] ; int k ;

C[0] = ’a ’ ; C[3] = ’J ’ ; C[2] = ’k ’ ;

C[1] = ’R’ ; for (k = 0 ; k < 4 ; k++)

printf (”%c\n” , C[ k ] ) ;

for (k = 0 ; k < 4 ; k++)

C[ k]++;

for (k = 0 ; k < 4 ; k++)

printf (”%c\n” , C[ k ] ) ;

Exercice 2

int K[10] , i , j ; K[0] = 1; for ( i = 1 ; i < 10 ; i++)

K[ i ] = 0; for ( j = 1 ;     j <= 3 ;    j++) for ( i = 1 ;  i < 10 ;    i++)

K[ i ] += K[ i ? 1];

for ( i = 0 ;                 i < 10 ;         i++)

printf (”%d\n” , K[ i ] ) ;

Exercice 3

int K[10] ,            i ,     j ;

K[0] = 1;

K[1] = 1; for ( i = 2 ; i < 10 ; i++)

K[ i ] = 0; for ( j = 1 ;     j <= 3 ;    j++) for ( i = 1 ;  i < 10 ;    i++)

K[ i ] += K[ i ? 1];

for ( i = 0 ;                 i < 10 ;         i++)

printf (”%d\n” , K[ i ] ) ;

Exercice 4 - Initialisation et affichage

Exercice 5 - Initialisation avec une boucle Même exercice en initialisant le tableau avec une boucle.

Exercice 6 - somme

Affichez la somme des n éléments du tableau T.

Exercice 7 - recherche

Demandez à l’utilisateur de saisir un int et dites-lui si ce nombre se trouve dans T.

Exercice 8 - permutation circulaire

Effectuez une permutation circulaire vers la droite des éléments de T en utilisant un deuxième tableau.

Exercice 9 - permutation circulaire sans deuxième tableau Même exercice mais sans utiliser de deuxième tableau.

Exercice 10 - miroir

Inversez l’ordre des éléments de T sans utiliser de deuxième tableau.

Exercice 11 - modification du tableau

Etendez le tableau T à 20 éléments. Placez dans T[i] le reste modulo 17 de i².

Exercice 12 - min/max

Affichez les valeurs du plus petit et du plus grand élément de T.

Exercice 13 - recherche séquentielle

Demandez à l’utilisateur de saisir une valeur x et donnez-lui la liste des indices i tels que T[i] a la valeur x.

Exercice 14 - recherche séquentielle avec stockage des indices

Même exercice que précédemment, mais vous en affichant La valeur se trouve aux indices suivants : si x se trouve dans T, et La valeur n’a pas été trouvée si x ne se trouve pas dans T.

Exercice 15 - pièces de monnaie

Reprennez l’exercice sur les pièces de monnaie en utilisant deux tableaux, un pour stocker les valeurs des pièces dans l’ordre décroissant, l’autre pour stocker le nombre de chaque pièce.

Exercice 16 - recherche de la tranche minimale en O(n³)

Une tranche est délimitée par deux indices i et j tels que i ? j, la valeur d’une tranche est t_i + + t_j. Ecrire un programme de recherche de la plus petite tranche d’un tableau, vous utiliserez trois boucles imbriquées. Vous testerez votre algorithme sur un tableau T à 20 éléments aléatoires (utilisez la fonction random de stdlib.h) de signes quelconques.

Même exercice mais en utilisant deux boucles imbriquées.

Exercice 18 - recherche de la tranche minimale en O(n) (difficile) Même exercice mais en utilisant une seule boucle.

Question 1 - Affichage

Créer une chaˆ?ne de caractères contenant la valeur ”Les framboises sont perchees sur le tabouret de mon grand-pere.” et affichez-la avec %s. Vous donnerez au tableau la plus petite taille possible.

Question 2 - Affichage sans %s

Même exercice mais sans utiliser %s.

Question 3 - Longueur

Ecrire un programme saisissant proprement une chaˆ?ne de caractère (sans débordement d’indice, avec le caractère nul et en faisant le ménage dans le buffer) et calculant sans strlen la taille de chaˆ?ne (nombre de caractères sans compter le caractère nul).

Question 4 - Longueur sans retour chariot

Même exercice mais en supprimant de la chaˆ?ne l’éventuel caractère de validation de la saisie (retour à la ligne).

Question 5 - Extraction

Ecrire un programme saisissant proprement une chaˆ?ne de caractère t, deux indices i et j et recopiant dans une deuxième chaˆ?ne t⁰ la tranche [t_i, ,t_j].

Question 6 - Substitution

Ecrire un programme saisissant proprement une chaˆ?ne de caractère t, deux caractères a et b et substituant des a à toutes les occurrences de b.

string.h

Pour chacun des exercices suivants, vous vous documenterez sur les fonctions de string.h utiles et vous vous en servirez de fac¸on convenable. Et ne faites pas de saletés!

Question 7 - Comparaisons

Saisissez deux chaˆ?nes de caractères, déterminez la plus grande selon l’ordre lexicographique.

Question 8 - Longueur

Saisissez deux chaˆ?nes de caractères, déterminez la plus longue des deux..

Question 9 - Copie

Saisissez une chaˆ?ne de caractères, copiez-là dans une deuxième chaˆ?ne.

Question 10 - Concaténation

Saisissez deux chaˆ?nes de caractères, affichez la concaténation de la première à la suite de la deuxième.

Ecrire un programme saisissant un nom de fichier et affichant séparément le nom du fichier et l’extension. Vous prévoirez le cas ou` plusieurs extensions sont concaténées, par exemple : .

Question 12 - Expressions arithmétiques

Ecrire un programme saisissant une expression arithmétique totalement parenthésée, (par exemple 3+4, ((3 ? 2) + (7/3))) et disant à l’utilisateur si l’expression est correctement parenthésée.

Ecrire un programme demandant à l’utilisateur de saisir une valeur numérique positive n et affichant un carré, une croix et un losange, tous de coté n. Par exemple, si n = 10, l’exécution donne

Saisissez la taille des figures

10

*                                * * * * * * * * *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                * * * * * * * * *

*

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

*                                *

#include<stdio .h>

/?

Affiche         le            caractere c

?/

void afficheCaractere (char c)

{

}

/?????????????????????????????????????????/

/?

affiche n fois               le                                             caractere c , ne revient pas a		la	ligne
apres        le         dernier             caractere . ?/ void ligneSansReturn ( int n, char c) { } /?????????????????????????????????????????/ /?
affiche n fois le caractere c , revient a la le dernier caractere .	ligne		apres

?/

void ligneAvecReturn ( int n, char c)

{

}

/?????????????????????????????????????????/

/?

Affiche n espaces .

?/

void espaces ( int n)

{

}

/?????????????????????????????????????????/

/?

Affiche    le                     caractere c a la                  colonne i , ne revient pas a la         ligne               apres .

?/

void unCaractereSansReturn ( int i , char c)

{

}

/?????????????????????????????????????????/

/?

Affiche    le                     caractere c a la                  colonne i , revient a la      ligne                apres .

?/

void unCaractereAvecReturn( int i , char c)

{

}

/?????????????????????????????????????????/

/?

Affiche le caractere c aux colonnes i et j , revient a la ligne apres .

?/

void deuxCaracteres ( int i , int j , char c)

{

}

/?????????????????????????????????????????/

/?

Affiche un carre de cote n.

?/

void carre ( int n)

{

}

/?????????????????????????????????????????/

/?

Affiche un chapeau dont la pointe ? non affichee ? est sur la colonne centre , avec les caracteres c .

?/

void chapeau( int centre , char c)

{

}

/?

Affiche un chapeau a l ’ envers avec des                                  caracteres c ,

la                          pointe ? non affichee ? est a la                                 colonne centre

?/

void chapeauInverse ( int centre , char c)

{

}

/?????????????????????????????????????????/

/?

Affiche un losange de cote n.

?/

void losange ( int n)

{

}

/?????????????????????????????????????????/

/?

Affiche une croix de cote n

?/

void croix ( int n)

{

}

/?????????????????????????????????????????/

main()

{ int t a i l l e ;

printf (” Saisissez                 la                     t a i l l e         des                  figures \n” ); scanf (”%d” , &t a i l l e ); carre ( t a i l l e ); losange ( t a i l l e ); croix ( t a i l l e ); }

Exercice 1 - chiffres et nombres

Rapellons que a % b est le reste de la division entière de a par b.

1.    Ecrire la fonction int unites(int n) retournant le chiffre des unités du nombre n.

2.    Ecrire la fonction int dizaines(int n) retournant le chiffre des dizaines du nombre n.

3.    Ecrire la fonction int extrait(int n, int p) retourant le p-ème chiffre de représentation décimale de n en partant des unités.

4.    Ecrire la fonction int nbChiffres(int n) retournant le nombre de chiffres que comporte la représentation décimale de n.

5.    Ecrire la fonction int sommeChiffres(int n) retournant la somme des chiffres de n.

Exercice 2 - Nombres amis

1.    Ecrire une fonction int sommeDiviseursStricts(int n), elle doit renvoyer la somme des diviseurs stricts de n.

2.    Ecrire une fonction int sontAmis(int a, int b), elle doit renvoyer 1 si a et b sont amis, 0 sinon.

Exercice 3 - Nombres parfaits

Un nombre parfait est un nombre égal à la somme de ses diviseurs stricts. Par exemple, 6 a pour diviseurs stricts 1, 2 et 3, comme 1 + 2 + 3 = 6, alors 6 est parfait.

1.    Est-ce que 18 est parfait?

2.    Est-ce que 28 est parfait?

3.    Que dire d’un nombre ami avec lui-même?

4.    Ecrire la fonction int estParfait(int n), elle doit retourner 1 si n est un nombre parfait, 0 sinon.

Exercice 4 - Nombres de Kaprekar

Un nombre n est un nombre de Kaprekar en base 10, si la représentation décimale de n² peut être séparée en une partie gauche u et une partie droite v tel que u + v = n. 45² = 2025, comme 20 + 25 = 45, 45 est aussi un nombre de Kaprekar. 4879² = 23804641, comme 238 + 04641 = 4879 (le 0 de 046641 est inutile, je l’ai juste placé pour éviter toute confusion), alors 4879 est encore un nombre de Kaprekar.

1.    Est-ce que 9 est un nombre de Kaprekar?

2.    Ecrire la fonction int sommeParties(int n, int p) qui découpe n est deux nombres dont le deuxième comporte p chiffres, et aui retourne leur somme. Par exemple,

sommeParties(12540,2) = 125 + 40 = 165

3.    Ecrire la fonction int estKaprekar(int n)

Exercice 5 - somme

Ecrire une fonction int somme(int T[], int n) retournant la somme des n éléments du tableau T.

Exercice 6 - minimum

Ecrire une fonction int min(int T[], int n) retournant la valeur du plus petit élément du tableau T.

Exercice 7 - recherche

Ecrire une fonction int existe(int T[], int n, int k) retournant 1 si k est un des n éléments du tableau T, 0 sinon.

Exercice 8 - Somme des éléments pairs

Exercice 9 - Vérification

Ecrivez le corps de la fonction int estTrie(int T[], int n), estTrie(T,n) retourne vrai si et seulement si le tableau T, à n éléments, est trié dans l’ordre croissant.

Exercice 10 - permutation circulaire

Ecrire une fonction void permutation(int T[], int n) effectuant une permutation circulaire vers la droite des éléments de T.

Exercice 11 - miroir

Ecrire une fonction void miroir(int T[], int n) inversant l’ordre des éléments de T.

On pose ici N = 25, vous utiliserez un #define N 25 dans toute cette partie. On rappelle qu’un nombre est premier s’il n’est divisible que par 1 et par lui-même. Par convention, 1 n’est pas premier.

Exercice 12

Ecrivez une fonction int estPremier(int n, int T[], int k) retournant 1 si n est premier, 0 sinon. Vous vérifierez la primarité de n en examinant les restes des divisions de n par les k premiers éléments de T. On suppose que k est toujours supérieur ou égal à 1.

Exercice 13

?Modifiez la fonction précédente en tenant compte du fait que si aucun diviseur premier de n inférieur à

n n’a été trouvé, alors n est premier

Exercice 14

Ecrivez une fonction void trouvePremiers(int T[], int n) pla¸cant dans le tableau T les n premiers nombres premiers.

Exercice 15

Ecrivez une fonction void décompose(int n, int T[], int K[]) pla¸cant dans le tableau K la décomposition en facteurs premiers du nombre n, sachant que T contient les N premiers nombres premiers. Par exemple, si n = 108108, alors on décompose n en produit de facteurs premiers de la sorte

108108 = 2 ? 2 ? 3 ? 3 ? 3 ? 7 ? 11 ? 13 = 2² ? 3³ ? 5⁰ ? 7¹ ? 11¹ ? 13¹ ? 17⁰ ? 19⁰ ? ? Z⁰

(ou` Z est le N-ième nombre premier). On représente donc n de fa¸con unique par le tableau K à N

éléments

{2,3,0,1,1,1,0,0,0, ,0}

Exercice 16

Ecrivez une fonction int recompose(int T[], int K[]) effectuant l’opération réciproque de celle décrite ci-dessus.

Exercice 17

Exercice 18

Ecrivez une fonction int pgcd(int i, int j) prenant en paramètres deux nombres i et j, et combinant les fonctions précédentes pour retourner le pgcd de i et j.

Nous souhaitons faire des statistiques sur les connexions des clients d’un site Web. Le tableau C, à n

éléments, contient les identifiants des clients qui se sont connectés. Ainsi C[i] contient l’identifiant du i-ème client à s’être connecté, notez bien que si un client se connecte plusieurs fois, son identifiant apparaˆ?tra plusieurs fois dans le tableau C. Le tableau D contient les durées de connexion. Ainsi D[i] est le temps de connexion de la i-ème connexion. Le but est de déterminer, pour chaque, client, son temps total de connexion.

Exercice 19

Ecrire le corps du sous-programme void decalageGauche(int T[], int a, int b), ce sous-programme décale la tranche

T[a]

T[a + 1]

T[b]

d’une case vers la gauche.

Exercice 20

Ecrivez le corps de la fonction int calculeTempsTotalConnexionClient(int C[], int D[], int n, int i). calculeTempsTotalConnexionClient(C, D, n, i) retourne le temps total de connexion du client d’identifiant C[i], on suppose que i est l’indice de la première occurence de C[i] dans C.

Exercice 21

Ecrivez le corps de la fonction int supprimeDoublons(int C[], int D[], int n, int i). supprimeDoublons(C, D, n, i) supprime toutes les occurences (d’indices strictement supérieurs à i) du client d’identifiant C[i] dans C et D et retourne le nombre d’éléments supprimés. Vous devrez utiliser decalageGauche.

Exercice 22

Ecrivez le corps de la fonction int tempsTotalDeConnexion(int C[], int D[], int n, int i). tempsTotalDeConn D, n, i) place dans D[i] le temps total de connexion du client C[i] et élimine de C et de D toutes les autres occurences de ce client. Cette fonction doit retourner le nombre d’éléments supprimés. Vous devrez utiliser calculeTempsTotalConnexionClient et supprimeDoublons.

Exercice 23

Question 24 - affichage

Ecrivez une fonction void afficheChaine(char s[]) qui affiche la chaˆ?ne de caractère s sans utiliser de %s.

Question 25 - longueur

Ecrivez une fonction int longueur(char s[]) qui retourne la longueur de la chaˆ?ne de caractère s sans utiliser strlen.

Question 26 - extraction

Ecrivez une fonction char extrait(char s[], int n) qui retourne le n-ème caractère de s, vous considérerez que les indices commencent à 1.

Question 27 - substitution

Ecrivez une fonction void subs(char s[], int n, char a) qui remplace le n-ème caractère de s par a, vous considérerez que les indices commencent à 1.

Cette section a pour but la programmation d’un pendu, vous êtes invités à utiliser les fonctions définies ci-dessus.

Question 28 - initialisation

Ecrire une fonction void initialise(char t[], int n) qui place dans t n caractères ’ ’.

Question 29 - vérification

Ecrire une fonction void verifie(char t[], char k[], char c) qui recherche toutes les occurences du caractère c dans t, soit i l’indice d’une occurrence de c dans t, alors cette fonction remplace le ième caractère de k par c. Par exemple, si on invoque verifie(‘‘bonjour", ‘‘b j r", ’o’), alors k prendra la valeur "bo jo r’’.

Question 30 - Le jeu

Programmez un pendu, faites le plus simplement possible, et utilisez les fonctions ci-dessus..

Exercice 31 - Tri à bulle

1.    Ecrivez le corps de la fonction void echange(int T[], int a, int b), echange(T,a,b) échange les éléments T[a] et T[b].

2.    Ecrivez le corps de la fonction void ordonne(int T[], int a, int b), ordonne(T,a,b) échange les éléments T[a] et T[b] si T[a] > T[b]. Vous utliserez le sous-programme echange.

T[a]

T[a + 1]

T[b]

3.    Ecrivez le corps de la fonction void bulle(int T[], int a, int b), bulle(T,a,b) place le plus grandélément de la tranchedans T[b]. Vous utiliserez le sous-programme ordonne.

Exercice 32 - Tri par sélection

1.    Implémentez la fonction int indiceDuMin(int T[], int i, int j) retournant l’indice du plus petit élément de T(i), , T(j), c’est-à-dire de tous les éléments du tableau dont l’indice est compris entre i et j.

2.    Implémentez le sous-programme void placeMin(int T[], int i, int j, int k)échangeant avec T(k) le plus petit élément de T dont l’indice est compris entre i et j.

3.    Le tri par sélection est une méthode consistant à rechercher dans un tableau T à n éléments le plus petit élément du tableau et à l’échanger avec le T(1). Puis à chercher dans T(2), ,T(N) le deuxième plus petit élément et à l’échanger avec T(2), etc. Une fois un tri par sélection achevé, les éléments du tableau doivent être disposés par ordre croissant. Ecrivez le sous-programme void triParSelection(int T[], int N).

Exercice 1

Créez un type structuré st contenant un char appelé c et un int appelé i.

Exercice 2

Créez deux variables k et l de type st. Affectez-leur les valeurs (⁰a⁰,1) et (⁰b⁰,2).

Exercice 3

Affichez les valeurs de tous les champs de ces deux variables.

Nous utiliserons pour représenter des heures de la journée au format hh : mm le type

typedef struct

{

int heure ; int minute ;

}heure t ;

Le champ heure devra contenir une valeur de {0,1, ,11} et le champ minute une valeur de {0,1,2, ,59}. Complétez le code source suivant :

#include<stdio .h>

typedef struct

{ int heure ; int minute ;

}heure t ;

/???????????????????????????????????????????????????/

/?

Retourne uen structure initialisee avec les valeurs heures et minutes .

?/

heure t creerHeure ( int heures , int minutes)

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Convertit                t en minutes .

?/

int enMinutes( heure t t )

{

}

/???????????????????????????????????????????????????/

/?

Convertit          la                 duree t en heure t .

?/

heure t enHeures( int t )

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Affiche x au format hh:mm

?/

void afficheHeure ( heure t x)

{

}

/???????????????????????????????????????????????????/

/?

Additionne a et b .

?/

heure t additionneHeures ( heure t a ,                                                heure t b)

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Retourne la                              valeur a ajouter a x pour obtenir                            00:00.

?/

heure t                         inverseHeure ( heure t x)

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Soustrait b a a.

?/

heure t                           soustraitHeures ( heure t a ,                        heure t b)

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Retourne 1 si a > b , ?1 si a < b , 0 si a = b .

?/

int compareHeures( heure t a ,                                       heure t b)

{

return 0;

}

/???????????????????????????????????????????????????/

/?

Retourne la            plus          petite                   des heures a et b .

?/

{

        heure t                   result = {0 , 0};

return result ;

}

/???????????????????????????????????????????????????/

/?

Pour tester             les            fonctions . . .

?/

int main()

{

return 0;

}

Nous considérons les déclarations suivantes :

#include<stdio .h>

#include<stdlib .h>

#include<string .h>

#define TAILLE NOM 50 #define TAILLE TEL 10

#define NBMAXNOMS 500

struct personne

{

char nom[TAILLE NOM+1]; char tel [TAILLE TEL+1];

};

Il vous est demandé de programmer un répertoire télphonique en stockant les entrées du répertoire dans un tableau de structpersonne. Les entrées devront être triées, il devra être possible de rechercher des entrées avec le préfixe du nom, insérer et supprimer des entrées. Prévoyez aussi la possibilité d’afficher toutes les entrées du répertoire les unes à la suite des autres. Bon courage.

Exercice 1

Ecrivez un programme déclarant une variable i de type int et une variable p de type pointeur sur int. Affichez les dix premiers nombres entiers en :

–    n’incrémentant que i

–    n’affichant que ?p

Exercice 2

Même exercice en

–    n’incrémentant que ?p

–    n’affichant que i

Exercice 3

Déterminez ce qu’affiche ce programme, exécutez-ensuite pour vérifier.

#include<stdio .h>

main()

{

int i = 4; int j = 10; int? p; int? q ;

p = &i ; q = &j ;
printf (” i = %d, ?p = ?p + ?q ;	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );
printf (” i = %d, p = &j ;	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );
printf (” i = %d, ?q = ?q + ?p;	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );
printf (” i = %d, q = &i ;	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );
printf (” i = %d, i = 4;	j ,	?p,	?q );
printf (” i = %d, ?q = ?q + 1;	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );
printf (” i = %d,	j = %d, p = %d, q = %d\n” , i ,	j ,	?p,	?q );

}

Exercice 4 - prise en main

Ecrire un programme qui place dans un tableau t les N premiers nombres impairs, puis qui affiche le tableau. Vous accéderez à l’élément d’indice i de t avec l’expression ?(t + i).

Exercice 5 - Tri à bulle

Ecrire un sous-programme triant un tableau t avec la méthode du tri à bulle. Vous accéderez à l’élément d’indice i de t avec l’expression ?(t + i).

Exercice 6 - Tableaux de carrés

Ecrire un programme qui demande à l’utilisateur de saisir un nombre n, et qui place les n premiers nombres impairs dans un tableau t. Utilisez ensuite le fait que k² est la somme des k premiers nombres impairs pour calculer puis afficher les n premiers nombres carrés.

Exercice 7 - Matrices et pointeurs de pointeurs

Ecrivez un programme qui demande à l’utilisateur de saisir un nombre n et qui crée une matrice T de dimensions n×n avec un tableau de n tableaux de chacun n éléments. Nous noterons t_ij le j-ème élément du i-ème tableau. Vous initialiserez T de la sorte : pour tous i,j, t_ij = 1 si i = j (les éléments de la diagonale) et t_ij = 0 si i 6= j (les autres éléments). Puis vous afficherez T.

Exercice 8 - Copie de chaˆ?nes de caractères

Ecrivez un programme qui saisit proprement une chaˆ?ne de caractère s et qui la recopie dans un tableau crée avec malloc et de contenance correspondant exactement à la longueur de s. Vous n’utiliserez ni strlen, ni strcpy.

Exercice 9 - Tableau de chaˆ?nes

Reprennez le programme précédent en saissisant successivement 4 chaˆ?nes de caractères et en les stockant dans un tableau de chaˆ?nes de caractères.

Exercice 10 - Prise en main

Créez dynamiquement un int, affectez-y la valeur 5, affichez-le, libérez la mémoire.

Demandez à l’utilisateur la taille du tableau qu’il souhaite créer, allouez dynamiquement l’espace nécessaire et placez-y les valeurs {0, n ? 1}, affichez-le et libérez la mémoire.

Exercice 12 - Tableaux sur mesure

Qu’affiche le programme suivant :

#include<stdio .h>

int main()

{

long A, B, C, D; long ?p1 , ?p2 , ?p3 ; long ??pp;

A      = 10 ;

B      = 20 ;

C      = 30 ;D = 40; p1 = &A; p2 = &B; p3 = &B; ?p1 = (?p1 + 1); ?p3 = (?p2 + D); p3 = &C; ?p3 = (?p2 + D); printf (”A = %ld , B = %ld , C = %ld , D = %ld\n” , A, B, C, D);

pp = &p3 ;

printf (”%ld\n” , ??pp );

return 0;

}

Exercice 13

Déterminez ce qu’affiche ce programme, exécutez-ensuite pour vérifier.

#include<stdio .h>

void affiche2int ( int a , int b)

{

printf (”%d, %d\n” , a , b );

}

void incr1 ( int x)

{

x = x + 1;

}

void incr2 ( int? x)

{

?x = ?x + 1 ;

}

void decr1 ( int? x)

{

x = x ? 1;

}

void decr2 ( int? x)

{

?x = ?x ? 1;

}

main() {

int i = 1; int j = 1;
affiche2int ( i , incr2(&i );	j );
affiche2int ( i , decr1(&j );	j );
affiche2int ( i , decr2(&j );	j );
affiche2int ( i , while( i != j ) {	j );

incr1 ( j ); decr2(&i );

} affiche2int ( i ,      j ); }

Exercice 14

Ecrivez le corps du sous-programme additionne, celui-ci doit placer dans res la valeur i + j.

#include<stdio .h>

void additionne ( int a , int b, int? res )

{

/? Ecrivez        le          corps du sous?programme         i c i    ?/

}

main()

{

int i = 2; int j = 3; int k ; additionne ( i , j , &k );

              printf (”k = %d\n” , k );           //     doit        afficher         ”k = 5”

}

Exercice 15

Exercice 16

Ecrivez le sous-programme void tri(int* a, int* b, int* c) qui permute les valeurs de ?a, ?b et ?c de sorte que ?a ? ?b ? ?c. Vous utiliserez le sous-programme void echange(int* x, int* y).

Le but de cet exercice est d’encapsuler les accès à la mémoire par le biais des pointeurs dans des fonctions. Ecrivez le corps des fonctions suivantes :

1.    int getIntVal(int* p) retourne la valeur se trouvant à l’adresse p.

2.    void setIntVal(int* p, int val) affecte la valeur val à la variable pointée par p.

3.    int* getTiAdr(int* t, int i) retourne l’adresse de l’élément T[i]

4.    int getTiVal(int* t, int i) retourne la valeur de l’élément T[i], vous utiliserez getTiAdr et getIntVal

5.    void setTiVal(int* t, int i, int val) affecte à T[i] la valeur val, vous utiliserez getTiAdr et setIntVal.

6.    void swapInt(int* a, int* b) échange les valeurs des variables pointées par a et b. Vous utiliserez getIntVal et setIntVal.

7.    void swapTij(int* t, int i, int j) échange les valeurs T[i] et T[j], vous utiliserez swapInt et getTiAdr.

Ecrivez le corps de la fonction de tri void sort(int* t, int n) de votre choix en utilisant au mieux les fonctions ci-dessus.

Le but de cet exercice est de créer n tableaux de chacun m éléments, de placer les n pointeurs ainsi obtenus dans un tableau de pointeurs T de type int?? et de manier T comme un tableau à deux indices. Ecrivez les corps des fonctions suivantes :

1.    int** getTi Adr(int** T, int i) retourne l’adresse du pointeur vers le i-ème tableau d’int de T.

2.    int* getTi (int** T, int i) retourne le i-ème tableau d’int de T, vous utiliserez getTi Adr.

3.    void setT Adr(int** T, int* p) place dans la variable pointée par T le pointeur p.

4.    void setTi (int** T, int i, int* p) fait de p le i-ème tableau de T, vous utiliserez getT Adr et setTi Adr

Nous noterons T_ij le j-ème élément du tableau T[i]. Pour tous (i,j) ? {1, ,10}², le but est de placer dans t_ij la valeur 10i+j. Vous utiliserez les fonctions int getIntVal(int* p), void setIntVal(int* p, int val), int* getTiAdr(int* t, int i), int getTiVal(int* t, int i) et void setTiVal(int* t, int i, int val) pour écrire les corps des sous-programmes ci-dessous :

1.    int* getTijAdr(int** t, int i, int j) retourne l’adresse de T_ij

2.    int getTijVal(int** t, int i, int j) retourne la valeur de T_ij

3.    void setTijVal(int** t, int i, int j, int val) affecte à T_ij la valeur val.

En utilisant les sous-programmes ci-dessus, ecrire un programme qui demande à l’utilisateur un nombre n, puis qui crée un triangle de Pascal à n + 1 lignes, et qui pour finir affiche ce triangle de Pascal. Vous utiliserez les sous-programmes définis dans les questions précédentes et rédigerez des sous-programmes les plus simples possibles (courts, le moins d’étoiles possible).

Vous rédigerez toutes les fonctions suivantes sous forme itérative, puis récursive.

1.    Ecrire une fonction void initTab(int* t, int n) pla¸cant dans le tableau t les éléments 1,2, ,n.

2.    Ecrire une fonction void printTab(int* t, int n) affichant les n éléments du tableau t.

3.    Ecrire une fonction int sommeTab(int* t, int n) retournant la somme des n éléments du tableau t.

4.    Ecrire une fonction (ni récursive, ni itérative) void swap(int* t, int i, int j)échangeant les éléments d’indices i et j du tableau t.

5.    Ecrire une fonction void mirrorTab(int* t, int n) inversant l’ordre des éléments du tableau t.

6.    Ecrire une fonction int find(int* t, int n, int x) retournant 1 si x se trouve dans le tableau t à n éléments, 0 sinon.

En utilisant les exercices sur les heures dans la section structures, vous rédigerez les fonctions suivantes sous forme récursive.

1.    Ecrire une fonction void afficheTabHeures(heure t* t, int n) affichant les n heures de t.

2.    Ecrire une fonction void initTabHeures(heure t* t, int n, heure t depart, heure t pas) initialisant le tableau t à n éléments comme suit : la première heure est depart et chaque heure s’obtient à additionnant pas à la précédente.

3.    Ecrire une fonction heure t sommeTabHeures(heure t* t, int n) retournant la somme des n heures du tableau t.

4.    Ecrire une fonction heure t minTabHeure(heure t* t, int n) retournant la plus petite des n heures du tableau t.

Complétez le code suivant :

#include<stdio .h>

#include<stdlib .h>#include<time .h>

#define MOD 10000

/?????????????????????????????????????????????/

/?

Affiche                       les n elements du tableau                    t .

?/

void printTab ( int? t , int n)

{

if (n > 0)

{

printf (”%d ” , ?t );

printTab ( t + 1 , n ? 1);

} else

printf (”\n” );

}

/?????????????????????????????????????????????/

/?

Place n elements aleatoires de valeurs maximales MOD ? 1 dans le tableau t .

?/

void initTab ( int? t , int n)

{

if (n > 0)

{

?t = rand()%MOD; initTab ( t + 1 , n ? 1);

}

}

/?????????????????????????????????????????????/

/?

Retourne un tableau de n elements alloue dynamiquement .

?/

int? createTab ( int n)

{ int? t = ( int?) malloc ( sizeof ( int )?n);

if ( t == NULL)

{ printf (”no memory avalaible\n” ); exit (0);

} return t ;

}

/?????????????????????????????????????????????/

/?

Libere la zone memoire pointee par ?t et met ce pointeur a NULL.

?/

void destroyTab( int?? t )

{ free (? t );

?t = NULL;

}

/?????????????????????????????????????????????/

/?

(Recursive)

Affiche une erreur                si       le        tableau         est        vide .

?/

int indexOfMin( int? t , int n)

{

return 0;

}

/?????????????????????????????????????????????/

/?

Echange les                      elements ?x et ?y.

?/

void swap( int? x , int? y)

{

int temp = ?x;

?x = ?y;

?y = temp;

}

/?????????????????????????????????????????????/

/?

Echange le plus petit element du tableau t a n elements avec le premier .

?/

void swapMin( int? t , int n)

{

}

/?????????????????????????????????????????????/

/?

(Recursive)

Trie         le                     tableau          t a n elements avec            la methode du tri                par                 selection .

?/

void selectionSort ( int? t , int n)

{

}

/?????????????????????????????????????????????/

/?

(Recursive)

Recopie les n elements du tableau source a l ’ adresse dest . ?/

void copyTab( int? source , int? dest , int n)

{

}

/?????????????????????????????????????????????/

/?

(Recursive)

Interclasse les n1 elements de source1 avec les n2 elements de source2 . source1 et source2 sont supposes tries . L’ interclassement se fait

en disposant                    ces elements dans                    l ’ordre dans                 le ?/	tableau	dest .
void shuffleTab ( int? source1 , int? source2 , int? int n1 , int n2) { } /?????????????????????????????????????????????/ /?	dest ,
Trie                      les n elements de t avec                                        la methode du tri	fusion .

?/

void fusionSort ( int? t , int n)

{

}

/?????????????????????????????????????????????/

/?

?/

int compareSorts ( int firstValue , int lastValue , int step )

{

int i ; int start , stop ;

int ?t , ?q;

srand (time(NULL));

for ( i = firstValue               ;              i <= lastValue             ;           i += step )

{

printf (”with %d elements : \n” , i ); t = createTab ( i ); q = createTab ( i ); initTab (t , i ); copyTab(t , q , i ); start = time(NULL); selectionSort (t , i ); stop = time(NULL);

                     printf (”? selection                 sort                    : %d\n” , stop ? start );

destroyTab(&t ); start = time(NULL); fusionSort (q , i ); stop = time(NULL);

printf (”? fusion sort : %d\n” , stop ? start ); destroyTab(&q );

}

return 0;

}

/?????????????????????????????????????????????/

/?

Pour tester les fonctions au fur et a mesure qu ’ elles sont ecrites . . . ?/

int main()

{ compareSorts (10000 , 500000 , 1000); return 0;

}

Exercice 1 - touch

La commande shell touch permet de créer un fichier vide. Ecrire un programme prenant le nom d’un fichier en ligne de commande et le créant.

Exercice 2 - more

La commande shell more permet d’afficher le contenu d’un fichier. Ecrire un programme prenant le nom d’un fichier en ligne de commande et affichant son contenu.

Exercice 3 - Alphabet

Ecrire un programme C alphabet permettant de créer un fichier. Le nom du fichier crée sera passé en ligne de commande et le fichier contiendra l’alphabet.

Exercice 4 - Initialiser un fichier

Ecrire un programme C createFile permettant de créer un fichier. Le nom du fichier crée sera le premier des arguments, tous les arguments suivants seront écrits dans le fichier. Par exemple, la commande

./createFile ceci est le contenu de mon fichier doit créer un fichier appelé et contenant le texte

ceci est le contenu de mon fichier

Exercice 5 - cp

Exercice 6 - Liste de noms

Ecrire deux programmes storeNames et getNames. storeNames demande à l’utilisateur de saisir une liste de noms et les enregistre au fur et à mesure qu’ils sont saisis dans un fichier dont le nom a été passé en ligne de commande au lancement du programme. On arrête le programme en saisissant ?1. getNames affiche la liste des noms stockée dans le fichier dont le nom est passé en ligne de commande.

Compléter le fichier source suivant :

#include<stdio .h>

#include<stdlib .h>

#define NB ROTORS 5

#define NB LETTERS 26

#define FORWARD 1

#define BACKWARD 2

/???????????????????????????????????????????????/typedef struct rotor

{ char permutation [NB LETTERS] ; char permutationInverse [NB LETTERS] ; char position ;

}rotor ;

/???????????????????????????????????????????????/

typedef struct enigma

{ rotor rotors [NB ROTORS] ; char mirror [NB LETTERS] ;

}enigma ;

/???????????????????????????????????????????????/

/?

Dispose tous             les                rotors dans leur                         position de depart .

?/

void initialiseRotors (enigma? e)

{

}

/???????????????????????????????????????????????/

/?

Libere                    la memoire occupee par e .

?/

void enigmaDestroy(enigma? e)

{

}

/???????????????????????????????????????????????/

/?

Alloue              la memoire et                  initialise                  les champs.

?/

enigma? enigmaCreate ()

{ return NULL;

}

/???????????????????????????????????????????????/

/?

Retourne                       le                     rang de         letter              dans               l ’ alphabet , en indicant a partir de 0.

?/

char indexOfLetter (char letter )

{

return 0;

}

/?

Retourne la                  lettre d ’ indice                    index dans    l ’ alphabet , ’a ’                  est d ’ indice     0.

?/

char letterOfIndex (char index )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Fait de la lettre cipherLetter l ’image de la lettre d ’ indice clearIndex par un passage dans le rotor d ’ indice rotorIndex de e .

?/

void setImage (enigma? e , int rotorIndex , int clearIndex , char cipherLetter )

{

}

/???????????????????????????????????????????????/

/?

Fait de               firstLetter             le         reflet                 de secondLetter .

?/

void setMirror (enigma? e , char firstLetter , char { } /???????????????????????????????????????????????/ /?	secondLetter )
Retourne vrai si et seulement si letter est une de l ’ alphabet . ?/ int isEncryptable (char letter ) { return 0; } /???????????????????????????????????????????????/ /? Affiche          les         rotors        et      le            miroir de e . ?/ void enigmaPrint (enigma? e) { } /???????????????????????????????????????????????/ /?	minuscule
Fait          pivoter         le                                           rotor d ’ indice indexOfRotor de	e

en modifiant sa position de depart . Retourne vrai ssi le rotor est revenu dans sa position initiale . ?/

int rotateRotor (enigma? e , int indexOfRotor )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Fait          pivoter         le                           jeu de rotors de e d ’une position .

?/

void rotateRotors (enigma? e)

{

}

/?

Indice d ’ entree de la                        lettre d ’ indice                    indexOfLetter dans            le                       rotor r , en tenant compte de la            position de ce rotor . ?/

int inputIndex ( rotor? r , int indexOfLetter )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Indice de la lettre sortie a l ’ indice indexOfLetter du rotor r , en tenant compte de la position de ce rotor . ?/

int outputIndex ( rotor? r , int indexOfLetter )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Fait         passer            la                     lettre d ’ indice                    indexOfLetter dans r dans la                    direction       direction       (FORWARD ou BACKWARD). ?/

int rotorEncrypt ( rotor? r , int indexOfLetter , char direction )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Fait passer la lettre d ’ indice indexOfLetter dans le miroir de e .

?/

int mirrorEncrypt (enigma? e , int indexOfLetter )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Chiffre letter avec e , fait ensuite pivoter les rotors de e .. ?/

char enigmaEncrypt(enigma? e , char letter )

{

return 0;

}

/???????????????????????????????????????????????/

/?

Chiffre le fichier clearFName avec e , ecrit le resultat dans cipherFName.

?/

void encryptFile (enigma? e , char? clearFName , char? cipherFName)

{

}

/???????????????????????????????????????????????/

/?

I n i t i l i a l i s e          les NB ROTORS rotors de e avec deux ecrits              dans               le                fichier            rotors .

?/

{

}

/???????????????????????????????????????????????/

/?

I n i t i l i a l i s e         le                             miroir de e avec une ligne du fichier                                rotors .

?/

void loadMirror (enigma? e , FILE? rotors )

{

}

/???????????????????????????????????????????????/

/?

Cree une machine enigma initialisee avec le contenu du fichier rotorFileName .

?/

enigma? loadFile (char? rotorFileName )

{ return NULL;

}

/???????????????????????????????????????????????/

/?

Chiffre    le                     fichier            clear               avec                la machine enigma decrite dans rotors ,  ecrit                le                     resultat          dans cipher .

?/

void enigmaRun(char? clear , char? cipher , char? rotors )

{

enigma? e = loadFile ( rotors );

encryptFile (e , clear , cipher ); enigmaDestroy(e );

}

/???????????????????????????????????????????????/

int main( int argc , char? argv [ ] )

{

if ( argc == 4)

              enigmaRun( argv [1] ,              argv [2] ,          argv [ 3 ] ) ;

else

              printf (”usage           :            ./ enigma source              cipher                rotorfile \n ” );

return 0;

}

klmnopqvwxyzgabcdefhijrstu uvwxystzabcdejklmnopqrfghi klmnopqabcdvwxyzgstuefhijr zgabcdefklmnopqvhijrstuwxy tuklmnopqvwxyzgabcdefhijrs wzgabchijrmdefynopqvstuklx

Que contient le message suivant? (attention, les accents s’affichent mal )

Bobuq ,                  uynl myck ipyvp zA˜ cmjbA˜ c              lr               lpkn zvw eywbovtssi              !

Exercice 1 - identite

Exercice 2 - somme

Ecrire une fonction calculant la somme de deux matrices.

Exercice 3 - transposition

Ecrire une fonction calculant la matrice transposée d’une matrice N × M passée en paramètre.

Exercice 4 - produit

Ecrire une fonction calculant le produit de deux matrices N × M et M × P passées en paramètre.

Exercice 5 - triangle de Pascal

Un triangle de Pascal peut être placé dans une matrice contenant des 1 sur la première colonne et la diagonale, et tel que chaque élément m[i][j] de la matrice soit la somme des éléments m[i ? 1][j ? 1] et m[i?1][j]. Seule la partie triangulaire inférieure d’un triangle de Pascal contient des valeurs significatives. Ecrire une fonction initialisant un triangle de Pascal à n lignes.

Exercice 6 - Matrice marrante

Ecrire une fonction pla¸cant dans chaque emplacement d’indices (i,j) d’une matrice la valeur (i + 1)^j.

Vous utiliserez le fait que

(i + 1)^j = P(0,j)i⁰ + P(1,j)i¹ + P(1,j)i¹ + + P(k,j)i^k + + P(j,j)i^j

ou` P(a,b) est l’élément se trouvant à la colonne a et à la ligne b du triangle de Pascal.

Exercice 1

Créer un type st contenant un champ i de type int et un champ c de type char. Déclarez une variable p de type st*, allouez dynamiquement une variable de type st et faites pointer p dessus. Affectez à cette variable les valeurs 5 et ’a’. Affichez-les, libérez la mémoire.

Exercice 2 - prise en main

Etant donné le programme

#include<stdio .h>

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/

int main()

{

maillon m, p; maillon? ptr ; m. data = 1;

m. next = &p;

p. data = 2;

p. next = NULL;

for ( ptr = &m ;             ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

return 0;

}

3 et 4, renseignez les valeurs next des maillons de sorte que la boucle for affiche

data = 1 data = 2 data = 3 data = 4

Exercice 3 - tableaux

Reprennez le programme

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct maillon

{

int data ;

struct maillon? next ;

}maillon ;

/??????????????????????????????????????????????????????????????/

void printData ( maillon? ptr )

{

for (    ;         ptr != NULL ;             ptr = ptr?>next )

printf (”data = %d\n” , ptr?>data );

}

/??????????????????????????????????????????????????????????????/

int main()

{

maillon? l ; int i ;

l = ( maillon ?) malloc (N ? sizeof ( maillon )); if ( l == NULL) exit (0);

l?>data = 0;

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

{

( l + i)?>data = i ;

( l + i ? 1)?>next = l + i ;

}

( l + N ? 1)?>next = NULL; printData ( l );

free ( l );

return 0;

}

Modifiez le chaˆ?nage de sorte que les maillons soient disposés dans l’ordre inverse et que, par conséquent, ce programme affiche :

data = 9 data = 8 data = 7 data = 6 data = 5 data = 3 data = 4 data = 2 data = 1 data = 0

Exercice 4 - ajout d’un élément à la fin

Erire le corps de la fonction suivante :

maillon? insereFinLL ( maillon? l , int n)

Vous insérerez un maillon contenant la valeur n à la fin de la liste dont le premier élément est pointé par l. Vous retournerez un pointeur vers le premier élément de la liste.

Exercice 5 - copie d’une liste chaˆ?née Erire le corps de la fonction suivante : maillon? copyLL( maillon? source )

Vous copierez la liste l et retournerez un pointeur vers le premier élément de la copie. Vous avez le droit d’utiliser insereFinLL.

Exercice 6 - inversion de l’ordre des éléments

Nous définissons comme suit une liste doublement chaˆ?née

#include<stdio .h>

#include<stdlib .h>

#include<malloc .h>

#define N 10

/??????????????????????????????????????????????????????????????/

typedef struct dmaillon

{

int data ; struct dmaillon? previous ; struct dmaillon? next ;

}dmaillon ;

/??????????????????????????????????????????????????????????????/

typedef struct dLinkedList

{

struct dmaillon?          f i r s t ; struct dmaillon? last ;

}dLinkedList ;

Implémentez les fonctions suivantes :

1.    void printDLL(dLinkedList* dl) affiche les éléments d’une liste chaˆ?née.

2.    void freeDLL(dLinkedList* dl) libère tous les maillons, puis libère dl.

3.    dLinkedList* makeDLL() alloue la mémoire pour une dLinkedList, initialise les pointeurs à NULL

4.    dmaillon* makeDMaillon(int n) crée un maillon contenant la valeur n.

5.    void appendDMaillonDLL(dLinkedList* dl, dmaillon* m) accroche le maillon m à la fin de la liste chaˆ?née dl

6.    void pushDMaillonDLL(dLinkedList* dl, dmaillon* m) accroche le maillon m au début de la liste chaˆ?née dl

7.    void appendIntDLL(dLinkedList* dl, int n) ajoute à la fin de dl un maillon contenant la valeur n.

8.    void pushIntDLL(dLinkedList* dl, int n) ajoute au début de dl un maillon contenant la valeur n.

9.    void initDLL(dLinkedList* dl, int n) place dans la liste doublement chaˆ?née les valeurs {0, ,n?

1}

10.   void reverseDLL(dLinkedList* dl) inverse l’ordre des éléments de dl.

11.   dLinkedList* copyDLL(dLinkedList* source) retourne une copie de source.

12.   void concatDLL(dLinkedList* debut, dLinkedList* fin) concatène fin à la suite de debut, vide la liste fin .

Complétez le code sources suivant. Les boucles sont interdites!

#include<stdio .h>

/?

?/

typedef struct l l s

{ int data ;

struct l l s ? next ;

} l l ;

/????????????????????????????????????????????????????????/

/?

Alloue dynamiquement et               initialise un maillon avec                        les valeurs     data               et next ,                retourne son adresse .

?/

l l ? creer ( int data ,                              l l ? next )

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

Affiche         le        maillon        l

?/

void affiche ( l l ? l )

{

}

/????????????????????????????????????????????????????????/

/?

Affiche , dans                l ’ordre ,          tous        les              maillons de la              l i s t e       l .

?/

void afficheTout ( l l ? l )

{

}

/????????????????????????????????????????????????????????/

/?

Affiche en partant de la fin tous les maillons de la l i s t e l .

?/

void afficheALEnvers ( l l ? l )

{

}

/????????????????????????????????????????????????????????/

/?

Detruit tous les maillons de la l i s t e ?l , met ce pointeur a NULL. ?/

void detruit ( l l ?? l )

{

}

/????????????????????????????????????????????????????????/

/?

Retourne la                             l i s t e n ?> n?1 ?> . . . ?> 2 ?> 1

?/

l l ? entiersALEnvers ( int n)

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

Retourne la           l i s t e                  1 ?> 2 ?> . . . ?> n

?/

l l ? entiers ( int n)

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

?/

l l ? insere ( l l ? l ,                           l l ? x)

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

Tri la l i s t e l avec la methode du tri par insertion , retourne l ’ adresse du premier element de la l i s t e triee .

?/

l l ? triInsertion ( l l ? l )

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

Repartit          les            elements de          l        entre        les          listes          l1      et       l2 .

ex      :                           l = 1 ?> 2 ?> 3 ?> 4 ?> 5 nous donne

l1 = 5 ?> 3 ?> 1et                       l2 = 4 ?> 2

?/

void split ( l l ? l ,                             l l ?? l1 ,             l l ?? l2 )

{

}

/????????????????????????????????????????????????????????/

/?

Retourne                   l ’ interclassement des                    listes          l1      et       l2 ,          supposees            triees .

?/

l l ? interclasse ( l l ? l1 ,                                   l l ? l2 )

{

return NULL;

}

/????????????????????????????????????????????????????????/

/?

Trie l avec la methode du tri fusion , retorune l ’ adresse du premier element de la l i s t e triee .

?/

l l ? triFusion ( l l ? l )

{ return NULL;

}

/????????????????????????????????????????????????????????/

/?

Pour tester             les            fonctions . . .

?/

int main()

{

return 0;

}

Annexe A

Saisie et affichage

#include<stdio .h>

int main()

{

int a ; printf (” Saississez une valeur : ” );

scanf (”%d” , &a );

return 0;

}

Permutation de 2 variables

#include<stdio .h>

int main()

{

int a , b, temp;

            printf (” Saississez                les                   valeurs de 2 variables                       :\nA = ” );

scanf (”%d” , &a ); printf (”B = ” );

scanf (”%d” , &b);

temp = a ; a = b; b = temp;

              printf (”Apres permutation ,                   les                  valeurs des variables                  sont        : ”

”\nA = %d\nB = %d\n” , a , b); return 0;

}

Permutation de 4 valeurs

#include<stdio .h>

int main()

{

int a , b, c , d, temp;

            printf (” Saississez                les                   valeurs de 4 variables                       :\nA = ” );

scanf (”%d” , &a ); printf (”B = ” ); scanf (”%d” , &b); printf (”C = ” ); scanf (”%d” , &c ); printf (”D = ” ); scanf (”%d” , &d);

temp = a ; a = c ; c = temp; temp = b; b = d; d = temp;

              printf (”Apres permutation ,                   les                  valeurs des variables                  sont        : ”

”\nA = %d\nB = %d\nC = %d\nD = %d\n” , a , b, c , d); return 0;

}

Permutation de 5 valeurs

#include<stdio .h>

int main()

{

int a , b, c , d, e , temp;

            printf (” Saississez                les                   valeurs de 5 variables                       :\nA = ” );

scanf (”%d” , &e );

temp = d; d = a ; a = temp; temp = b; b = c ; c = e ; e = temp;

printf (”Apres permutation , les valeurs des variables sont : ” ”\nA = %d\nB = %d\nC = %d\nD = %d\nE = %d\n” , a , b, c , d, e ); return 0;

}

Saisie et affichage

#include<stdio .h>

int main()

{ float a ;

                printf (” Saississez une valeur                         : ” );

scanf (”%f” , &a );

           printf (”Vous avez                saisi         la              valeur %f\n” , a );

return 0;

}

Moyenne arithmétique

#include<stdio .h>

int main()

{

float a , b, c , moyenne ; printf (” Saississez 3 valeurs :\n1 : ” );

scanf (”%f” , &a ); printf (”2 : ” ); scanf (”%f” , &b); printf (”3 : ” );

scanf (”%f” , &c );

moyenne = (a + b + c )/3.;

              printf (”La moyenne de ces                   trois           valeurs                 est %f .\n” , moyenne );

return 0;

}

Surface du rectangle

#include<stdio .h>

int main()

{

float largeur , longueur , surface ; printf (”largeur : ” );

scanf (”%f” , &largeur ); printf (”longueur : ” ); scanf (”%f” , &longueur ); surface = largeur ? longueur ;

                   printf (”La surface de ce rectangle                                    est %f .\n” , surface );

return 0;

}

Moyennes arithmétique et géométrique

#include<stdio .h>#include<math.h>

int main()

{

float a , b, arithmetique , geometrique ; printf (”Saissez deux valeurs :\nA : ” );

scanf (”%f” , &a ); printf (”B : ” ); scanf (”%f” , &b); arithmetique = (a + b)/2; geometrique = sqrt (a ? b);

printf (”La moyenne arithmetique de ces deux valeurs ”

return 0;

}

Prise en main

#include<stdio .h>

int main()

{

char a ;

                 printf (” Saississez un caractere                         : ” );

scanf (”%c” , &a );

           printf (”Vous avez                saisi         la                              valeur %c , son code ASCII est %d.\n” , a , a );

return 0;

} Successeur

#include<stdio .h>

int main()

{

char a ;

                 printf (” Saississez un caractere                         : ” );

scanf (”%c” , &a );

a = a + 1;

             printf (”Le caractere                   suivant               est %c\n” , a );

return 0;

}

Casse

#include<stdio .h>

int main()

{

char a ;

                 printf (” Saississez une minuscule                         : ” );

scanf (”%c” , &a );

          printf (”Cette                                        lettre a pour majuscule %c .\n” , a + ’A’ ? ’a ’ );

return 0;

}

Codes ASCII

#include<stdio .h>

int main()

{

char c = ’0 ’ ;

printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++; printf (”%c a pour code ASCII %d\n” , c , c ); c++;

printf (”%c a pour code ASCII %d\n” , c , c );

return 0;

}

Codage d’adresses IP

#include<stdio .h>

int main()

unsigned long ip = 0 , masque = 255; unsigned short octet1 , octet2 , octet3 , octet4 ;

            printf (” Saississez                les        quatre                        chiffres de l ’ adresse IP\n”

”Premiere valeur : ” ); scanf (”%hu” , &octet1 ); ip = octet1 ; ip <<= 8; printf (”Deuxieme valeur : ” ); scanf (”%hu” , &octet2 ); ip |= octet2 ; ip <<= 8; printf (”Troisieme valeur : ” ); scanf (”%hu” , &octet3 ); ip |= octet3 ; ip <<= 8; printf (”Quatrieme valeur : ” ); scanf (”%hu” , &octet4 ); ip |= octet4 ;

printf (”Cette IP se code en long sous la forme %lu .\n” , ip ); printf (”Vous remarquez qu ’ i l est possible de la retrouver : ” ); octet4 = ip & masque ; ip >>= 8; octet3 = ip & masque ; ip >>= 8; octet2 = ip & masque ; ip >>= 8; octet1 = ip & masque ;

               printf (”%hu.%hu.%hu.%hu\n” , octet1 ,                       octet2 ,           octet3 ,            octet4 );

return 0;

}

Permutation circulaire des bits

#include<stdio .h>

int main()

{

unsigned short s ,                  firstBit ;

                printf (” Saisissez une valeur                        : ” );

scanf (”%hu” , &s ); firstBit = s & 1;

s >>= 1;

firstBit <<=7;

s |= firstBit ;

              printf (”Apres permutation                      circulaire               des bits ,             cette          valeur           est ”

”%hu\n” , s ); return 0;

}

Permutation de 2 octets

#include<stdio .h>

int main()

{

unsigned int u, temp;

scanf (”%u” , &u); temp = u & 255; temp <<= 8; u >>= 8; u |= temp;

              printf (”Apres permutation                      circulaire                des octets ,             cette          valeur          est ”

”%u\n” , u); return 0;

}

Permutation de 4 octets

#include<stdio .h>

int main()

{

unsigned long l ; unsigned short octet1 ,     octet2 ,          octet3 ,          octet4 ;

                printf (” Saisissez une valeur                        : ” );

scanf (”%lu” , &l ); octet4 = 255 & l ; l >>= 8; octet3 = 255 & l ; l >>= 8; octet2 = 255 & l ; l >>= 8; octet1 = 255 & l ; l = octet4 ; l <<= 8; l |= octet3 ; l <<= 8; l |= octet2 ; l <<= 8; l |= octet1 ;

              printf (”Apres permutation                      circulaire                des octets ,             cette          valeur          est ”

”%lu\n” , l ); return 0;

}

Pièces de monnaie

#include<stdio .h>#define EPS 0.001

int main()

{ float valeur ; int nbPieces ; printf (”Saissez la somme : ” ); scanf (”%f” , &valeur );

printf (”Pour la payer , vous aurez besoin de :\n” );

/??????????/

nbPieces = ( valeur + EPS)/ 0.5; printf (”%d piece ( s ) de 0.5 euros\n” , nbPieces ); valeur ?= nbPieces ? 0.5; /??????????/ nbPieces = ( valeur + EPS)/ 0.2; printf (”%d piece ( s ) de 0.2 euros\n” , nbPieces ); valeur ?= nbPieces ? 0.2; /??????????/ nbPieces = ( valeur + EPS)/ 0.1; printf (”%d piece ( s ) de 0.1 euros\n” , nbPieces ); valeur ?= nbPieces ? 0.1; /??????????/ nbPieces = ( valeur + EPS)/ 0.05; printf (”%d piece ( s ) de 0.05 euros\n” , nbPieces ); valeur ?= nbPieces ? 0.05;

/??????????/

}

Dernier bit

#include<stdio .h>

int main()

{

unsigned short s ,                    sSansDernierBit ,                  dernierBit ;

                printf (” Saisissez une valeur                        : ” );

scanf (”%hu” , &s ); sSansDernierBit = ( s & 254); dernierBit = ( s & 1); dernierBit = ˜dernierBit & 1; s = sSansDernierBit | dernierBit ;

                   printf (”Apres modification du dernier                           bit ,         cette          valeur           est ”

”%hu\n” , s ); return 0;

}

Permutation sans variable temporaire

#include<stdio .h>

int main()

{

int a , b;

printf (” Saississez les valeurs de 2 variables :\nA = ” ); scanf (”%d” , &a ); // notons x cette valeur , a = x

printf (”B = ” );

scanf (”%d” , &b); // notons y cette valeur , b = y a ˆ= b; // a = xˆy , b = y b ˆ= a ; // a = xˆy , b = yâ = yˆxˆy = x

a ˆ= b; // a = xˆyˆx = y , b = y

              printf (”Apres permutation ,                   les                  valeurs des variables                  sont        : ”

”\nA = %d\nB = %d\n” , a , b); return 0;

}

Majorité

#include<stdio .h>

int main()

{

unsigned short age ; printf (”T’ as quel age ?\n” ); scanf (”%hu” , &age ); if (age >= 18)

printf (”T’ es majeur . ” );

else

printf (”T’ es mineur . ” );

printf (”\n” );

return 0;

}

Valeur absolue

#include<stdio .h>

int main()

{ float a ; printf (” Saisissez une valeur\n” ); scanf (”%f” , &a ); printf (”La valeur absolue de %f est ” , a ); if (a < 0) a = ?a ;

printf (”%f .\n” , a );

return 0;

}

Admissions

#include<stdio .h>

{ float note ; printf (” Saisissez votre note\n” ); scanf (”%f” , &note ); if ( note < 8)

printf (”Ajourne” );

if ( note >= 8 && note < 10) printf (”Rattrapage” );

if ( note >= 10) printf (”Admis” );

printf (”\n” );

return 0;

}

Assurance

#include<stdio .h>

int main()

{ float dommages , franchise , remboursement ; printf (” Saisissez le montant des dommages\n” ); scanf (”%f” , &dommages ); franchise = dommages ? 0.1; if ( franchise > 4000)

franchise = 4000;

remboursement = dommages ? franchise ; printf (”Montant de la franchise : %.2f\n” , franchise ); printf (”Montant rembourse : %.2f\n” , remboursement );

return 0;

}

Valeurs distinctes parmi 2

#include<stdio .h>

int main()

{

int a , b;

                 printf (” Saisissez deux valeurs                            : \na = ” );

scanf (”%d” , &a ); printf (”b = ” ); scanf (”%d” , &b); if (a == b)

printf (”Vous avez                      saisi               deux fois      la meme valeur . ” ); else

               printf (”Vous avez                saisi             deux valeurs                  distinctes . ” );

printf (”\n” );

return 0;

}

Plus petite valeur parmi 3

#include<stdio .h>

int main()

{

int a , b, c , min;

            printf (” Saisissez                trois           valeurs               : \na = ” );

scanf (”%d” , &a ); printf (”b = ” ); scanf (”%d” , &b); printf (”c = ” );

scanf (”%d” , &c );

min = a ; if (b < min) min = b;

if (c < min)

min = c ;

printf (”La plus petite de ces valeurs est %d. ” , min ); printf (”\n” );

return 0;

}

Recherche de doublons

int main()

{

int a , b, c ;

            printf (” Saisissez                trois           valeurs               : \na = ” );

scanf (”%d” , &a ); printf (”b = ” ); scanf (”%d” , &b); printf (”c = ” );

scanf (”%d” , &c );

if (a == b || a == c                         || b == c)

printf (” Il y a des doublons dans les           valeurs que vous avez     saisies ” ); else

               printf (”Vous avez                saisi          trois           valeurs               distinctes ” );

printf (”\n” );

return 0;

}

Valeurs distinctes parmi 3

#include<stdio .h>

int main()

{

int a , b, c , nbd;

            printf (” Saisissez                trois           valeurs               : \na = ” );

scanf (”%d” , &a ); printf (”b = ” ); scanf (”%d” , &b); printf (”c = ” ); scanf (”%d” , &c );

if (a == b && a == c)

nbd = 1;

else

if (a == b || a == c                       || b == c)

nbd = 2;

else

nbd = 3;

               printf (” Il y a %d valeur ( s )                              distincte ( s ).\n” , nbd );

return 0;

}

ax + b = 0

#include<stdio .h>

int main()

{

double a , b, x; printf (” Saisissez les coefficients de l ’ equation (E) : ax + b = 0\na = ” ); scanf (”%l f ” , &a ); printf (”b = ” ); scanf (”%l f ” , &b);

if (a != 0)

{

x = ?b/a ;

printf (”La solution de (E) est x = %l f ” , x );

} else

{

if (b == 0)

printf (”Tout reel           est                   solution de (E)” ); else

printf (”(E) n ’a pas de solution” );

} printf (”.\n” );

return 0;

}

#include<stdio .h>#include<math.h>

int main()

{

double a , b, c , x1 , x2 ,                     delta ;

            printf (” Saisissez               les                        coefficients de l ’ equation (E)                        : ”

”axˆ2 + bx + c = 0\na = ” );

scanf (”%l f ” , &a ); printf (”b = ” ); scanf (”%l f ” , &b); printf (”c = ” ); scanf (”%l f ” , &c ); if (a != 0)

{

delta = b?b ? 4?a?c ;

if ( delta > 0)

{

x1 = ( sqrt ( delta ) ? b)/(2 ? a ); x2 = (? sqrt ( delta ) ? b)/(2 ? a );

                                     printf (”Les solutions de (E) sont %l f                                   et %f” , x1 , x2 );

} else

{

if ( delta == 0)

{

x1 = (? b)/(2 ? a );

printf (”La solution de (E) est x = %l f ” , x1 );

} else

                                       printf (”(E) n ’a pas de solution                            reelle ” );

}

} else

{

if (b != 0)

{

x1 = ?c/b;

printf (”La solution de (E) est x = %l f ” , x1 );

} else

{

if (c == 0)

printf (”Tout reel                       est                   solution de (E)” ); else

printf (”(E) n ’a pas de solution” );

}

} printf (”.\n” );

return 0;

}

Calculatrice

#include<stdio .h>

#include<stdlib .h>

int main()

{

float gauche , droite , resultat ; int erreur = 0; char operateur ;

printf (”Operande gauche : ” ); scanf (”%f” , &gauche ); getchar (); printf (”Operateur : ” ); scanf (”%c” , &operateur ); printf (”Operande droit : ” ); scanf (”%f” , &droite ); getchar (); switch( operateur )

{

case	’+’	:	break;
case	’?’	:	resultat = gauche ? droite ;	break;
case	’/ ’	:	resultat = gauche / droite ;	break;
case	’? ’	:	resultat = gauche ? droite ;	break;

default :                erreur = 1;

} if ( erreur )

               printf (” Saisie                  erronnee .\n” );

else

                     printf (”%.2f%c%.2f = %f\n” , gauche ,                         operateur ,             droite ,              resultat );

return 0;

}

Opérations sur les heures

#include<stdio .h>

int main()

{ int heureDebut , heureFin , minuteDebut , minuteFin ,

             heureEcart ,               minuteEcart ;

printf (”Heure debut (hh:mm) ? ” ); scanf (”%d:%d” , &heureDebut , &minuteDebut ); printf (”Heure fin (hh:mm) ? ” ); scanf (”%d:%d” , &heureFin , &minuteFin ); heureEcart = heureFin ? heureDebut ; minuteEcart = minuteFin ? minuteDebut ;

if ( minuteEcart < 0)

{ heureEcart??;

minuteEcart += 60;

}

printf (”Duree de l ’ intervalle : %2.2d:%2.2d\n” , heureEcart , minuteEcart );

return 0;

}

Le jour d’après

#include<stdio .h>

int main()

{

int jour , mois , annee , nbJours ,

erreur = 0;

printf (” Saisissez la date : ( jj /mm/aaaa) ” ); scanf (”%d/%d/%d” , &jour , &mois , &annee ); switch(mois)

{

case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12: nbJours = 31; break;

case 4 : case 6 : case 9 : case 11 : nbJours = 30; break;

case 2 :

if (annee % 4 ||               !           (annee % 100))

nbJours = 28;

else

nbJours = 29; break;

default : erreur = 1;

} if ( erreur )

{ printf (” Saisie   erronnee       : %2.2d/%2.2d/%4.4d\n” ,

jour , mois , annee );

return ?1;

printf (”Le lendemain du %2.2d/%2.2d/%4.4d est le ” , jour , mois , annee );

jour++;

if ( jour == nbJours + 1)

{

jour = 1; mois++;

if (mois == 13)

{

mois = 1; annee++;

}

} printf (” est le %2.2d/%2.2d/%4.4d.\n” , jour , mois , annee );

return 0;

}

Couleurs des cases

#include<stdio .h>

int main()

{

unsigned short i ,	j ;
printf (” Saisissez	les	coordonnees de la	case	:\n” );

printf (” i = ” ); scanf (”%hu” , &i ); printf (”j = ” ); scanf (”%hu” , &j );

                   printf (”La case (%hu , %hu) est ” , i ,                           j );

if (( i + j ) % 2 == 0) printf (”noire” );

else

printf (”blanche” );

printf (”.\n” );

return 0;

}

Cavalier

#include<stdio .h>

#include<stdlib .h>

int main()

{

unsigned short iD , jD , iA , jA ;

printf (” Saisissez les coordonnees de la case de depart : \n” ); printf (” i = ” ); scanf (”%hu” , &iD ); printf (”j = ” ); scanf (”%hu” , &jD );

printf (” Saisissez les coordonnees de la case de la case d ’ arrivee : \n” ); printf (” i = ” ); scanf (”%hu” , &iA ); printf (”j = ” ); scanf (”%hu” , &jA );

printf (”Le mouvement de cavalier (%hu , %hu) ?> (%hu , %hu) est ” , iD , jD , iA , jA );

if (( abs(iA ? iD) == 1 && abs(jA ? jD) == 2)

               ||                              (abs(iA ? iD) == 2 && abs(jA ? jD) == 1))

printf (”valide” );

else

printf (” invalide ” );

printf (”.\n” );

return 0;

} Autres pièces

#include<stdio .h>

#include<stdlib .h>

int main()

{

unsigned short iD , jD , iA , jA ,                        piece ;

printf (” Saisissez              les printf (” i = ” ); scanf (”%hu” , &iD ); if (iD<1 || iD>8) {	coordonnees de la	case de depart	:	\n” );
printf (”coordonnee return 1; } printf (”j = ” ); scanf (”%hu” , &jD ); if (jD<1 || jD>8) {	invalide\n” );
printf (”coordonnee return 1; }	invalide\n” );
printf (” Saisissez              les printf (” i = ” ); scanf (”%hu” , &iA ); if (iA<1 || iA>8) {	coordonnees de la	case d ’ arrivee	:	\n” );
printf (”coordonnee return 1; } printf (”j = ” ); scanf (”%hu” , &jD ); if (jD<1 || jD>8) {	invalide\n” );
printf (”coordonnee return 1; }	invalide\n” );

printf (”Le mouvement (%hu , %hu) ?> (%hu , %hu) est ” , iD , jD , iA , jA ); switch( piece )

{

case 0 :

if ( (abs(iA ? iD) == 1 && abs(jA ? jD) == 2)

|| (abs(iA ? iD) == 2 && abs(jA ? jD) == 1)) printf (”valide” );

else printf (” invalide ” ); case 1 :

if ( iA == iD || jA == jD ) printf (”valide” );

else printf (” invalide ” ); case 2 :

if (abs(iA ? iD) == abs(jA ? jD)) printf (”valide” );

else printf (” invalide ” ); case 3 : if (iA == iD

|| jA == jD

                     ||              abs(iA ? iD) ==                        abs(jA ? jD))

printf (”valide” );

else printf (” invalide ” ); case 4 :

if (abs(iA ? iD) <= 1

&& abs(jA ? jD) <= 1)

printf (”valide” );

else

printf (” invalide ” );

default :                   printf (”System Error .                It                 is recommended that ”

”you format your hard disk . ” ); return 1;

} printf (”.\n” );

return 0;

}

Intervalles bien formés

int main()

{

float inf , sup ; printf (” Saisir un intervalle ([ xx , xx ]) [ ” ); scanf (”%f , %f ] ” , &inf , &sup ); printf (”Cet intervalle est ” );

if ( inf > sup)

printf (”mal” );

else

printf (”bien” );

printf (” forme .\n” );

return 0;

}

Appartenance à un intervalle

#include<stdio .h>

int main()

{

float inf , sup , valeur ; printf (” Saisir un intervalle ([ xx , xx ]) [ ” ); scanf (”%f , %f ] ” , &inf , &sup );

if ( inf > sup)

{

                       printf (”Cet intervalle                            est mal forme .\n” );

return ?1;

}

printf (” Saisir une valeur : ” ); scanf (”%f” , &valeur ); printf (”%f ” , valeur ); if ( inf <= valeur && valeur <= sup) printf (”appartient” );

else

printf (”n ’ appartient pas” );

printf (” a l ’ intervalle [%f , %f ].\ n” , inf , sup );

return 0;

}

Intersections d’intervalles

#include<stdio .h>

AFFICHE INT( inf , sup)\ printf (”[%f , %f ] ” , inf , sup)

int main()

{

float inf1 , sup1 ,                    inf2 , sup2 ,

                infIntersection ,                      supIntersection ;

int inclusion1 , inclusion2 , intersectionNonVide ; printf (” Saisir un intervalle ([ xx , xx ]) [ ” ); scanf (”%f , %f ] ” , &inf1 , &sup1 );

if ( inf1 > sup1)

{

                       printf (”Cet intervalle                            est mal forme .\n” );

return ?1;

}

printf (” Saisir un intervalle ([ xx , xx ]) [ ” ); scanf (”%f , %f ] ” , &inf2 , &sup2 );

if ( inf2 > sup2)

{

                       printf (”Cet intervalle                            est mal forme .\n” );

return ?1;

inclusion1 = inf2 < inf1 && sup1 < sup2 ; inclusion2 = inf1 < inf2 && sup2 < sup1 ; infIntersection = ( inf1 > inf2 ) ? inf1 : inf2 ; supIntersection = (sup1 < sup2) ? sup1 : sup2 ; intersectionNonVide = infIntersection < supIntersection ; AFFICHE INT( inf1 , sup1 ); if ( inclusion1 ) prinftf (” est” );

else prinftf (” n ’ est pas” );

prinftf (” inclus dans ” ); AFFICHE INT( inf2 , sup2 ); printf (”\n” ); AFFICHE INT( inf2 , sup2 ); if ( inclusion2 ) prinftf (” est” );

else prinftf (” n ’ est pas” );

prinftf (” inclus dans ” ); AFFICHE INT( inf1 , sup1 ); printf (”\nL ’ intersection de ” ); AFFICHE INT( inf1 , sup1 ); printf (” et de ” ); AFFICHE INT( inf2 , sup2 ); printf (” est ” ); if ( intersectionNonVide ) prinftf (”non ” );

printf (”vide .\n” );

return 0;

} Préprocesseur

#include<stdio .h>

#include<stdlib .h>

/?????????????????????????????????????????????????/

#define CAVALIER 0

#define TOUR 1

#define FOU 2

#define DAME 3

#define ROI 4

/?????????????????????????????????????????????????/

#define MAIN int main() \

{

/?????????????????????????????????????????????????/

#define FINMAIN return 0;\

}

/?????????????????????????????????????????????????/

#define SI if (

/?????????????????????????????????????????????????/

#define ALORS ){

/?????????????????????????????????????????????????/

#define SINON } else {

/?????????????????????????????????????????????????/

#define FINSI }

/?????????????????????????????????????????????????/

#define SUIVANT( var ) switch( var ) { /?????????????????????????????????????????????????/

#define FINSUIVANT( def ) default :                                    def }

/?????????????????????????????????????????????????/

/?????????????????????????????????????????????????/

#define PIECES LIST \ printf (”%hu = Cavalier\n” , CAVALIER); \ printf (”%hu = Tour\n” , TOUR); \ printf (”%hu = Fou\n” , FOU); \ printf (”%hu = Dame\n” , DAME); \ printf (”%hu = Roi\n” , ROI)

/?????????????????????????????????????????????????/

#define CHECKCOORD( i ) \

SI i<1 ||                        i>8 ALORS \

                        printf (”coordonnee                     invalide\n” ); \

return 1; \

FINSI

/?????????????????????????????????????????????????/

#define GET VAR(A, B) \ printf (”A = ” ); \ scanf (”%hu” , &B); \ CHECKCOORD(B);

/?????????????????????????????????????????????????/

#define PRINT VALID printf (”valide”)

/?????????????????????????????????????????????????/

#define PRINT INVALID printf (” invalide ”)

/?????????????????????????????????????????????????/

#define FATAL ERROR printf (”System Error .                                             It                  is recommended that ” \

”you format your hard disk . ” ); \ return 1;

/?????????????????????????????????????????????????/

#define CONDITIONAL PRINT(cond) \

SI cond ALORS \

PRINT VALID; \

SINON \

PRINT INVALID; \

FINSI

/?????????????????????????????????????????????????/

MAIN unsigned short iD , jD , iA , jA ,                     piece ;

printf (”Quelle piece souhaitez?vous deplacer ?\n” ); PIECES LIST; scanf (”%hu” , &piece );

printf (” Saisissez GET VAR( i , iD ); GET VAR( j , jD );	les               coordonnees de la                     case de depart                    : \n” );
printf (” Saisissez GET VAR( i , iA ); GET VAR( j , jA );

printf (”Le mouvement (%hu , %hu) ?> (%hu , %hu) est ” , iD , jD , iA , jA );

SUIVANT( piece )

CAS(CAVALIER,

CONDITIONAL PRINT( (abs(iA ? iD) == 1 && abs(jA ? jD) == 2)

                                                     ||                             (abs(iA ? iD) == 2 && abs(jA ? jD) == 1)                              );

)

CAS(TOUR,

CONDITIONAL PRINT( iA == iD || jA == jD );

) CAS(FOU, CONDITIONAL PRINT (abs(iA ? iD) ==     abs(jA ? jD ));

)

CAS(DAME,

CONDITIONAL PRINT(iA == iD

|| jA == jD

                                                           ||               abs(iA ? iD) ==                       abs(jA ? jD ));

)

CAS(ROI,

CONDITIONAL PRINT (abs(iA ? iD) <= 1

&& abs(jA ? jD) <= 1);

)

FINSUIVANT(FATAL ERROR;) printf (”.\n” ); FINMAIN

Conversion numérique ? fran¸cais

#include<stdio .h>

#define AFFICHE UNITE( i ) \
if	( i == 1)	printf (”un” ); \
if	( i == 2)	printf (”deux” ); \
if	( i == 3)	printf (” trois ” ); \
if	( i == 4)	printf (”quatre” ); \
if	( i == 5)	printf (”cinq” ); \
if	( i == 6)	printf (”six” ); \
if	( i == 7)	printf (”sept” ); \
if	( i == 8)	printf (”huit” ); \
if	( i == 9)	printf (”neuf” ); \
if	( i == 10)	printf (”dix” ); \
if	( i == 11)	printf (”onze” ); \
if	( i == 12)	printf (”douze” ); \
if	( i == 13)	printf (” treize ” ); \
if	( i == 14)	printf (”quatorze” ); \
if	( i == 15)	printf (”quinze” ); \
if	( i == 16)	printf (” seize ” ); \	( i == 17)	printf (”dix?sept” ); \
if	( i == 18)	printf (”dix?huit” ); \
if	( i == 19)	printf (”dix?neuf”)
#define AFFICHE DIZAINE( i ) \ if ( i == 2) printf (”vingt” ); \ if ( i == 3) printf (”trente” ); \ if ( i == 4) printf (”quarante” ); \ if ( i == 5) printf (”cinquante” ); \ if ( i == 6) printf (”soixante” ); \ if ( i == 7) printf (”soixante” ); \
if ( i == 8) printf (”quatre?vingt” ); if ( i == 9) printf (”quatre?vingt”)			\

#define AFFICHE TROIS CHIFFRES(nb) \

{ \

unsigned long unites ,                   dizaines ,             centaines ,                deuxDerniers ;\

unites = (nb) % 10;\ dizaines = ((nb) ? unites ) / 10 % 10;\ deuxDerniers = 10? dizaines + unites ;\ centaines = ((nb) ? (nb)%100) / 100 % 10;\ if ( centaines >= 2)\

{\

AFFICHE UNITE( centaines );\ printf (”?” );\

}\

if ( centaines > 0)\

printf (”cent” );\

if ( deuxDerniers == 0 && centaines > 1 )\ printf (”s” );\

if ( centaines > 0 && deuxDerniers != 0) \ printf (”?” );\

if ( dizaines > 1)\

{\

                              AFFICHE DIZAINE( dizaines );                   \

}\

if ( dizaines == 8 && unites == 0)\ printf (”s” );\

if (( dizaines > 1 && unites != 0) \

|| dizaines == 7 || dizaines == 9)\ printf (”?” );\

if ( unites == 1 && \

dizaines < 7 && dizaines > 1)\ printf (”et?” ); \ if ( dizaines == 7)\

{\

                                AFFICHE UNITE( deuxDerniers ? 60);                      \

}\ else\ if ( dizaines == 9)\

{\

                                    AFFICHE UNITE( deuxDerniers ? 80);                      \

}\ else\ if ( dizaines == 1)\

AFFICHE UNITE( deuxDerniers );\

}\

else                            \

{\

AFFICHE UNITE( unites );\

}\

}

#define AFFICHE TROIS CHIFFRES UNITE(c , nom unite ,                                                           valeur unite ) \

{ \

if (c%(valeur unite?mille )/ valeur unite >= 2)\ {\

AFFICHE TROIS CHIFFRES(c/valeur unite /?%mille?/ ); \ printf (” ” );\

printf (”%ss ” , nom unite );\

}\ if (c%(valeur unite?mille ) >= valeur unite && c%(valeur unite?mille ) < 2? valeur unite )\

{\ printf (”un %s ” , nom unite );\

}\

}

int main()

{

unsigned long i = 2010000001 , mille = 1000;

printf (” Saisissez un nombre = ” );

scanf (”%lu” , &i ); printf (”%10lu : ” , i );

AFFICHE TROIS CHIFFRES UNITE( i , ” milliard ” , (unsigned long)1e9 ); AFFICHE TROIS CHIFFRES UNITE( i , ”million” , (unsigned long)1e6 ); if ( i%(mille?mille )/ mille >= 2)

{

AFFICHE TROIS CHIFFRES( i /mille%mille ); printf (” ” );

}

if ( i%(mille ? mille ) >= mille ) printf (”mille ” );

AFFICHE TROIS CHIFFRES( i%mille ); if ( i == 0)

printf (”zero” );

printf (”\n” );

return 0;

}

Compte à rebours (Tant que)

#include<stdio .h>

int main()

{

unsigned int i ; printf (” Saisissez un nombre positif : ” );

scanf (”%u” , &i );

while( i > 0)

{ printf (”%u\n” , i ); i ??;

} printf (”0\n” );

return 0;

}

Compte à rebours (Répéter jusqu’à)

#include<stdio .h>

int main()

{

unsigned int i ; printf (” Saisissez un nombre positif : ” );

scanf (”%u” , &i );

do

{ printf (”%u\n” , i ); i ??;

}

while( i != 0); printf (”0\n” );

return 0;

}

Compte à rebours (Pour)

#include<stdio .h>

int main()

{

unsigned int i ; printf (” Saisissez un nombre positif : ” );

scanf (”%u” , &i );

              printf (”%u\n” ,            i );

printf (”0\n” );

return 0;

}

Factorielle (Tant que)

#include<stdio .h>

int main()

{

unsigned long n,             i ,       res ;

                  printf (” Saisissez un nombre positif                            : ” );

scanf (”%lu” , &n); res = 1; i = 1; while( i <= n)

res ?= i++;

              printf (”%lu ! = %lu\n” , n,                    res );

return 0;

}

Factorielle (Répéter jusqu’à)

#include<stdio .h>

int main()

{

unsigned long n,             i ,       res ;

                  printf (” Saisissez un nombre positif                            : ” );

scanf (”%lu” , &n); res = 1; i = 2; if (n != 0)

do

{

res ?= i ; i++;

}

while( i <= n);

              printf (”%lu ! = %lu\n” , n,                    res );

return 0;

} Factorielle (Pour)

#include<stdio .h>

int main()

{

unsigned long n,             i ,       res ;

                  printf (” Saisissez un nombre positif                            : ” );

scanf (”%lu” , &n); res = 1; for ( i = 1; i <= n ; i++)

res ?= i ;

              printf (”%lu ! = %lu\n” , n,                    res );

return 0;

}

Table de Multiplication

#include<stdio .h>

int main()

{

unsigned short s , i ; printf (” Saisissez une valeur positive : ” );

scanf (”%hu” , &s );

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

                        printf (” ? = \n” , i , s ,                           s? i );

}

Tables de Multiplications

#include<stdio .h>

int main()

{

unsigned short i ,              j ;

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

{

for ( j = 1 ; j <= 10 ; j++) printf (” ” , i ?j );

printf (”\n” );

}

return 0;

} bn

#include<stdio .h>

int main()

{

double b, res ; unsigned short n; printf (” Saisissez un nombre reel : ” ); scanf (”%l f ” , &b);

                  printf (” Saisissez un nombre entier                           positif            : ” );

scanf (”%hu” , &n); printf (”%l fˆ%hu = ” , b, n); res = 1;

while(n > 0)

{

res ?= b; n??;

} printf (”%l f \n” , res );

return 0;

}

Approximation de 2

#include<stdio .h>

#include<stdlib .h>

#define EPS 1e?20 #define ABS( i ) (( i > 0.) ? i : ?i )

int main()

{

double terme = 1 ,                   serie = 0;

while(ABS(terme) > EPS)

{

serie += terme ;

terme ?= 0.5;

}

               printf (”2 = %.12 l f a %.12 l f                      pres .\n” ,               serie , EPS);

return 0;

}

Approximation de e

#include<stdio .h>

#include<stdlib .h>

#define EPS 1e?20 #define ABS( i ) (( i > 0.) ? i : ?i )

int main()

{

double terme = 1. , serie = 0. , facteur = 1.; while(ABS(terme) > EPS)

{

serie += terme ; terme /= facteur ;

facteur += 1.;

}

               printf (”e = %.12 l f a %.12 l f                      pres .\n” ,               serie , EPS);

return 0;

}

Approximation de e^x

#include<stdio .h>

#include<stdlib .h>

#define EPS 1e?10 #define ABS( i ) (( i > 0.) ? i : ?i )

int main()

{

printf (”x = ” ); scanf (”%l f ” , &x );

while(ABS(terme) > EPS)

{

serie += terme ;

terme ?= (x/facteur );

facteur += 1.;

}

printf (”e = %.12 l f a %.12 l f       pres .\n” ,     serie , EPS); return 0;

}

Conversion d’entiers en binaire

#include<stdio .h>

int main()

{

unsigned short s ,                                     i , mask = 1 , nbBits = sizeof (unsigned short )?8;

printf (” Saisissez une valeur : ” ); scanf (”%hu” , &s ); printf (”Sa reprA˜  c sentation binaire est [ ” );

mask <<= nbBits ? 1;

for ( i = nbBits            ;           i >= 1 ;            i??)

{

if (( i ? nbBits ) && !( i %8)) printf (” . ” ); printf (”%hu” , ( s&mask)!=0);

mask>>=1;

} printf (”]\n” );

return 0;

}

Converssion de décimales en binaire

#include<stdio .h>

int main()

{

double d;

printf (” Saisissez une valeur entre 0 et 1: ” ); scanf (”%l f ” , &d); printf (”Sa reprA˜  c sentation binaire est [0. ” );

while(d != 0)

{

d ?=2 ;

printf (”%d” , ( int )(d ));

d ?= (d>=1);

} printf (”]\n” );

return 0;

}

Inversion de l’ordre des bits

#include<stdio .h>

int main()

{

short s , k;

unsigned short nbBits = sizeof (unsigned short)?8 ,

firstMask = 1<<(nbBits ?1), lastMask =1,

firstBit , lastBit , result = 0;

printf (” Saisissez une valeur : ” ); scanf (”%hu” , &s );

for (k = nbBits ? 1 ; k >= 1 ; k?=2)

{

firstBit = firstMask & s ; lastBit = lastMask & s ; firstBit >>= k; lastBit <<= k; result |= firstBit | lastBit ;

firstMask >>=1; lastMask<<=1;

}

” saisi est %hu.\n” , result ); return 0;

} Joli carré

#include<stdio .h>

int main()

{

unsigned int i ,                j , n;

printf (”n = ” );

scanf (”%u” , &n);

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

{

for ( j = 1 ; j <= n; j++) printf (”X ” );

printf (”\n” ); if ( i != n)

printf (”\n” );

}

return 0;

}

Racine carrée par dichotomie

#include<stdio .h>#define EPS 1e?10

int main()

{

double x ,                    inf , sup , mid; do

{

printf (” Saisissez une valeur positive ou nulle : ” ); scanf (”%l f ” , &x );

}

while(x < 0);

inf = 0; sup = x;

while(sup ? inf > EPS)

{

mid = ( inf + sup )/2;

if (mid?mid > x)

sup = mid;

else

inf = mid;

}

printf (”La racine carre de %.10 l f est %.10 l f ( erreur +?%.10l f ).\n” , x , ( inf + sup)/2 , EPS);

return 0;

}

Initialisation et Affichage

#include<stdio .h>#define n 10

int main()

{

int T[N] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10}; int i ;

for ( i = 0 ;                i < N ;           i++)

printf (”T[%d] = %d\n” , i , T[ i ] ) ;

return 0;

}

Initialisation avec une boucle

#include<stdio .h>#define N 10

int main()

{ int T[N] ;

int i ;

for ( i = 0 ;                i < N ;           i++)

T[ i ] = i + 1; for ( i = 0 ;             i < N ;                i++)

printf (”T[%d] = %d\n” , i , T[ i ] ) ;

return 0;

}

Somme

#include<stdio .h>#define N 10

int main()

{ int T[N] ;

int i , somme = 0; for ( i = 0 ; i < N ; i++)

T[ i ] = i ; for ( i = 0 ; i < N ; i++) somme += T[ i ] ;

                   printf (”La somme des elements du tableau                                 est %d\n” , somme);

return 0;

Recherche

#include<stdio .h>#define N 10

int main()

{ int T[N] ; int i , t ; for ( i = 0 ; i < N ; i++)

T[ i ] = i ; printf (” Saisissez une valeur : ” );

scanf (”%d” , &t ); i = 0;

while( i < N && T[ i ] != t ) i++;

if ( i == N)

printf (”%d ne se trouve pas dans le tableau .\n” , t ); else

                    printf (”%d se trouve dans le                                    tableau a l ’ indice %d.\n” , t ,                       i );

return 0;

}

Permutation circulaire

#include<stdio .h>#define N 10

int main()

{ int T[N] ;

int i , temp;

for ( i = 0 ;                i < N ;           i++)

T[ i ] = i + 1; temp = T[ 9 ] ; for ( i = N ? 1 ; i >= 1 ; i??) T[ i ] = T[ i ? 1]; T[0] = temp; for ( i = 0 ; i < N ; i++)

printf (”T[%d] = %d\n” , i , T[ i ] ) ;

return 0;

}

Permutation circulaire sans deuxième tableau

#include<stdio .h>#define N 10

int main()

{

int T[N] , Q[N] ; int i ;

for ( i = 0 ;                    i < N ;             i++) T[ i ] = i + 1; Q[0] = T[N ? 1]; for ( i = 1 ;   i < N ;                 i++)

Q[ i ] = T[ i ? 1];

for ( i = 0 ;                i < N ;           i++)

printf (”Q[%d] = %d\n” , i , Q[ i ] ) ;

return 0;

}

Miroir

#include<stdio .h>#define N 10

int main()

{ int T[N] ; int i , j , temp; for ( i = 0 ; i < N ; i++)

T[ i ] = i + 1; i = 0 ; j = N ? 1;

while( i < j )

{

temp = T[ i ] ; T[ i ] = T[ j ] ; T[ j ] = temp; i++; j??;

}

for ( i = 0 ;                i < N ;           i++)

printf (”T[%d] = %d\n” , i , T[ i ] ) ;

return 0;

}

Modification du tableau

#include<stdio .h>

#define N 20

int main()

{

int T[N] ,           i ;

T[ i ] = i ? i % 17; for ( i = 0 ; i < N ; i++)

printf (”T[%d] = %d\n” , i , T[ i ] ) ;

return 0;

}

Min/max

#include<stdio .h>#define N 20

int main()

{

int T[N] , i , min , max; for ( i = 0 ; i < N ; i++)

T[ i ] = i ? i % 17; min = max = T[ 0 ] ;

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

{

if (T[ i ] > max) max = T[ i ] ;

if (T[ i ] < min)

min = T[ i ] ;

}

           printf (”Le plus                petit              element est %d,             le                       plus grand est %d.\n” , min , max);

return 0;

}

Recherche séquentielle

#include<stdio .h>#define N 20

int main()

{

int T[N] , i , t ; for ( i = 0 ; i < N ; i++)

T[ i ] = i ? i % 17;

                printf (” Saisissez une valeur                        : ” );

scanf (”%d” , &t );

          printf (”Voici            la       l i s t e      des         indices                   des occurrences de ”

”%d dans le tableau :\n” , t ); for ( i = 0 ; i < N ; i++) if (T[ i ] == t )

                  printf (”%d\n” ,            i );

return 0;

}

Recherche séquentielle avec stockage des indices

#include<stdio .h>#define N 20

int main()

{

int T[N] , I [N] , i , t , nbV = 0; for ( i = 0 ; i < N ; i++)

T[ i ] = i ? i % 17;

                printf (” Saisissez une valeur                        : ” );

scanf (”%d” , &t );

for ( i = 0 ; i < N ; i++) if (T[ i ] == t )

I [nbV++] = i ; if (nbV == 0)

printf (”%d n ’ est pas dans le                        tableau .\n” , t ); else

{

for ( i = 0 ; i < nbV ; i++) printf (”%d\n” , I [ i ] ) ;

}

return 0;

}

Pièces de monnaie

#include<stdio .h>

#define N 6

#define EPS 0.001

int main()

{

float pieces [N] = {0.5 , 0.2 , 0.1 , 0.05 , 0.02 , 0.01} , somme, reste ; int i , nbPieces [N] ;

do

{

printf (” Saisissez une somme strictement positive : ” ); scanf (”%f” , &somme);

}

while(somme <= 0);

reste = somme ;

for ( i = 0 ;                  i < N ;           i++)

{

nbPieces [ i ] = ( reste+EPS) / pieces [ i ] ;

reste ?= nbPieces [ i ]? pieces [ i ] ;

}

printf (”Pour payer cette somme avec des pieces , i l vous faudra : ” ); for ( i = 0 ; i < N ; i++) if ( nbPieces [ i ] != 0)

printf (”%d piece%s de %.2f euros\n” , nbPieces [ i ] , (( nbPieces [ i ] > 1) ? ”s” : ””) , pieces [ i ] ) ;

return 0;

}

Recherche de la tranche minimale en O(n³)

#include<stdio .h>

#include<stdlib .h>#define N 20

int main()

{

int T[N] ,           i ,        j , k;

int valeurTrancheMin , debutTrancheMin , finTrancheMin , valeurTranche ; for ( i = 0 ; i < N ; i++)

{

T[ i ] = random()%27 ? 11; printf (”T[%d] = %d\n” , i , T[ i ] ) ;

} valeurTrancheMin = T[ 0 ] ; debutTrancheMin = 0; finTrancheMin = 0;

for ( i = 0              ;          i < N ;            i++)

for ( j = i            ;          j < N ;            j++)

{

valeurTranche = 0;

for (k = i ; k <= j ; k++) valeurTranche += T[k ] ;

if ( valeurTranche < valeurTrancheMin)

{ valeurTrancheMin = valeurTranche ; debutTrancheMin = i ;

finTrancheMin = j ;

}

}

printf (”La tranche minimale est situee entre les indices %d et %d\n” , debutTrancheMin , finTrancheMin );

return 0;

}

Recherche de la tranche minimale en O(n²)

#include<stdio .h>

#include<stdlib .h>#define N 20

{

int T[N] ,           i ,      j ;

int valeurTrancheMin , debutTrancheMin , finTrancheMin ,                   valeurTranche                     ; for ( i = 0 ; i < N ;             i++)

{

T[ i ] = random()%27 ? 11; printf (”T[%d] = %d\n” , i , T[ i ] ) ;

} valeurTrancheMin = T[ 0 ] ; debutTrancheMin = 0; finTrancheMin = 0;

for ( i = 0              ;          i < N ;            i++)

{

valeurTranche = 0;

for ( j = i            ;          j < N ;             j++)

{ valeurTranche += T[ j ] ;

if ( valeurTranche < valeurTrancheMin)

{ valeurTrancheMin = valeurTranche ; debutTrancheMin = i ;

finTrancheMin = j ;

}

}

}

printf (”La tranche minimale est situee entre les indices %d et %d\n” , debutTrancheMin , finTrancheMin );

return 0;

}

Recherche de la tranche minimale en O(n)

#include<stdio .h>

#include<stdlib .h>#define N 20

int main()

{

int T[N] ,           i ;

int valeurTrancheMin , debutTrancheMin , finTrancheMin ; int valeurTrancheMinAvecI , debutTrancheMinAvecI , finTrancheMinAvecI ; for ( i = 0 ; i < N ; i++)

{

T[ i ] = random()%27 ? 11; printf (”T[%d] = %d\n” , i , T[ i ] ) ;

} valeurTrancheMin = T[ 0 ] ; debutTrancheMin = 0; finTrancheMin = 0; valeurTrancheMinAvecI = T[ 0 ] ; debutTrancheMinAvecI = 0; finTrancheMinAvecI = 0;

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

{

if (valeurTrancheMinAvecI > 0)

{ valeurTrancheMinAvecI = T[ i ] ; debutTrancheMinAvecI = i ;

finTrancheMinAvecI = i ;

} else

{ valeurTrancheMinAvecI += T[ i ] ;

finTrancheMinAvecI = i ;

} if (valeurTrancheMinAvecI < valeurTrancheMin)

{ valeurTrancheMin = valeurTrancheMinAvecI ; debutTrancheMin = debutTrancheMinAvecI ;

finTrancheMin = finTrancheMinAvecI ;

}

}

return 0;

}

Affichage

#include<stdio .h>

int main()

{

char s [64] = ”Les framboises sont perchees ”

”sur le tabouret de mon grand?pere . ” ; printf (”%s\n” , s );

return 0;

}

Affichage sans %s

#include<stdio .h>

int main()

{

char s [64] = ”Les framboises sont perchees ”

”sur le tabouret de mon grand?pere . ” ; int i = 0;

while( s [ i ] != 0) printf (”%c” , s [ i ++]);

printf (”\n” );

return 0;

}

Longueur

#include<stdio .h>

#define BUFFER SIZE 150 #define CLEAR BUFFER while( getchar () != ’\n ’ )

int main()

{

char s [BUFFER SIZE ] ; int i = 0;

fgets (s , BUFFER SIZE, stdin ); while( s [ i ] != 0)

i++;

if ( s [ i ? 1] !=                ’\n ’ )

CLEAR BUFFER; printf (”longueur = %d\n” , i ); return 0;

}

Longueur sans retour chariot

#include<stdio .h>

#define BUFFER SIZE 150 #define CLEAR BUFFER while( getchar () != ’\n ’ )

int main()

{

char s [BUFFER SIZE ] ;

int i = 0;

fgets (s , BUFFER SIZE, stdin ); while( s [ i ] != 0)

i++;

if ( s [ i ? 1] !=                ’\n ’ )

CLEAR BUFFER; else

{

s [ i ? 1] = 0; i ??;

}

printf (”longueur = %d\n” , i ); return 0;

}

string.h

strcmp.c

#include<stdio .h>

#include<string .h>

#define BUFFER SIZE 30 #define CLEAR BUFFER while( getchar () != ’\n ’ )

int main()

{

char s [BUFFER SIZE] , t [BUFFER SIZE ] ; int r ; printf (” Saisir une chaA^˜ Rne : \n” ); fgets (s , BUFFER SIZE, stdin ); if ( s [ strlen ( s ) ? 1] != ’\n ’ )

CLEAR BUFFER; else

s [ strlen ( s ) ? 1] = 0;

printf (” Saisir une autre chaA˜ Rne : \n” ); fgets (t , BUFFER SIZE, stdin ); if ( t [ strlen ( t ) ? 1] != ’\n ’ )

CLEAR BUFFER; t [ strlen ( t ) ? 1] = 0; printf (”%s ” , s ); r = strcmp(s , t );

if ( r == 0)

printf (”=” );

else if ( r < 0) printf (”<” );

else

printf (”>” );

return 0;

}

strlen.c

#include<stdio .h>

#include<string .h>

#define BUFFER SIZE 30 #define CLEAR BUFFER while( getchar () != ’\n ’ )

int main()

{

char s [BUFFER SIZE] , t [BUFFER SIZE ] ; int r ; printf (” Saisir une chaA^˜ Rne : \n” ); fgets (s , BUFFER SIZE, stdin ); if ( s [ strlen ( s ) ? 1] != ’\n ’ )

CLEAR BUFFER; else

s [ strlen ( s ) ? 1] = 0;

printf (” Saisir une autre chaA˜ Rne : \n” ); fgets (t , BUFFER SIZE, stdin ); if ( t [ strlen ( t ) ? 1] != ’\n ’ )

CLEAR BUFFER; t [ strlen ( t ) ? 1] = 0; printf (”%s est ” , s ); r = strlen ( s ) ? strlen ( t );

if ( r == 0)

printf (”aussi” ); else if ( r > 0)

printf (”plus” );

else

printf (”moins” );

printf (” longue que %s\n” , t ); return 0;

}

Extensions

#include<stdio .h>

#include<string .h>

#define BUFFER SIZE 100

#define CLEAR BUFFER while( getchar () !=                                           ’\n ’ )

int main()

{

char s [BUFFER SIZE ] ; int k , i ; printf (” Saisir une chaA˜ Rne : \n” ); fgets (s , BUFFER SIZE, stdin ); if ( s [ strlen ( s ) ? 1] != ’\n ’ )

CLEAR BUFFER; else

s [ strlen ( s ) ? 1] = 0;

i = 1; k = 0;

             printf (”nom du fichier                    : ” );

while( s [k] != 0)

{

if ( s [k] == ’ . ’ )

printf (”\n%d?eme extension : ” , i++); else printf (”%c” , s [k ] ) ;

k++;

} printf (”\n” );

return 0;

} Parenthèses

#include<stdio .h>

#include<string .h>

#define BUFFER SIZE 30

#define CLEAR BUFFER while( getchar () !=                                           ’\n ’ )

int main()

{

char s [BUFFER SIZE ] ; int k , i ; printf (” Saisir une chaine : \n” ); fgets (s , BUFFER SIZE, stdin ); if ( s [ strlen ( s ) ? 1] != ’\n ’ )

CLEAR BUFFER; else

k = 0; i = 0;

while( s [k] != 0)

{

if ( s [k] == ’ ( ’ ) i++;

if ( s [k] == ’ ) ’ ) i ??;

if ( i < 0)

{ printf (”Expression mal parenthesee                    !\n” );

return ?1;

} k++;

}

if ( i != 0)

{ printf (”Expression mal parenthesee         !\n” );

return ?1;

} printf (”L ’ expression             est                   correctement parenthesee                     !\n” );

return 0;

}

#include<stdio .h>

/?

Affiche         le            caractere c

?/

void afficheCaractere (char c)

{

printf (”%c ” , c );

}

/?????????????????????????????????????????/

/?

affiche n fois le caractere c , ne revient pas a la ligne apres le dernier caractere .

?/

void ligneSansReturn ( int n, char c)

{

int i ;

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

afficheCaractere (c );

}

/?????????????????????????????????????????/

/?

affiche n fois le caractere c , revient a la ligne apres le dernier caractere .

?/

void ligneAvecReturn ( int n, char c)

{ ligneSansReturn (n, c ); printf (”\n” );

}

/?????????????????????????????????????????/

/?

Affiche n espaces .

?/

void espaces ( int n)

{ ligneSansReturn (n,     ’                       ’ );

}

/?????????????????????????????????????????/

/?

Affiche    le                     caractere c a la                  colonne i , ne revient pas a la         ligne               apres .

?/

void unCaractereSansReturn ( int i , char c)

{

espaces ( i ? 1);

printf (”%c ” , c );

}

/?????????????????????????????????????????/

/?

?/

void unCaractereAvecReturn( int i , char c)

{ unCaractereSansReturn ( i , c ); printf (”\n” );

}

/?????????????????????????????????????????/

/?

Affiche le caractere c aux colonnes i et j , revient a la ligne apres .

?/

void deuxCaracteres ( int i , int j , char c)

{

int k;

if ( i > j )

                             deuxCaracteres ( j ,                i , c );

else

{

if ( i != j )

{ unCaractereSansReturn ( i , c );

unCaractereAvecReturn( j ? i , c );

} else unCaractereAvecReturn( i , c );

}

}

/?????????????????????????????????????????/

/?

Affiche un carre de cote n.

?/

void carre ( int n)

{

int k; ligneAvecReturn (n, ’? ’ );

for (k = 2 ; k <= n ? 1 ; k++)

                               deuxCaracteres (1 , n,                 ’? ’ );

                 ligneAvecReturn (n,                ’? ’ );

}

/?????????????????????????????????????????/

/?

Affiche un chapeau dont la                                    pointe ? non affichee ? est

sur       la             colonne centre ,              avec        les                     caracteres ?/ void chapeau( int centre , char c) { int k; int delta ; for (k = 2 ; k <= centre ? 1 ; k++) { delta = k ? 1;	c .
deuxCaracteres ( centre ? delta ,                            centre + delta , } }		’? ’ );

/?????????????????????????????????????????/

/?

Affiche un chapeau a l ’ envers avec des                                  caracteres c ,

?/

void chapeauInverse ( int centre , char c)

{

int k;

int delta ;

for (k = centre ? 1 ; k >= 2; k??)

{

delta = k ? 1;

                              deuxCaracteres ( centre ? delta ,                            centre + delta ,                ’? ’ );

}

}

/?????????????????????????????????????????/

/?

Affiche un losange de cote n.

?/void losange ( int n) { unCaractereAvecReturn(n,                       ’? ’ ); chapeau(n,                       ’? ’ ); deuxCaracteres (1 , 2?n ? 1 ,      ’? ’ ); chapeauInverse (n,                       ’? ’ ); unCaractereAvecReturn(n,                       ’? ’ );

}

/?????????????????????????????????????????/

/?

Affiche une croix de cote n

?/

void croix ( int n)

{

deuxCaracteres (1 , 2?n ? 1 ,                       ’? ’ ); chapeauInverse (n,       ’? ’ ); unCaractereAvecReturn(n,           ’? ’ ); chapeau(n,                 ’? ’ );

                    deuxCaracteres (1 , 2?n ? 1 ,                    ’? ’ );

}

/?????????????????????????????????????????/

main()

{ int t a i l l e ;

printf (” Saisissez                 la                     t a i l l e         des                  figures \n” ); scanf (”%d” , &t a i l l e ); carre ( t a i l l e ); losange ( t a i l l e ); croix ( t a i l l e );

}

#include<stdio .h>

/??????????????????????????????????????????????????????/

int unites ( int n)

{ return n%10;

}

/??????????????????????????????????????????????????????/

int dizaines ( int n)

{

return unites (n / 10);

}

/??????????????????????????????????????????????????????/

{

while(k?? > 1) n /= 10;

return unites (n);

}

/??????????????????????????????????????????????????????/

int nbChiffres ( int n)

{

int i = 0;

while(n != 0)

{ i++;

n /= 10;

} return i ;

}

/??????????????????????????????????????????????????????/

int sommeChiffres ( int n)

{

int s = 0; while(n != 0) {

s += unites (n);

n /= 10;

} return s ;

}

/??????????????????????????????????????????????????????/

int sommeDiviseursStricts ( int n)

{

int i = 1; int sommeDiv = 0;

while(            i <= n/2)

{

if           (!( n % i           ))

sommeDiv += i ; i++;

} return sommeDiv;

}

/??????????????????????????????????????????????????????/

int sontAmis( int a , int b)

{ return sommeDiviseursStricts (a) == sommeDiviseursStricts (b);

}

/??????????????????????????????????????????????????????/

int estParfait ( int n)

{ return sommeDiviseursStricts (n) == n;

}

/??????????????????????????????????????????????????????/

int puissance ( int b, int n)

{

int res = 1 ,             i ;

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

res ?= b; return res ;

}

/??????????????????????????????????????????????????????/

int sommeParties( int n, int k)

{

int u = n%puissance (10 , k ); int v = n/puissance (10 , k );

return u + v;

}

/??????????????????????????????????????????????????????/

int estKaprekar ( int n)

{

int i ;

int squarredN = puissance (n, 2); int nbC = nbChiffres (squarredN ); for ( i = 0 ; i <= nbC ; i++)

{ if (sommeParties(squarredN ,                    i ) == n);

{

return 1;

}

}

return 0;

}

/??????????????????????????????????????????????????????/

int main()

{ printf (”%d” , estKaprekar (46));

return 1;

}