Exercice Programmation Langage C : LES TABLEAUX ET LES CHAINES DE CARACTERES

1. LES TABLEAUX DE NOMBRES (INT ou FLOAT)

Les tableaux correspondent aux matrices en mathématiques. Un tableau est caractérisé par sa taille et par ses éléments.
Les tableaux à une dimension:
Déclaration:     type nom[dim];                     
Exemples:          int compteur[10];
float nombre[20];
Cette déclaration signifie que le compilateur réserve dim places en mémoire pour ranger les éléments du tableau.
Exemples:
int compteur[10];  le compilateur réserve des places pour 10 entiers, soit 20 octets en TURBOC et 40 octets en C standard.
float nombre[20];   le compilateur réserve des places pour 20 réels, soit 80 octets.
Remarque:  dim est nécessairement une VALEUR NUMERIQUE. Ce ne peut être en aucun cas une combinaison des variables du programme.
Utilisation: Un élément du tableau est repéré par son indice. En langage C les tableaux commencent à l’indice 0. L’indice maximum est donc dim-1.
Appel:                  nom[indice]   
Exemples:         compteur[2] = 5;
                                  nombre[i] = 6.789;
                                  printf(“%d”,compteur[i]);
scanf(“%f”,&nombre[i]);
Tous les éléments d’un tableau (correspondant au dimensionnement maximum) ne sont pas forcément définis.
D’une façon générale, les tableaux consomment beaucoup de place en mémoire. On a donc intérêt à les dimensionner au plus juste.

Exercice 1:

Saisir 10 réels, les ranger dans un tableau. Calculer et afficher la moyenne et l’écart-type.
Les tableaux à plusieurs dimensions:
Tableaux à deux dimensions:
Déclaration:     type nom[dim1][dim2];  
Exemples:         int compteur[4][5];
                                  float nombre[2][10];
Utilisation: Un élément du tableau est repéré par ses indices. En langage C les tableaux commencent aux indices 0. Les indices maximum sont donc dim1-1, dim2-1.
Appel:                nom[indice1][indice2]
Exemples:        compteur[2][4] = 5;  
                             nombre[i][j] = 6.789;
                             printf(“%d”,compteur[i][j]);
                             scanf(“%f”,&nombre[i][j]);
Tous les éléments d’un tableau (correspondant au dimensionnement maximum) ne sont pas forcément définis.

Exercice 2:

Saisir une matrice d’entiers 2×2, calculer et afficher son déterminant.
Tableaux à plus de deux dimensions:
On procède de la même façon en ajoutant les éléments de dimensionnement ou les indices nécessaires.

2. INITIALISATION DES TABLEAUX

On peut initialiser les tableaux au moment de leur déclaration:
Exemples:
int liste[10] = {1,2,4,8,16,32,64,128,256,528};
float nombre[4] = {2.67,5.98,-8,0.09};
int x[2][3] = {{1,5,7},{8,4,3}};  /* 2 lignes et 3 colonnes */

3. TABLEAUX ET POINTEURS

En déclarant un tableau, on définit automatiquement un pointeur (on définit en fait l’adresse du premier élément du tableau).
Les tableaux à une dimension:
Les écritures suivantes sont équivalentes:
int *tableau;                                                   int tableau[10];                      déclaration
tableau = (int*)malloc(sizeof(int)*10);
*tableau                                                          tableau[0]                               le 1er élément
*(tableau+i)                                                    tableau[i]                                un autre élément
tableau                                                            &tableau[0]               adresse du 1er élément
(tableau + i)                                                    &(tableau[i])             adresse d’un autre élément
Il en va de même avec un tableau de réels (float).
Remarque: La déclaration d’un tableau entraine automatiquement la réservation de places en mémoire. Ce n’est pas le cas lorsque l’on déclare un pointeur. Il faut alors utiliser une fonction d’allocation dynamique comme malloc.
Les tableaux à plusieurs dimensions:
Un tableau à plusieurs dimensions est un pointeur de pointeur.
Exemple:
int t[3][4];   t est un pointeur de 3 tableaux de 4 éléments ou bien de 3 lignes à 4 éléments.
Les écritures suivantes sont équivalentes:
t[0]                  &t[0][0]                       t           adresse du 1er élément
t[1]                  &t[1][0]                                   adresse du 1er élément de la 2e ligne
t[i]                   &t[i][0]                                   adresse du 1er élément de la ième ligne 
t[i]+1               &(t[i][0])+1                             adresse du 1er élément de la ième +1 ligne   

repartition des elements en memoire

Exercice 3:

Un programme contient la déclaration suivante:
int tab[10] = {4,12,53,19,11,60,24,12,89,19};
Compléter ce programme de sorte d’afficher les adresses des éléments du tableau.

Exercice 4:

Un programme contient la déclaration suivante:
int tab[20] = {4,-2,-23,4,34,-67,8,9,-10,11, 4,12,-53,19,11,-60,24,12,89,19};
Compléter ce programme de sorte d’afficher les  éléments du tableau avec la présentation suivante:
4          -2         -23       4          34
-67       8          9          -10       11
4          12        -53       19        11
-60       24        12        89        19

4. LES CHAINES DE CARACTERES 

En langage C, les chaînes de caractères sont des tableaux de caractères. Leur manipulation est donc analogue à celle d’un tableau à une dimension:

Déclaration:   char nom[dim]; ou bien                      char *nom;
                                                                                                           nom = (char*)malloc(dim);
Exemple:         char texte[dim]; ou bien                    char *texte;
                                                                                                            texte = (char*)malloc(10);
Le compilateur réserve (dim-1) places en mémoire pour la chaîne de caractères: En effet, il ajoute toujours le caractère NUL (‘\0′) à la fin de la chaîne en mémoire.
Affichage à l’écran:
On peut utiliser la fonction printf et le format %s:
char texte[10] = « BONJOUR »;
printf(“VOICI LE TEXTE: %s\n”,texte);           
On utilisera si possible la fonction puts non formatée:
puts(texte);                 est équivalent à           printf(“%s\n”,texte);
Saisie:  On peut utiliser la fonction scanf et le format %s. Une chaîne étant un pointeur, on n’écrit pas le symbole &. On utilisera de préférence la fonction gets non formatée.
char texte[10];
printf(“ENTRER UN TEXTE: “);
scanf(“%s”,texte);    est équivalent à           gets(texte);
Remarque: scanf ne permet pas la saisie d’une chaîne comportant des espaces: les caractères saisis à partir de l’espace ne sont pas pris en compte (l’espace est un délimiteur au même titre que LF) mais rangés dans le tampon d’entrée. Pour saisir une chaîne de type “il fait beau”, il faut utiliser gets.
A l’issue de la saisie d’une chaîne de caractères, le compilateur ajoute ‘\0′ en mémoire après le dernier caractère.
Comme expliqué au chapitre 2, gets et scanf utilisent le flux d’entrée.

Exercice 5:

Saisir une chaîne de caractères, afficher les éléments de la chaîne et leur adresse (y compris le dernier caractère ‘\0′).

Exercice 6:

Saisir une chaîne de caractères. Afficher le nombre de e et d’espaces de cette chaîne.
Fonctions permettant la manipulation des chaînes:
Les bibliothèques fournies avec les compilateurs contiennent de nombreuses fonctions de traitement des chaînes de caractères. En BORLAND C++,  elles appartiennent aux bibliothèques string.h ou stdlib.h.  En voici quelques exemples:
Générales (string.h):
void *strcat(char *chaine1,char *chaine2)      concatène les 2 chaînes, résultat dans chaine1,
renvoie l’adresse de chaine1.
int strlen(char  *chaine)                       renvoie la longueur de la chaine (‘\0′ non comptabilisé).
void *strrev(char *chaine)                  inverse la chaîne et, renvoie l’adresse de la chaine inversée.
Comparaison (string.h):
int strcmp(char *chaine1,char *chaine2)         renvoie un nombre:
– positif si la chaîne1 est supérieure à la chaine2 (au sens de l’ordre alphabétique)
– négatif si la chaîne1 est inférieure à la chaîne2
– nul si les chaînes sont identiques.
Copie (string.h):
void *strcpy(char *chaine1,char *chaine2)
recopie chaine2 dans chaine1 et renvoie l’adresse de chaîne1.
Recopie (string.h):
Ces fonctions renvoient l’adresse de l’information recherchée en cas de succès, sinon le pointeur NULL (c’est à dire le pointeur de valeur 0 ou encore le pointeur faux).
void *strchr(chaine,caractère)             recherche le caractère dans la chaîne.
void *strrchr(chaine,caractère)            idem en commençant par la fin.
void *strstr(chaîne,sous-chaîne)          recherche la sous-chaine dans la chaîne.
Conversions (stdlib.h):
int atoi(char *chaîne)              convertit la chaîne en entier
float atof(char *chaine)           convertit la chaîne en réel
exemple:          printf(“ENTRER UN TEXTE: “);
gets(texte);
n = atoi(texte) ;
printf(“%d”,n);            /* affiche 123 si texte vaut “123” */
/* affiche 0 si texte vaut “bonjour” */
void *itoa(int n,char *chaîne,int base)            convertit un entier en chaîne:
base: base dans laquelle est exprimé le nombre,
cette fonction renvoie l’adresse de la chaîne.
exemple: itoa(12,texte,10);     texte vaut “12”
Pour tous ces exemples, la notation void* signifie que la fonction renvoie un pointeur (l’adresse de l’information recherchée), mais que ce pointeur n’est pas typé. On peut ensuite le typer à l’aide de l’opérateur cast .
Exemple:         int *adr;
char texte[10] = “BONJOUR”;
adr = (int*)strchr(texte,’O’);

Exercice 7:

L’utilisateur saisit le nom d’un fichier. Le programme vérifie que celui-ci possède l’extension .PAS

Exercice 8:

Un oscilloscope à mémoire programmable connecté à un PC renvoie l’information suivante sous forme d’une  chaîne de caractères terminée par ‘\0’au PC:
“CHANNELA 0 10 20 30 40 30 20 10 0 -10 -20 -30 -40 -30 -20 -10 -0″
Afficher sur l’écran la valeur des points vus comme des entiers. On simulera la présence de l’oscilloscope en initialisant une chaîne de caractères char mesures[100].

5. CORRIGE DES EXERCICES

Exercice 1:

#include <stdio.h>#include <math.h>
#include <conio.h>
void main()
{
float nombre[10],moyenne = 0,ecart_type = 0;
int i;
 
/* saisie des nombres */
printf(“SAISIR 10 NOMBRES SEPARES PAR RETURN: \n”);
for(i=0;i<10;i++)
            {
            printf(“nombre[%1d] = “,i);
            scanf(“%f”,&nombre[i]);
            }
/* calculs */
for(i=0;i<10;i++)
            {
            moyenne = moyenne + nombre[i];
            ecart_type = ecart_type + nombre[i]*nombre[i];
            }
moyenne = moyenne/10;
ecart_type = ecart_type/10;
ecart_type = ecart_type – moyenne*moyenne;
ecart_type = sqrt(ecart_type);          /* racine */
printf(“MOYENNE = %f  ECART_TYPE = %f\n”,moyenne,ecart_type);
printf(“POUR CONTINUER FRAPPER UNE TOUCHE: “);
getch();
}
 

Exercice 2:

#include <stdio.h>#include <conio.h>
void main()
{
int mat[2][2],det;
/* saisie */
printf(“ENTRER SUCCESSIVEMENT LES VALEURS DEMANDEES: \n”);
printf(“mat[0][0] = “);
scanf(“%d”,&mat[0][0]);
printf(“mat[1][0] = “);
scanf(“%d”,&mat[1][0]);
printf(“mat[0][1] = “);
scanf(“%d”,&mat[0][1]);
printf(“mat[1][1] = “);
scanf(“%d”,&mat[1][1]);
 
/* calcul */
det = mat[0][0]*mat[1][1]-mat[1][0]*mat[0][1];
 
/* affichage */
printf(“DETERMINANT = %d\n”,det);
printf(“POUR CONTINUER FRAPPER  UNE TOUCHE: “);
getch();
}

Exercice 3:

#include <stdio.h>#include <conio.h>
void main()
{
int i,tab[10]={4,12,53,19,11,60,24,12,89,19};
printf(“VOICI LES ELEMENTS DU TABLEAU ET LEURS ADRESSES:\n”);
for(i=0;i<10;i++)
printf(“ELEMENT N¯%1d: %2d    ADRESSE: %p\n”,i,tab[i],tab+i);
printf(“POUR SORTIR FRAPPER UNE TOUCHE: “);
getch();
}
 

Exercice 4:

#include <stdio.h>#include <conio.h>
void main()
{
int i,tab[20] = {4,-2,-23,4,34,-67,8,9,-10,11, 4,12,-53,19,11,-60,24,12,89,19};
printf(“VOICI LE TABLEAU:\n\n”);
for(i=0;i<20;i++)
            if (((i+1)%5)==0) printf(“\t%d \n”,tab[i]);
            else printf(“\t%d “,tab[i]);
printf(“\nPOUR SORTIR FRAPPER UNE TOUCHE: “);
getch();
}
 

Exercice 5:

#include <stdio.h>#include <conio.h>
#include <alloc.h>
void main()
{
char i=0,*phrase;
phrase = (char*)malloc(20); /* reserve 20 places */
 
printf(“ENTRER UNE PHRASE: “);
gets(phrase);  /* saisie */
 
printf(“VOICI LES ELEMENTS DE LA CHAINE ET LEUR ADRESSE\n”);
do
            {
printf(“LETTRE: %c CODE ASCII: %x ADRESSE: %p\n”,phrase[i],phrase[i],phrase+i);
            i++;
            }
while(phrase[i-1]!=’\0′);
free(phrase);
printf(“\nPOUR CONTINUER FRAPPER UNE TOUCHE: “);
getch();
}
 

Exercice 6:

#include <stdio.h>#include <conio.h>
#include <alloc.h>
void main()
{
char *phrase,compt_espace = 0,compt_e = 0,i;
phrase=(char*)malloc(20);   /* reserve 20 places */
printf(“ENTRER UNE PHRASE:”);
gets(phrase);  /* saisie */
 
for(i=0;phrase[i]!=’\0′;i++)
            {
            if(phrase[i]==’e’)compt_e++;
            if(phrase[i]==’ ‘)compt_espace++;
            }
printf(“NOMBRE DE e: %d\n”,compt_e);
printf(“NOMBRE D’ESPACES : %d\n”,compt_espace);
free(phrase);
printf(“POUR SORTIR FRAPPER UNE TOUCHE “);
getch();
}
 

Exercice 7:

#include <conio.h>#include <alloc.h>
#include <string.h>
void main()
{
char *nom,*copie;
int n;
nom = (char*)malloc(30);
copie = (char*)malloc(30);
printf(“\nNOM DU FICHIER (.PAS):”);
gets(nom);
strcpy(copie,nom);
strrev(copie);  /* chaine inversee */
n = strnicmp(“SAP.”,copie,4);         /* n vaut 0 si ‚galite */
if(n!=0)printf(“\nLE FICHIER N’EST PAS DE TYPE .PAS\n”);
else printf(“\nBRAVO CA MARCHE\n”);
free(nom);
free(copie);
printf(“\nPOUR CONTINUER FRAPPER UNE TOUCHE “);
getch();
}
 

Exercice 8:

#include <stdio.h>#include <conio.h>
#include <stdlib.h>
void main()
{
char mesures[100] =
“CHANNELA 0 10 20 30 40 30 20 10 0 -10 -20 -30 -40 -30 -20 -10 0″;
int i,j,val[20],nombre_val=0;
char temp[4];   /* chaine temporaire */
 
/* recherche des nombres */
for(i=9;mesures[i]!=’\0′;i++)
            {
            for(j=0;(mesures[i]!=’ ‘)&&(mesures[i]!=’\0′);j++)
                        {
                        temp[j]=mesures[i];
                        i++;
                        }
            temp[j] = ‘\0′;     /* On borne la chaine */
            val[nombre_val] = atoi(temp); /* Conversion de la chaine temporaire en nombre */
            nombre_val++;
            }
 
/* Affichage du resultat */
clrscr();
for(i=0;i<nombre_val;i++)printf(“val[%d] = %d\n”,i,val[i]);
printf(“POUR SORTIR FRAPPER UNE TOUCHE:”);
getch();
}

Leave a Reply

Your email address will not be published. Required fields are marked *


*