| N.F.I. 2 ième année |
Langage C
|
octobre 1999 |
Corrigé d'octobre 1999
Dans la programmation qui suit, les saisies sont supposées faites sans
erreur.
Question 1
Question 1.a
/* prog1_a.C :initialisation à la déclaration (donc les carOctets ne
sont pas lus), puis calcul et affichage du résultat de la disjonction.
*/
#include <stdio.h>
const int TAILLE=8 ;
void main() {
char u[TAILLE] = {'0','1' ,'0' ,'1' ,'0' ,'1' ,'0' ,'1'},
v[TAILLE] = {'1','1' ,'1' ,'1' ,'0' ,'0' ,'0' ,'0'},
uouv[TAILLE];
int i ;
/* Calcul de la disjonction (en utilisant l'opérateur ternaire ? :) */
for( i=0 ; i<TAILLE ; i++) {
uouv[i] = (u[i]=='1') ? '1':v[i] ;
}
/* Affichage de trois lignes */
printf(" u = ");
for( i=0 ; i<TAILLE ; i++) printf("%c",u[i]);
printf("\n v = ");
for( i=0 ; i<TAILLE ; i++) printf("%c",v[i]);
printf("\nu ou v = ");
for( i=0 ; i<TAILLE ; i++) printf("%c", uouv[i]);
printf("\n");
}
Question 1.b
/* prog1_b.c : représentation des carOctets sous forme chaîne de
caractères: la taille du tableau à réserver est donc de un 'char' de
plus, puisqu'il faut penser à la marque de fin de chaîne ('\0').
Les instructions répétitives d'affichage des tableaux de caractères
disparaissent, car on utilise le format %s pour afficher un tableau
de caractères, interprétés comme une chaîne.
*/
#include <stdio.h>
const int TAILLE=8 ;
void main() {
char u[] = "01010101", v[] = "11110000", uouv[TAILLE+1];
int i ;
/* Calcul de la disjonction */
for( i=0 ; i<TAILLE ; i++) uouv[i] = (u[i]=='1') ? '1':v[i] ;
uouv[i] = '\0'; /* pour interpréter en chaîne */
/* Affichage des résultats */
printf(" u = %s\n", u);
printf(" v = %s\n", v);
printf("u ou v = %s\n", uouv);
}
Question 2
/* prog2.c : conversion entier à carOctet
On obtient les chiffres en numération binaire à partir de chaque reste
dans une suite de divisions par 2; ce reste, étant numérique, doit
être converti en caractère pour obtenir un carOctet.
Ce programme devra être testé avec les essais:
138 donne "10001010" 0 donne "00000000"
127 donne "01111111" 1 donne "00000001"
128 donne "10000000" 255 donne "11111111"
Dans la version ci-dessous, plusieurs nombres sont saisis; chacun
d'eux est converti en un carOctet qui est affiché; l'exécution prend
fin à la lecture d'un nombre négatif.
Il n'est pas vérifié que les nombres lus sont dans l'intervalle
[0, 255].
*/
#include <stdio.h>
const int BASE=2 ;
const int TAILLE=8 ;
void main() {
char u[TAILLE+1];
int i , m, reste;
printf("Un entier (arrêt sur -1): "); scanf("%d", &m);
while( m != -1 ) {
/* Conversion et affichage du résultat */
for( i=TAILLE-1; i>=0; i--) {
reste = m % BASE; /* récupérer le reste */
u[i] = '0' + reste; /* convertir en caractère '0' ou '1' */
m = m/BASE;
}
u[TAILLE]='\0'; /* pour interpréter en chaîne */
printf( "carOctet = \"%s\"\n", u);
/* Autre lecture */
printf("Un entier (arrêt sur -1): "); scanf("%d", &m);
}
}
Question 3
/* prog3.c */
#include <stdio.h>
#include <stdlib.h> /* utilisation de malloc() */
#include <string.h>
typedef char * CarOctet;
int plusPetitInt ( int n, CarOctet tc[]);
int plusGrandInt ( int n, CarOctet tc[]);
Question 3.a
/* question 3.a
Deux paramètres sont prévus respectivement pour l'indice du plus petit
carOctet, et du plus grand carOctet.
L'information à fournir étant du type int, ces paramètres, appelés
p_pp et p_pg, sont de type int *.
*/
void minMaxInt( int n, CarOctet tc[], int * p_pp, int * p_pg){
*p_pp = plusPetitInt ( n, tc);
*p_pg = plusGrandInt ( n, tc);
}
Question 3.b
/* question 3.b
D'après l'exemple, les troisième et quatrième arguments sont de type
CarOctet *.
*/
void minMaxCO(int n,CarOctet tc[],CarOctet* p_pp,CarOctet* p_pg){
*p_pp = tc[plusPetitInt( n, tc)];
*p_pg = tc[plusGrandInt( n, tc)];
}
Question 3.c
const int BASE=2 ;
const int TAILLE=8 ;
void main() {
/* Partie test des questions 3.a et 3.b
CarOctet tt[] = { "01010101", "00000000", "101010101" , "11111111"},
ppCOtt, pgCOtt;
int ntt=sizeof(tt)/sizeof(tt[0]), ipptt, ipgtt;
minMaxInt( ntt, tt, &ipptt, &ipgtt);
printf("n=%d, ipp=%d, ipg=%d\n", ntt, ipptt, ipgtt);
minMaxCO( ntt, tt, &ppCOtt, &pgCOtt);
printf("ppCO=%s, pgCO=%s\n", ppCOtt, pgCOtt);
*/
/* Partie liée à la question 3.c) */
CarOctet *tc, ppCO, pgCO;
int n, i;
printf("Nombre de carOctets: "); scanf("%d",&n);
/* Allocation de n adresses */
tc = (CarOctet *) malloc( n*(sizeof(CarOctet)) );
if( tc == NULL ) { printf("Pas assez de mémoire !!!"); exit(1);}
/* Allocation de chacun des carOctets */
for(i=0; i<n; i++) tc[i] = (CarOctet) malloc( TAILLE+1 );
if( tc[n-1] == NULL ) {printf("Pas assez de mémoire !!!");exit(2);}
/* Saisie de chacun des carOctets
Il n'est pas vérifié que chaque chaîne est de longeur 8, et que les
seuls caractères saisis sont '0' ou '1'.
*/
for(i=0; <n; i++){printf("carOctet %d: ",i+1);scanf( "%s",tc[i]);}
/* Exemple d'utilisation */
minMaxCO( n, tc, &ppCO, &pgCO);
printf( "ppCO=%s, pgCO=%s\n", ppCO, pgCO);
/* Libérations non demandées par l'énoncé */
for( i = n-1; i >= 0 ; i--) free( tc[i] ) ;
free(tc);
}
/* pour tester */
int plusPetitInt ( int n, CarOctet tc[]) { return 1;}
int plusGrandInt ( int n, CarOctet tc[]) { return n-1;}