TP N° 1 : entrées sorties sous C

Exercice 0 (TD)

Cocher les identificateurs corrects, dites pourquoi les autres sont incorrects :

nom1	1nom	nom_2	nom.2	_nom_3	-nom-3
Nom_de_variable	Nom de variable	deuxieme_choix	deuxième_choix	mot_francais	mot_français
fonction-1	3e_jour	__A_	_MOYENNE_du_MOIS_	a	limite_inf.
lim_supérieure	_	3

Exercice 1 (TD)

Ci-dessous, vous trouvez un simple programme en C. Essayez de distinguer et de classifier autant que possible les éléments qui composent ce programme (commentaires, variables, déclarations, instructions, etc.)

/* Ce programme calcule la somme
   de 4 nombres entiers introduits
   au clavier.
*/

#include <stdio.h>
int main(void)
{
    int NOMBRE, SOMME, COMPTEUR;
    /* Initialisation des variables */
    SOMME = 0;
    COMPTEUR = 0;
    /* Lecture des données */
    while (COMPTEUR < 4)
    {
         /* Lire la valeur du nombre suivant */
         printf("Entrez un nombre entier :");
         scanf("%i", &NOMBRE);
         /* Ajouter le nombre au résultat */
         SOMME += NOMBRE;
         /* Incrémenter le compteur */
         COMPTEUR++;
    }
    /* Impression du résultat */
    printf("La somme est: %i \n", SOMME);
    return 0;
}

**Les mots-clés**
auto	double	int	struct
break	else	long	switch
case	enum	register	typedef
char	extern	return	union
const	float	short	unsigned
continue	for	signed	void
default	goto	sizeof	volatile
do	if	static	while

Créer un répertoire TP1 afin d'y placer tous les programmes correspondant aux exercices suivants

Exercice 1bis : bonjour

Nom du programme : essai.c Ce programme doit afficher le message : Hello world!

Compiler le programme sous le nom de essai et l'exécuter.
Passer sous shell et vérifier l'existence des fichiers et les droits (ls -l) ou sous le gestionnaire de fichiers

Quelle commande utiliser pour exécuter le programme dans la fenêtre console ?

Exercice 2 : affichage des nombres

Programme nombre.c : Ce programme doit afficher des valeurs numériques de nombres entiers et de nombres réels , déclarer et utiliser une variable n pour les entiers et x pour les réels.

Affecter des valeurs 2001 à n et 3.1416 à x et les afficher selon différents formats : naturel, en octal, en hexadécimal pour n et en décimal ou en notation scientifique pour x puis sur 5 chiffres, avec trois décimales .

Rappels : spécificateurs de format pour printf
SYMBOLE	TYPE	IMPRESSION COMME
%d ou %i	int	entier relatif
%u	int	entier naturel (unsigned)
%o	int	entier exprimé en octal
%x	int	entier exprimé en hexadécimal
%c	int	caractère
%f %nf %.nf	double	rationnel en notation décimale avec un nombre fixe n de chiffres après la virgule
%e	double	rationnel en notation scientifique
%s	char*	chaîne de caractères

Arguments du type long
Les spécificateurs %d, %i, %u, %o, %x peuvent seulement représenter des valeurs du type int ou unsigned int.
Une valeur trop grande pour être codée dans deux octets est coupée sans avertissement si nous utilisons %d.
Pour pouvoir traiter correctement les arguments du type long, il faut utiliser les spécificateurs %ld, %li, %lu, %lo, %lx.

Améliorer la présentation en utilisant les caractères de mise en page (Séquences d'échappement) puis afficher le message suivant "Le fichier d'interrogation est "sous" la racine \ du disque dur."


\a	sonnerie	\\	trait oblique
\b	curseur arrière	\?	point d'interrogation
\t	tabulation	\'	apostrophe
\n	nouvelle ligne	\"	guillemets
\r	retour au début de ligne	\f	saut de page (imprimante)
\0	NUL	\v	tabulateur vertical

Exercice 3 : Programme calcul.c

Contrôle des saisies : saisir deux valeurs et afficher leur valeur, puis calculer et afficher leur somme som, le minimum min , le maximum max (utilisation d'une conditionnelle).

Rappel de la syntaxe : if (condition) instruction1; else instruction2;

Exercice 4 : les opérateurs

a) Sans utiliser l'ordinateur, trouvez et notez les résultats du programme ci-dessous.

b) Vérifiez vos résultats à l'aide de l'ordinateur.

#include <stdio.h>

int main(void)
{
   int N=10, P=5, Q=10, R;
   char C='S';

   N = 5; P = 2; Q = N++ > P || P++ != 3;
   printf ("C : N=%d P=%d Q=%d\n", N, P, Q);

   N = 5; P = 2; Q = N++ < P || P++ != 3;
   printf ("D : N=%d P=%d Q=%d\n", N, P, Q);

   N = 5; P = 2; Q = ++N == 3 && ++P == 3;
   printf ("E : N=%d P=%d Q=%d\n", N, P, Q);

   N=5; P=2; Q = ++N == 6 && ++P == 3;
   printf ("F : N=%d P=%d Q=%d\n", N, P, Q);

   N=C;
   printf ("G : %c %c\n", C, N);
   printf ("H : %d %d\n", C, N);
   printf ("I : %x %x\n", C, N);
   return 0;
}

Exercice 5 : représentation en mémoire

Recopier les lignes suivantes du programme, le compiler, l'exécuter, puis rajouter les lignes de code demandées aux questions 1, 2, 3 et 4, et exécuter a nouveau en remarquant les nouveautés. (On pourra dans un premier temps se dispenser de recopier les commentaires)

#include <stdio.h>

int main(void)
{
     int a,b,i; float x,y; char c,s ; /* declarations des variables */
     int *pa, *pb; float *px, *py; char *pc, *ps, *p; /* declarations de pointeurs */
     a=54; b=-12;x=1.5; y=-1,25;c='k'; s='é'; /* affectation des valeurs aux variables */
     
     /* question 1 : en s'inspirant de l'instruction suivante
     afficher les valeurs des variables a,b,x,y,c, s avec les bons formats */
     printf("la valeur de a est %i\n",a);
     
     /* question 2 : en s'inspirant de l'instruction suivante
     afficher la taille de la place memoire requise par ces variables */
     printf("la taille d\'une variable de type int est de %i octets \n",(int) sizeof(a));
    
     /* question 2 (suite): et les
     categories de variables ou types */
    
     printf("la taille d\'un type int est de %i octets \n", (int) sizeof(int));
    
     /* question 2 (fin): remarquer le polymorphisme
     de la fonction size of qui s'applique aussi bien
     sur des variables que sur des categories de variables ou types */
    
     /* question 3 :reprendre les
     instructions suivantes en utilisant a la place de la variable a
     les variables b,x,y,c,s et les pointeurs correspondants */
    
     pa= &a; /* l'operateur & signifie adresse de */
     printf("la valeur de pa est %li\n", pa); /* affiche la valeur des variables pointeurs */
    
     pa ++; /* incrementation des pointeurs par pas de 1 */
     printf("la nouvelle valeur de pa est %li\n", pa);
     
     /* afficher la nouvelle valeur des pointeurs */
    
     /* question 3 (fin) : que deduire
     sur l'algebre des pointeurs ? */
    
     /* representation en memoire */
     
     /* question 4 : recommencer l'execution suivante avec d'autres valeurs de
     a : 0,2,4,8,16,32,1024
     -2, -4, -8 */
    
     a=4; /* on initialise la variable a */
     pa = &a; /* on affecte l'adresse de a au pointeur pa :pointeur sur entier */
     p = (char *) pa; /* on transforme pointeur sur entier en pointeur sur caractère */
     for (i=1; i<= (int)sizeof(a); i++)
     /* on lit chaque caractere de l'entier */
     { printf("valeur de l\'octet %i est en hexa %x \n", i,*p);
         p++;<
     };
     /* question 4 (fin):pour les valeurs négatives, vérifier en calculant le complement a 1 */
     return 0;
 }

Exercice 6 (Analyse et programmation)

Utilisation des comparateurs et des opérateurs booléens &&

On donne un caractère : tester si c'est une majuscule, une minuscule ou un chiffre

Exercice 7 (A+P)

Du problème au programme (à faire en TDs )

On donne les trois coefficients d'une équation du second degré. Calculer le discriminant. Tester l'existence de racines

Exercice 8 (A+P)

Opérateurs booléens

On donne deux nombres, détecter s'ils sont de même signe ou pas et afficher un message adéquat dans chaque cas.

Exercice 9 (A+P)

Utilisation de bibliothèque <math.h>

On donne deux nombres a et b, calculer le module et l'argument
Utiliser les fonctions sqrt(variable ou expression), pow(nombre, puissance) et atan(variable)

Exercice 10 (P)

Priorité des opérateurs et précision des calculs

On donne deux nombres réels x et y : afficher le résultat des expressions suivantes
x-1/x*(20+x) ; x+y/2 et (x+y)/2 ; (x/2)+(x*(x-1)) et x/2 + x*(x-1) ; x/x*y et x*y/x

**Les priorités des opérateurs**
	*Classes de priorités :*	*Ordre de l'évaluation :*
Priorité 1 (la plus forte)	()	->
Priorité 2	! ++ --	<-
Priorité 3	* / %	->
Priorité 4	+ -	->
Priorité 5	< <= > >=	->
Priorité 6	== !=	->
Priorité 7	&&	->
Priorité 8	\|\|	->
Priorité 9 (la plus faible)	*= += -= = /= %=**	<-