Cours-Langage C

Langage de Programmation
Structuré
- Le Langage C -
M.MOUSTAID
- Le Langage C - M.MOUSTAID
Sommaire
1. Introduction au langage
2. Éléments de base (règles d’écriture, types…)
3. Les variables
4. Opérateurs et expressions
5. Les entrées-Sorties (printf, scanf)
6. Les structures de contrôle
Sommaire
7. Classification des variables
8. Les objets structurés (tableaux, structures)
9. Les Fonctions
10. Les pointeurs
11. Les fichiers
12. Le préprocesseur (#include, #define…)
Introduction
L’ordinateur est une machine non intelligente, qui sait exécuter
des opérations très simples :
• Opérations arithmétiques : addition, soustraction,

multiplication…
• Opérations de comparaisons.
• Lecture de valeurs et affichage de résultats.
Introduction
Crée par KERNIGHAM et RITCHIE pour développer le système
d’exploitation UNIX , C est un langage compilé, c'est à dire qu'il
faut:
* Entrer le programme ou le code source dans l'ordinateur (à
l'aide d'un EDITEUR),
* le traduire en langage machine (Codes binaires
compréhensibles par l'ordinateur): c'est la compilation.
* l'exécuter et visualiser le résultat
Premier Programme en C
Exemple:
# include <stdio.h>
main()
{
printf(’’Bonjour!’’);
}
La directive #include inclu le fichier stdio.h au programme avant

la compilation (pour pouvoir utiliser la fonction prédéfinie
printf).
Définition d'une variable
– nom:
• Unique pour chaque variable
• Commence toujours par une lettre
• Différenciation minuscule-majuscule
– type:
• Conditionne le format de la variable en mémoire
• Peut être soit un type standard ou un type utilisateur
– valeur:
• Peut évoluer pendant l'exécution
• initialisation grâce à l'opérateur d'affectation
Types de variables
– charcaractère
– int entier
– short entier court
– long entier long
– float nombre décimal (réel)
– double nombre décimal de précision supérieure
– long double nombre décimal encore plus précis
– unsigned int entier non signé
Déclaration
• Déclaration d'une variable
Type nom_de_la_variable [= valeur]
• Exemple:
int nb;
float pi = 3.14;
char c = 'a';
long i,j,k;
double r = 6.28765;
LA FONCTION PRINTF
La fonction printf permet d’afficher à l’ecran

Syntaxe:
printf("%format",nom_de_variable);
• formats:
–%c caractère
–%s chaîne de caractères
–%dentier
–%fréel
–%lf double
–%e réel en notation scientifique
Instructions de base
– opérateurs de base
• +,-,*, / opérateurs arithmétique de base
• % reste d'une division entière
• == test d'égalité
• != test de différence
• <, >, <=, >= test de comparaison
• ! négation
• || ou logique pour évaluer une expression
• && et logique pour évaluer une expression
• Exercice d’application
– opérateurs de base
• a = 2+3
• a = 3%2
• a = (3==3)
• a = (6==5)
• a = (2!=3)
• a = (6<=3)
• a = !1
• a =((3==3) || (6<=3))
• a =((3==3) && (6<=3))
Éléments de base
NOTATION RESULTAT
\a cloche ou bip (alert ou audible bell)
\b Retour arrière (Backspace)
\f Saut de page (Form Feed)
\n Saut de Ligne (Line Feed)
\r Retour chariot (Carriage Return)
\t Tabulation horizontaLe (HorizontaL Tab)
\v Tabutation verticale (VerticaL Tab)
\\ \
\' ‘
\ '' ‘’
\? ?
Exercice
• a et b sont des entiers, a = -21430 b = 4782, calculer et
afficher a+b, a-b, a*b, a/b, a%b en format décimal, et en
soignant l’interface homme/machine.
• a/b donne le quotient de la division, a%b donne le reste de la
division.
Exemple
#include <stdio.h>
#include <conio.h>
void main()
{
char c;
c =‘A’; /* c est le caractere alphanumerique A */
printf("%d\n",c); /* affichage du code ASCII en decimal */
/* et retour … à la ligne */
printf("%o\n",c); /* affichage du code ASCII en base huit
printf("%x\n",c); /* affichage du code ASCII en hexadecimal
printf("%c\n",c); /* affichage du caractère */
/* et retour à la ligne */
puts("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}
Correction
#include <stdio.h>
#include <conio.h>
void main()
{
int a,b;
a= -21430;
b= 4782;
printf("A + B = %d\n",a+b);
printf("A - B = %d\n",a-b);
printf("A x B = %d\n",a*b);
printf("A sur B = %d\n",a/b);
printf("A mod B = %d\n",a%b);
puts("Pour continuer frapper une touche...");
getch(); /* Attente d'une saisie clavier */
}
LA FONCTION SCANF
• La fonction scanf permet la saisie clavier de n'importe
quel type de variable.
• Les variables à saisir sont formatées, le nom de la variable
est précédé du symbole & désignant l'adresse de la
variable .
• Tous les éléments saisis après un caractère d'espacement
(espace, tabulation) sont ignorés.
• Syntaxe :
Scanf("format",&variable)
LA FONCTION SCANF
• Exemples: char alpha;

int i;
float r;
scanf("%c",&alpha);/* saisie d'un caractère */
scanf("%d",&i); /* saisie d'un nombre entier en décimal */
scanf("%x",&i); /* saisie d'un nombre entier en hexadécimal*/
scanf("%f",&r); /* saisie d'un nombre réel */
Instruction de test simple
• Instructions de base
– instruction conditionnelle simple si alors
if (expression)
{
instructions;
}
expression est évaluée. Si le résultat est vrai alors les
instructions sont exécutées.
– exemple
int x;
printf(« Entrer x: »);
scanf(« %d »,&x);
if (x%2==0)
{
printf(« %d est paire »,x);
}
Instruction de test simple
– Instruction conditionnelle simple si alors sinon
if (expression)
{
instructions1;
}
else
{
instrutions2;
}
Si le résultat de expression est vrai alors les instructions1 sont
exécutées sinon on exécute l'ensemble instructions2
– exemple
int x;
printf(« Entrer x: »);
scanf(« %d »,&x);
if (x%2==0)
{ printf(« %d est paire »,x); }
else
{ printf(« %d est impaire »,x); }
instruction conditionnelle multiple
• Instructions de base
– instruction conditionnelle multiple
switch(expression)
{
case valeur1:
instructions1;break;
case valeur2:
instructions2;break;
..
.
case valeur3:
instruction3;break;
default:
instruction4;break;
}
expression est évaluée. Si le résultat vaut valeur1, alors
instruction1 est exécutée et on quitte le switch, sinon si
expression vaut valeur2, ……, sinon on va dans default pour
exécuter instruction4.
– Permet de faire une sélection parmi plusieurs choix.
Exemple:
char c;
printf('' entrer votre choix '');
Scanf('' %c'‘,&c);
switch (c)
{
case 'a':
printf(" 0");
break;
case 'b':
printf("1");
break;
case 'q':
printf(" 2");
break;
default:
printf("3");
}
Algorithme : Déclaration Entier : j, M, A chaîne : Mois

Algorithme : Déclaration Entier : j Chaîne :jours
Début
Début
Ecrire « donner un chiffre » Ecrire « donner l’année »
Lire J
Cas parmi J Lire A
Cas 1 : jour « lundi »
Ecrire « donner le jour »
Cas 2 : jour « Mardi »
Cas 3 : jour « Mercredi » Lire J
Cas 4 : jour « Jeudi »
Cas 5 : jour « Vendredi » Ecrire « donner le mois »
Cas 6 : jour « Samedi »
Cas 7 : jour « Dimanche » Lire M
Sinon Ecrire « erreur »
Cas parmi M
Fin Cas
Cas 1 : Mois « Janvier »
Fin
Cas 2 : Mois « Février »
……
Cas 12 : Mois « Décembre »
Sinon
Ecrire « erreur »
Fin Cas
Ecrire « la date est : »,J, Mois, A
Fin
• Exercice 1 :
Ecrire un programme qui à partir d’un
nombre compris entre 1 et 7 affiche le jour
correspondant.
• Exercice 2 :
Ecrire un programme qui permet d’entrer une date sous
forme 15 10 2002 et d’afficher la date sous forme 15 octobre
2002.
Instruction de répétition
– boucle pour:
for(expr1;expr2;expr3)
{
instructions
}
expr1: évaluée 1 seule fois en début de
boucle
expr2: évaluée avant chaque itération.
Si vrai alors les instructions de la boucle
sont exécutées sinon la boucle est
terminée
expr3: évaluée à la fin de chaque itération
• Exemple:
// somme des 100 premiers entiers
int i,s;
s= 0;
for(i=0;i<=100;i = i+1)
{
s = s+i; / / ou s+=i;
}
printf(" la somme vaut: %d \n",s);
– boucle tant que
while (expression)
{
instructions;
}
expression est évaluée avant chaque itération.
Si le résultat est vrai alors les instructions sont
exécutées sinon on sort de la boucle
– Exemple : // somme des 100 premiers entiers
int i=0,s=0;
while(i<=100)
{
s = s+i;
i = i+1;
}
printf(" la somme vaut: %d \n", s);
– boucle répéter
do
{
instructions;
} while (expression);
expression est évaluée après chaque itération.
Si le résultat est vrai alors les instructions sont
exécutées sinon on sort de la boucle
– exemple
int n;
do
{
printf(‘’entrer un nombre positif ’’);
scanf(‘’%d ’’,&n)
} while(n<0);
Les tableaux
Les tableaux à une seule dimension
–définition
• Ensemble de variables de même type, de
même nom caractérisées par un index.
–déclaration
• type nom_tableau[dimension]
–exemples:
• char NOM[20];
• int T[10];
Les tableaux à une seule dimension
–accès aux éléments du tableau

• Nom_tableau[indice]
–exemples:
• NOM[5] = 'c';
• T[6] = 10;
 le premier élément commence à l'indice 0 !!
 Les valeurs ne sont pas initialisées !!
Les tableaux à deux dimensions
– Définition:
• Il s'agit d'un tableau de tableaux
– Déclaration:
• type nom_tableau[dim1][dim2]…[dimn]
– Exemples:
• char listeNoms[20][80];
• int mat[6][10];
- Le Langage C - MOUSTAID
Les tableaux à deux dimensions
• Les tableaux statiques à 2 dimensions et plus
– accès aux éléments
• nom_tableau[ind1][ind2]…[indn]
– exemples:
• livre[30][15] = 'c';
• mat[5][6] =13;
Les colonnes
j=0 j=1 j=2 j=3 j=4

i=0 2 3 5 7 3
Les lignes T[1][4]
i=1 22 3 9 5 6
i=2 11 4 77 7 3
T[3][2]
- Le Langage C - M.MOUSTAID T[2][3]
Les tris
Les fonctions et les procédures
Les fonctions
– Définition:
Ensemble d'instructions pouvant être appelés de manière
répétitive par un nom
– Déclaration:
Type nom_f( type arg1,type arg2, …type argn)
{
ensemble instructions
return var;
}
- Type Le type de la variable renvoyé par la fonction
(instruction return)
- nom_f est le nom de la fonction
- arg1 …argn sont les arguments envoyés à la fonction
- Le Langage C -
Les fonctions
– règles d'utilisation
• L'ordre, le type et le nombre des arguments doivent être respectés lors de
l'appel de la fonction
• L'appel d'une fonction doit être située après sa déclaration ou celle de son
prototype
(voir exemple transp suivant)
- Le Langage C -
Les fonctions
Les fonctions
– exemple:
#include<stdio.h>
#include<conio.h>
int min(int a, int b)
{
if (a <b) return a;
else return b;
}
Main()
{int i,j;
Printf(« entrer deux valeurs »);
Scanf‘(« %d%d »,&i,&j);
Printf(« le min est %d »,min(i,j));
Getch();}
Les fonctions
/* Calcul du maximum */
int imax(int n, int m)
{
Déclaration de la fonction
int max;
if (n>m)
max = n; Variable locale
else
max = m;
return max;
}
Valeur retournée par la fonction
Les fonctions
• Les fonctions
– Les paramètres se passent par valeur
• Recopie en mémoire des paramètres dans des paramètres
temporaires.
– Toute modification des paramètres dans la fonction est sans effet sur les
paramètres originelles
– Quand on quitte la fonction, les paramètres temporaires sont effacés de
la mémoire
– Recopie dans le sous programme appelant de la valeur du paramètre
retourné par la fonction return.
Les fonctions
• Les fonctions
– Passage d'arguments par adresse
• On passe non pas la valeur de la variable mais son adresse
• Il est donc possible par les pointeurs de modifier le contenu de
l'adresse, donc la variable originelle
• Permet de modifier plusieurs arguments à la fois dans une fonction
• Permet de passer des tableaux en argument
Les fonctions
• En langage C les sous-programmes s'appellent des fonctions.
• Une fonction possède un et un seul point d'entrée, mais
éventuellement plusieurs points de sortie (à l'aide du mot
return).
• Une variable connue uniquement d'une fonction ou de
main() est une variable locale.
• Une variable connue de tout le programme est une variable
globale.
FONCTIONS SANS PASSAGE
D'ARGUMENTS ET NE
RENVOYANT RIEN AU
PROGRAMME.
• Une fonction ne renvoyant rien au programme est une fonction
de type void.
Exemple 1
#include <stdio.h>
#include <conio.h>
void bonjour() /* declaration de la fonction */

{
printf("bonjour\n");
}
void main() /* programme principal */

{
bonjour(); /* appel de la fonction */
printf("POUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
Exemple 2
#include <stdio.h>
#include <conio.h>
void bonjour() /* declaration de la fonction */

{
printf("bonjour\n");
}
void test() /* declaration de la fonction */

{
bonjour();/* appel d'une fonction dans une fonction */
printf("test\n");
}

{
test(); /* appel de la fonction */
getch();
}
Exemple 3
#include <stdio.h>
#include <conio.h>
void carre() /* declaration de la fonction */

{
int n,n2; /* variables locales à carre */
printf("ENTRER UN NOMBRE: ");
scanf("%d",&n);
n2 = n*n ;
printf("VOICI SON CARRE: %d\n",n2);
}
{
carre(); /* appel de la fonction */
getch();
}
#include <stdio.h>
#include <conio.h>

{
int n, n2; /* variables locales a carre */
scanf("%d",&n);
n2 = n*n;
}
void cube() /* declaration de la fonction */

{
int n, n3; /* variables locales a cube */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}
{
char choix; /* variable locale a main() */
printf("CALCUL DU CARRE TAPER 2\n");
printf("CALCUL DU CUBE TAPER 3\n");
printf("\nVOTRE CHOIX: ");
scanf("%c",&choix);
switch(choix)
{
case '2':carre();break;
case '3':cube();break;
}
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
• Les 2 variables locales n sont indépendantes l'une de l'autre.
• La variable locale choix n'est connue que de main().
#include <stdio.h>
#include <conio.h>
int n; /* variable globale, connue de tout le programme */

{
int n2; /* variable locale */
scanf("%d",&n);
n2 = n*n;
}
void cube() /* declaration de la fonction */

{
int n3; /* variable locale */
scanf("%d",&n);
n3 = n*n*n;
printf("VOICI SON CUBE: %d\n",n3);
}
{
char choix; /* variable locale a main() */
printf("CALCUL DU CARRE TAPER 2\n");
printf("CALCUL DU CUBE TAPER 3\n");
printf("\nVOTRE CHOIX: ");
scanf("%c",&choix);
switch(choix)
{
case '2':carre();break;
case '3':cube();break;
}
printf("\nPOUR CONTINUER FRAPPER UNE TOUCHE: ");
getch();
}
•
Résumé
• La variable globale n est connue de tout le programme
(fonctions et main()).
• La variable locale choix n'est connue que de main().
• Le fichier d’en-tête n’a pas changé.
• Un programme bien construit possède peu de variables
globales.
Exercice
• Un programme contient la déclaration suivante:
• int tab[10] = {1,2,4,8,16,32,64,128,256,512}; /* variable
globale */
• Ecrire une fonction de prototype void affiche() qui affiche les
éléments du tableau; la mettre en œuvre dans main().
FONCTION RENVOYANT UNE
VALEUR AU PROGRAMME
ET SANS PASSAGE D'ARGUMENTS
• Dans ce cas, la fonction, après exécution, renvoie une valeur.
Le type de cette valeur est déclaré avec la fonction. La valeur
retournée est spécifiée à l'aide du mot réservé return.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <time.h>
int lance_de() /* declaration de la fonction */

{
int test; /* variable locale */
test = random(6) + 1;
return(test);
}
void main()
{
int resultat;
randomize();
resultat = lance_de();
/* resultat prend la valeur retournee par le sous-programme */
printf("Vous avez obtenu le nombre: %d\n",resultat);
printf("POUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}
Exercice
• Un programme contient la déclaration suivante:
• float liste[8] = {1.6,-6,9.67,5.90,345,-23.6,78,34.6}; /*
variable globale */
• Ecrire une fonction de prototype float min() qui renvoie le
minimum de la liste.
• Ecrire une fonction de prototype float max() qui renvoie le
maximum de la liste.
• Les mettre en œuvre dans main().
FONCTIONS AVEC PASSAGE
D'ARGUMENTS
• Ces fonctions utilisent les valeurs de certaines variables du
programme les ayant appelé: on passe ces valeurs au moyen
d'arguments déclarés avec la fonction.
#include <stdio.h>
#include <conio.h>
int carre(int x) /* declaration de la fonction */

{ /* x est un parametre*/
int x2; /* variable locale */
x2 = x*x;
return(x2);
}
void main()
{
int n1, n2, res1, res2; /* variables locales */
scanf("%d",&n1);
res1 = carre(n1);
printf("ENTRER UN AUTRE NOMBRE: ");
scanf("%d",&n2);
res2 = carre(n2);
printf("VOICI LEURS CARRES: %d %d\n\n",res1, res2);
printf("POUR SORTIR FRAPPER UNE TOUCHE: ");
getch();
}
Exercice
• Ecrire une fonction de prototype int puissance(int a, int b)
qui calcule ab, a et b sont des entiers. La mettre en œuvre dans
main().
• Une variable globale est déclarée au début du programme et
qu'elle est connue de tout le programme. Les variables
globales sont initialisées à 0 au début de l'exécution du
programme, sauf si on les initialise à une autre valeur.
• Une variable locale (déclarée au début d'une fonction ou de
main()) n'est connue que de cette fonction ou de main(). Une
variable locale est encore appelée automatique.
• On peut allonger la durée de vie d'une variable locale en la
déclarant static. Lors d'un nouvel appel à la fonction, la
variable garde la valeur obtenue à la fin de l'exécution
précédente. Une variable static est initialisée à 0 lors du
premier appel à la fonction.
• Exemple: int i; devient static int i;
Quelle sera la valeur finale de n si i est déclarée comme variable static, puis comme variable
automatique ?
#include <stdio.h>
#include <conio.h>
int n; /* initialisee … 0 */
void calcul()
{
static int i; /* initialisee … 0 */
i++;
printf("i=%d\n",i);
n = n+i;
}
void main()
{
calcul();
printf("n= %d\n",n);
calcul();
printf("n= %d\n",n);
printf("\nPOUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}
Solution puissance(int x,int y)
#include <stdio.h>
#include <conio.h>
#include "c:\bc5\courc_C\teach_c\chap7\chap7.h" /* fichier d'en-tete */
int puissance(int x,int y)

{
int i,p=1;
for(i=1;i<=y;i++) p=x*p;
return(p);
}
void main()
{
int a,b,res;
printf("\nENTRER A: ");scanf("%d",&a);
printf("\nENTRER B: ");scanf("%d",&b);
res = puissance(a,b);
printf("\A PUISS B = %d\n",res);
printf("\n POUR CONTINUER FRAPPER UNE TOUCHE ");
getch();
}
Les procedures
• Une procédure ne renvoie rien alors on précise le type void
– déclaration
Void nom_P( type arg1,type arg2, …type argn)
{
ensemble instructions
}
- Le prototype void car la procédure ne retourne rien.
- nom_P est le nom de la procedure
- arg1 …argn sont les arguments envoyés à la procedure
Introduction au Langage C
• Procédure:passage par valeur

– exemple:
void permutter(int a, int b)
{
int temp;
temp = a;
a = b;
b= temp;
Printf(« les valeurs après permutation sont %d%d »,a,b);
}
Main()
{int i,j;
Scanf(« %d%d »,&i,&j);
Printf(« les valeurs avant permutation sont %d%d »,i,j);
permutation(i,j);
Getch();}
Les procédures
Procédure: passage par adresse
– Exemple:
void permutter(int *pa, int *pb)
{
int temp;
temp = *pa;
*pa = *pb;
*pb= temp;
}
Main()
{int i,j;
Scanf(« %d%d »,&i,&j);
Printf(« les valeurs avant permutation sont %d%d »,i,j);
permutation(&i,j&);
Printf(« les valeurs après permutation sont %d%d »,&i,j&);
Getch();}
• Remplir et afficher un tableau:
#include<stdio.h> void lirev(vect v,int n)
{ int i;
#include<conio.h> for(i=0;i<n;i++)
#define x 100 {
printf("Donner le element %d : ",i+1);
typedef float vect[x]; scanf("%f",&v[i]);
void ecrirev(vect v,int n) }
{ }
main()
int i; {
for(i=0;i<n;i++) vect tab;
printf("entrez la dimension");
{ scanf("%d",&n);
printf("%.2f",v[i]); lirev(tab,n);
printf("\n"); printf("\nresultat : \n");
ecrirev(tab,n);
} getch();
} }
Pointeurs en Langage C
M.MOUSTAID
Définition
Toute variable manipulée dans un programme est stockée

quelque part en mémoire centrale. Cette mémoire est
constituée d'octets qui sont identifiés de manière univoque par
un numéro qu'on appelle adresse. Pour retrouver une variable,
il suffit donc de connaître l'adresse de l'octet où elle est
stockée
Exemple 1
• Exemple
int i, j;
i = 3;
j = i;
Si le compilateur a placé la variable i à l'adresse 4831836000 en
mémoire, et la variable j à l'adresse 4831836004, on a
Exemple 2
• Un pointeur est un objet dont la valeur est égale à l'adresse
d'un autre objet. On déclare un pointeur par l'instruction :
type *nom-du-pointeur;
Exemple
• suivant, on définit un pointeur p qui pointe vers un entier i :
int i = 3;
int *p;
p = &i;
Exemple 3
main()
{
int i = 3;
int *p;
p = &i;
printf(« i= %d \n",i);
printf(« p = %d \n",p);
printf("*p = %d \n",*p);
}
Résultat d’affichage est *p = 3.
Exemple 4
main()
{
int i = 3, j = 6;
int *p1, *p2;
p1 = &i;
p2 = &j;
*p1 = *p2;
printf(« i = %d \n",i);
printf(« j = %d \n",j);
printf(« p1 = %d \n",p1);
printf(« p2 = %d \n",p2);
printf(« *p1 = %d \n",*p1);
printf(« *p2 = %d \n",*p2);
Exemple 4
• Après l'affectation *p1 = *p2; du premier programme, on a
Exemple 5
main()
{
int i = 3, j = 6;
int *p1, *p2;
p1 = &i;
p2 = &j;
p1 = p2;
}
Exemple 5
• l'affectation p1 = p2 du second programme, conduit à la

situation :
Arithmétique des pointeurs
• Si i est un entier et p est un pointeur sur un objet de
type type, l'expression p + i désigne un pointeur sur un objet
de type type dont la valeur est égale à la valeur
de p incrémentée de i * sizeof(type).
main()
{
int i = 3;
int *p1, *p2;
p1 = &i;
p2 = p1 + 1;
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
}
affiche p1 = 4831835984 p2 = 4831835988.
Car le type int est codé en 4octets.
le même programme avec des pointeurs sur des objets de
type double :
main()
{
double i = 3;
double *p1, *p2;
p1 = &i;
p2 = p1 + 1;
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
}
affiche p1 = 4831835984 p2 = 4831835992.
Car le type double est codé en 8octets.
Taille d’un type
• Pour savoir la taille d’un type, utiliser le code suivant:
Exercice
Donnez le résultat du programme suivant:
Chaines de caractères
VII- LES CHAINES DE CARACTERES
Il n'existe pas de type spécial de chaine en C. Une chaîne de
caractères est traitée comme un tableau à une dimension de
caractères.
1- Déclaration
1.Un caractère : char
Char var;
Exemple de caractère : ‘a’, ‘z’, ‘\n’, …
2.Une chaine de caractères = Tableau de caractères

Char NomVariable[Longueur];
char ch[20];
3.Un pointeurs
char *NomVariable ;
NomVariable=(char*)malloc(Longueur*sizeof(char)) ;
Exemple: char *ch;
ch = (char*)malloc(20*sizeof(char));
1- Déclaration
Un pointeurs
char *NomVariable ;
NomVariable=(char*)malloc(Longueur*sizeof(char)) ;
Exemple: char *ch;
ch = (char*)malloc(20*sizeof(char));
2-Espace à réserver
Lors de la déclaration, nous devons indiquer l'espace à réserver en
mémoire pour le stockage de la chaîne.
La représentation interne d'une chaîne de caractères est terminée par le
symbole '\0' (NUL). Ainsi, pour un texte de n caractères, nous devons
prévoir n+1 octets.
-Les chaînes de caractères constantes sont indiquées entre guillemets.
La chaîne de caractères vide est alors: ""
3- Initialisation d’une chaine de caractères.
char ch[20] = {'b', 'o', 'n', 'j','o', 'u', 'r', '\0'};
char ch[20]; ch[0]=‘b’; ch[1]=‘o’; …
4- Accès aux éléments d'une chaîne
L'accès à un élément d'une chaîne de caractères peut se faire de la même façon que
l'accès à un élément d'un tableau.
En déclarant une chaîne par: char A[6];
nous avons défini un tableau A avec six éléments,
auxquels on peut accéder par: A[0], A[1], ... , A[5]
5- Comparaison des chaînes
"ABC" précède "BCD" car 'A‘>'B'
"ABC" précède "B" car 'A‘>'B'
"Abc" précède "abc" car 'A‘>'a'
" ab" précède "ab" car ' ‘>'a'
(le code ASCII de ' ' est 32, et le code ASCII de 'a' est 97)
6- Les fonctions des chaînes de caractères.
Il existe plusieurs fonctions distribuées dans différentes librairies.
Bibliotheque : <stdio.h>
la bibliothèque <stdio> nous offre des fonctions qui effectuent l'entrée et la sortie
des données.
les deux fonctions putchar et getchar, sont spécialement conçues pour l'écriture et la
lecture des caractères.
les deux fonctions puts et gets, sont spécialement conçues pour l'écriture et la lecture
de chaînes de caractères.
Exemple:
#include<stdio.h>
#define max 100
Main()
{ char c;
Char chaine[max];
Printf(" donner un caractère : " );
c = getchar();
putchar(c);
Printf("donner une chaîne de caractères : ");

gets(chaine);
puts(chaine);
}
Bibliothèque : <string.h>
strlen(s) : fournit la longueur de la chaîne sans compter le '\0'
strcpy(s, t) copie la chaine t vers la chaine s
strncpy(s, t, n) copie n caractères de la chaine t vers la chaine s
strcat(s, t) ajoute la chaine t à la fin de la chaine s
strncat(s, t, n) ajout n caractères de la chaine t à la fin de de la chaine s.
strcmp(s, t) compare la chaine s et la chaine t et fournit un résultat:
négatif si s précède t
zéro si s est égal à t
positif si s suit t
strrev(s) inverse la chaîne s.
Char s[10]="Bonjour" ,t[10]="tout le monde";
Int k;
K=strlen(s) k=7
K=strlen(t) k=13
strcpy(s, t)  s=tout le monde , t= tout le monde
strncpy(s, t, 7)  s=tout le , t= tout le monde
strcat(s, t)  s=Bonjourtout le monde , t= tout le monde
strncat(s, t, 4)  s=bonjourtout
K=strcmp(s, t)  k=1 car ‘b’>’t’
strrev(s) s=ruojnob
Bibliothèque : <ctype.h>
Les fonctions de classification suivantes fournissent un résultat du type int différent
de zéro, si la condition respective est remplie, sinon zéro.
isupper(s)!=0 si <c> est une majuscule ('A'...'Z')
islower(s) != 0si <c> est une minuscule ('a'...'z')
Les fonctions de conversion suivantes fournissent une valeur du type int qui peut
être représentée comme caractère; la valeur originale de <c> reste inchangée:
tolower(<c>) retourne <c> converti en minuscule si <c> est une majuscule
toupper(<c>) retourne <c> converti en majuscule si <c> est une minuscule
7- Les tableaux de chaines de caractères

Un tableau de chaînes de caractères correspond à un tableau à deux dimensions du
type char, où chaque ligne contient une chaîne de caractères.
Déclaration
char nom[nbr_L][nbr_C];
Exemple:
char JOUR[7][9];
//réserve l'espace en mémoire pour 7 chaines contenant 9 caractères.
initialisation
Lors de la déclaration il est possible d'initialiser toutes les composantes du tableau par
des chaînes de caractères constantes:
char JOUR[7][9]= {"lundi", "mardi", "mercredi","jeudi", "vendredi", "samedi",
"dimanche"};
Accès aux chaînes
Il est possible d'accéder aux différentes chaînes de caractères d'un tableau, en
indiquant simplement la ligne correspondante.
Exemple
int i = 2;
printf("Aujourd'hui, c'est %s !\n", JOUR[i]);
Affichera la phrase: Aujourd'hui, c'est mercredi !
Remarque :
L'attribution d'une chaîne de caractères à une composante d'un tableau de chaînes se
fait en général à l'aide de la fonction strcpy:
Exemple
La ligne strcpy(JOUR[4], "Friday");
//changera le contenu de la 5e composante du tableau JOUR de "vendredi" en
"Friday".
Exemple:
Exemple:
LES STRUCTURES
Définition
• Le langage C autorise la déclaration de types particuliers: les
structures . Une structure est constituée de plusieurs
éléments de même type ou non.
• Les structures de données
– déclaration
struct nom_structure
{
type1 nomchamps1;
type2 nomchamps2;
.
.
.
typeN nomchampsN;
};
111
– exemple et utilisation
Typedef struct
{
int x;
int y;
int z;
char nom;
} pt;
main()
{
pt p;
}
112
– simplification de l'écriture
struct pt
{ typedef struct pt
int x;
int y; {
int z;
char nom; Notations int x;
}; équivalentes int y;
typedef struct pt point; int z;
char nom;
main() } point;
{
point p;
}
113
Exemple:
Déclaration:
typedef struct /* On définit un type struct */

{
char nom[10];
char prenom[10];
int age;
float note;
}
fiche;
Exercice
• Créer la structure ci-dessus, saisir une fiche, l'afficher
#include <stdio.h>
#include <conio.h>
typedef struct
{
char nom[10];
char prenom[10];
int age;
float note;
}
fiche;
main()
{
fiche f;
printf("SAISIE D'UNE FICHE \n");
printf("NOM: ");gets(f.nom);
printf("PRENOM: ");gets(f.prenom);
printf("AGE: ");scanf("%d",&f.age);
printf("NOTE: ");scanf("%f",&f.note);
printf("\n\nLECTURE DE LA FICHE:\n");
printf("NOM: %s PRENOM: %s AGE: %d NOTE: %f",
f.nom,f.prenom,f.age,f.note);
getch();
} - Le Langage C - M.MOUSTAID
STRUCTURES ET TABLEAUX
• On peut définir un tableau de structures

• Exemple: (à partir de la structure définie précédemment)
• Déclaration: fiche f[10]; /* on déclare un tableau

de 10 fiches */
• Ecrire le code
Utilisation:
Changer les informations de la fiche 2 par: "xxx" "xxx" 20 11.5.
strcpy(f[2].nom, "xxx") /* pour un indice i quelconque */

strcpy(f[2].prenom,"xxx")
f[2].age = 20;
f[2].note = 11.5;
Exercice : Créer une structure point{int num;float x;float y;}

Saisir 4 points, les ranger dans un tableau puis les afficher.
Exercices :
Ex1:Créer une structure point{int num;float x;float y;}
Saisir 4 points, les ranger dans un tableau puis les afficher.
Ex2:Créer une structure Entreprise dont les champs sont:
*statut
*nombresEmploys.
Sachant que chaque employé a un nom; prénom; adresse; fonction
• Saisir les informations de l’entreprise
• Afficher les données des employés dont la fonction est
« Technicien ».Utiliser la fonction strcmp
#include <stdio.h>
#include <conio.h>
typedef struct {int num;float x;float y;} point;
void main()
{
point p[4]; /* tableau de points */
int i;
float xx,yy;
/* saisie */
printf("SAISIE DES POINTS\n\n");
for(i=0;i<4;i++)
{
printf("\nRELEVE N¯%1d\n",i);
p[i].num = i;
printf("X= ");scanf("%f",&xx);
printf("Y= ");scanf("%f",&yy);
p[i].x = xx;p[i].y = yy;
}
/* relecture */
printf("\n\nRELECTURE\n\n");
for(i=0;i<4;i++)
{
printf("\nRELEVE N¯%1d",p[i].num);
printf("\nX= %f",p[i].x);
printf("\nY= %f\n",p[i].y);
}
printf("\n\nPOUR SORTIR FRAPPER UNE TOUCHE ");
getch();
}
STRUCTURES ET POINTEURS
• On peut déclarer des pointeurs sur des structures. Cette

syntaxe est très utilisée en langage C, elle est notamment
nécessaire lorsque la structure est un paramètres modifiable
dans la fonction.
•
• Un symbole spécial a été créé pour les pointeurs de
structures, il s'agit du symbole ->
•
• Exercice : Reprendre l'exercice VIII_2: Une fonction saisie
permet de saisir un point, une fonction affiche permet
d'afficher un point.
#include <stdio.h>
#include <conio.h>
void saisie(point *pp,int i)

{
float xx,yy;
printf("\nRELEVE Nø%1d\n",i);
printf("X= ");scanf("%f",&xx);
printf("Y= ");scanf("%f",&yy);
pp->num = i;pp->x = xx;pp->y = yy;
}
void affiche(point *pp)

{
printf("\nRELEVE Nø%1d",pp->num);
printf("\nX= %f",pp->x);
printf("\nY= %f\n",pp->y);
}
void main()
{
point p[4]; /* tableau de points */
int i;
printf("SAISIE:\n\n");
for(i=0;i<4;i++)saisie(&p[i],i);
printf("\n\nRELECTURE:\n\n");
for(i=0;i<4;i++)affiche(&p[i]);
getch();
}
• Calculer et afficher les racines de ax2+bx+c=0.
• Une fonction de prototype void saisie(float *aa,float
*bb,float *cc) permet de saisir a,b,c.
• Une fonction de prototype void calcul(float aa,float bb,float
cc) exécute les calculs et affiche les résultats.
• a, b, c sont des variables locales à main();
• main() se contente d'appeler saisie(&a,&b,&c) et
calcul(a,b,c).
#include <stdio.h>
#include <math.h>
#include <conio.h>
#include "c:\bc5\courc_C\teach_c\chap7\chap7.h" /* fichier
d'en-tete */
void saisie(float *aa,float *bb,float *cc)

{
printf("\nENTRER A: ");scanf("%f",aa);
printf("\nENTRER B: ");scanf("%f",bb);
printf("\nENTRER C: ");scanf("%f",cc);
printf("\n");
}
•
void calcul(float aa,float bb,float cc)
{
float delta,x1,x2;
printf("\nA= %f B= %f C=%f\n",aa,bb,cc);
delta = bb*bb-4*cc*aa;
printf("\nDELTA = %f\n",delta);
if (delta<0) printf("\nPAS DE SOLUTION");
if (delta == 0)
{
x1=-(bb/aa/2);
printf("\UNE SOLUTION: X= %f\n",x1);
}
if (delta > 0)
{
x1=(-bb+sqrt(delta))/2/aa;
x2=(-bb-sqrt(delta))/2/aa;
printf("\DEUX SOLUTIONS: X1 = %f X2 = %f\n",x1,x2);
}
}
void main()
{
float a,b,c;
saisie(&a,&b,&c);
calcul(a,b,c);
getch();
}
Les fichiers en langage C
Problématique
Le défaut avec les variables, c'est

qu'elles n'existent que dans la mémoire
vive(RAM). Une fois votre programme
arrêté, toutes vos variables sont
supprimées de la mémoire et il n'est pas
possible de retrouver ensuite leur valeur.
Ouvrir et fermer un fichier
Pour lire et écrire dans des fichiers, nous

Allons nous servir de fonctions situées
dans la librairie stdio.h
fopen : ouverture du fichier
Cette fonction attend 2 paramètres :

Le nom du fichier à ouvrir
Le mode d'ouverture du fichier
• Cette fonction renvoie... un pointeur sur FILE
le paramètre "modeOuverture".
• "r" : lecture seule. Vous pourrez lire le contenu du fichier, mais pas
écrire dedans. Le fichier doit avoir été créé au préalable.
• "w" : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire
son contenu. Si le fichier n'existe pas, il sera créé.
• "r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier.
Le fichier doit avoir été créé au préalable.
• "w+" : lecture et écriture, avec suppression du contenu au préalable.
Le fichier est donc d'abord vidé de son contenu, et vous écrivez et lisez
ensuite dedans. Si le fichier n'existe pas, il sera créé.
Exemple
int main()
{
FILE* fichier = NULL;
fichier =
fopen("test.txt", "r+");
return 0;
}
Exemple
int main()
{
FILE *fichier=NULL;
fichier= fopen("C:\\Program Files\\Exemple\\exercice.txt",
"r+");
return 0;
}
Tester l'ouverture du fichier
int main()
{
fichier = fopen("test.txt", "r+");
if (fichier != NULL)
{
printf(" On peut lire et écrire dans le fichier");
}
else
{
printf("Impossible d'ouvrir le fichier test.txt");
}
fclose(fichier);
// On ferme le fichier qui a été ouvert
return 0;
} - Le Langage C - M.MOUSTAID
Différentes méthodes de
lecture / écriture
Ecrire dans le fichier
Il existe plusieurs fonctions capables d'écrire

dans un fichier.
Voici les 3 fonctions que Nous allons étudier :
• fputc : écrit un caractère dans le fichier (UN
SEUL caractère à la fois).
• fputs : écrit une chaîne dans le fichier
• fprintf : écrit une chaîne "formatée" dans le
fichier, fonctionnement quasi-identique à printf
fputc
int main()
{
fichier = fopen("test.txt", "w");
{
fputc('A', fichier);
//Ecriture du caractère A
fclose(fichier); }
return 0;
}
fputs
int main()
{
{
fputs("Salut MIPC ", fichier);
fclose(fichier);
}
return 0;
}
fprintf
int main()
{
int age = 0;
{
printf("Quel age avez-vous ? ");
scanf("%d", &age);
// On l'écrit dans le fichier
fprintf(fichier, "Le Monsieur qui utilise le programme, il a %d ans",
age);
fclose(fichier);
}
return 0;}
Lire dans un fichier
1. fgetc : lit un caractère

2. fgets : lit une chaîne
3. fscanf : lit une chaîne formatée
fgetc
int main()
{
char caractereActuel ;
fichier = fopen("test.txt", "r");
{ // Boucle de lecture des caractères un à un
do
{ caractereActuel = fgetc(fichier);
// On lit le caractère
printf("%c", caractereActuel);
// On l'affiche
}
while (caractereActuel != EOF);
// On continue tant que fgetc n'a pas retourné EOF (fin de fichier)
fclose(fichier);
}
return 0;
}
fgets
#define TAILLE_MAX 1000 // Tableau de taille 1000
int main()
{ FILE* fichier = NULL;
char chaine[TAILLE_MAX+1] = "";
// Chaîne vide de taille TAILLE_MAX
{ fgets(chaine, TAILLE_MAX, fichier);
// On lit maximum TAILLE_MAX caractères du fichier, on stocke
le tout dans "chaine"
printf("%s", chaine);
// On affiche la chaîne
fclose(fichier);
} return 0;} - Le Langage C - M.MOUSTAID
fscanf
int main()
{
int score[3] = {0,0,0};
// Tableau des 3 meilleurs scores
{
fscanf(fichier, "%d %d %d", &score[0], &score[1], &score[2]);
printf("Les meilleurs scores sont : %d, %d et %d", score[0],
score[1], score[2]);
fclose(fichier);
}
return 0;
}
Fin

Cours-Langage C

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Cours-Langage C

Загружено:

Авторское право:

Доступные форматы

Langage de Programmation

2. Éléments de base (règles d’écriture, types…)

5. Les entrées-Sorties (printf, scanf)

6. Les structures de contrôle

7. Classification des variables

8. Les objets structurés (tableaux, structures)

10. Les pointeurs

11. Les fichiers

12. Le préprocesseur (#include, #define…)

• Opérations arithmétiques : addition, soustraction,

La directive #include inclu le fichier stdio.h au programme avant

La fonction printf permet d’afficher à l’ecran

• Exemples: char alpha;

Algorithme : Déclaration Entier : j, M, A chaîne : Mois

–accès aux éléments du tableau

j=0 j=1 j=2 j=3 j=4

void bonjour() /* declaration de la fonction */

void main() /* programme principal */

void bonjour() /* declaration de la fonction */

void test() /* declaration de la fonction */

void main() /* programme principal */

void carre() /* declaration de la fonction */

void carre() /* declaration de la fonction */

void cube() /* declaration de la fonction */

int n; /* variable globale, connue de tout le programme */

void carre() /* declaration de la fonction */

void cube() /* declaration de la fonction */

int lance_de() /* declaration de la fonction */

int carre(int x) /* declaration de la fonction */

int puissance(int x,int y)

• Procédure:passage par valeur

Toute variable manipulée dans un programme est stockée

• Après l'affectation *p1 = *p2; du premier programme, on a

• l'affectation p1 = p2 du second programme, conduit à la

Il n'existe pas de type spécial de chaine en C. Une chaîne de

caractères est traitée comme un tableau à une dimension de

2.Une chaine de caractères = Tableau de caractères

Exemple: char *ch;

Exemple: char *ch;

Lors de la déclaration, nous devons indiquer l'espace à réserver en

mémoire pour le stockage de la chaîne.

La représentation interne d'une chaîne de caractères est terminée par le

symbole '\0' (NUL). Ainsi, pour un texte de n caractères, nous devons

prévoir n+1 octets.

-Les chaînes de caractères constantes sont indiquées entre guillemets.

La chaîne de caractères vide est alors: ""

3- Initialisation d’une chaine de caractères.

char ch[20] = {'b', 'o', 'n', 'j','o', 'u', 'r', '\0'};

char ch[20]; ch[0]=‘b’; ch[1]=‘o’; …

4- Accès aux éléments d'une chaîne

l'accès à un élément d'un tableau.

En déclarant une chaîne par: char A[6];

nous avons défini un tableau A avec six éléments,

auxquels on peut accéder par: A[0], A[1], ... , A[5]

5- Comparaison des chaînes

"ABC" précède "BCD" car 'A‘>'B'

"ABC" précède "B" car 'A‘>'B'

"Abc" précède "abc" car 'A‘>'a'

" ab" précède "ab" car ' ‘>'a'

6- Les fonctions des chaînes de caractères.

Il existe plusieurs fonctions distribuées dans différentes librairies.

lecture des caractères.

Printf("donner une chaîne de caractères : ");

• Après l'affectation p1 = p2; du premier programme, on a

void saisie(float aa,float bb,float *cc)