Programmation C

AHMED BENTAJER

A.BENTAJER@GMAIL.COM

Université Abdelmalek Essaadi�Ecole Nationale des Sciences Appliquées

-Tétouan

2AP-2

2019/2020

Plan du cours

Chapitre 2: Notions de base

Chapitre 3: Type de base, Opérateurs & expr.

Chapitre 5 : La structure alternative

Chapitre 4 : Lire & écrire des données

Chapitre 6 : La structure répétitive

Introduction

Chapitre 1 : Env. & Bibl. de fonctions

Plan du cours

Chapitre 9 : Les pointeurs

Chapitre 10 : Les fonctions

Chapitre 12 : La programmation modulaire

Chapitre 11 : Les fichiers séquentiels

Chapitre 13 : Les préprocesseur

Chapitre 7 : Les tableaux

Chapitre 8 : Les chaînes de caractères

Introduction

Programmer c’est quoi ! ?

Réaliser des programmes informatiques

Introduction

Programmer c’est quoi ! ?

Introduction

Programmer c’est quoi ! ?

Problème 1 : Comment écrire des programmes en binaire ?

Solution 1 : Inventer de nouveaux langages qui vont être traduits en binaire pour l’ordinateur

Problème 2 : Comment réaliser le programme qui fait la traduction ?

Solution 2 : Existe déjà ☺ !!

Ch1 : Env. et les Bibl.

Les bibl. de fonctions

Bibl. de fonctions disponibles dans leur form précompilé (.LIB)

Inclure des fichiers en-tête (Header files - .H) qui contiennent des prototypes des fonctions définies dans les bibliothèques & créent un lien entre les fcts précompilées et les programmes

• .C fichiers source

​

• .OBJ fichiers compilés (versions objet)

​

🡪 .EXE fichiers compilés et liés (versions exécutables)

​

• .LIB bibliothèques de fonctions précompilées

​

🡪 .H fichiers en-tête (header files)

Ch1 : Env. et les Bibl.

Les bibl. de fonctions

Stdio.h

Math.h

…

#include <stdio.h>

#include <math.h>

#include …

​

void main()

{

…

}

Compiler

Code compilé de la fct Main

Linker

Code compilé de la fct Main

Stdio.lib

Fichiers d’entête

.Exe

Math.lib

….lib

Ch2 : Notions de bases

Hello World

HELLO_WORLD en C

​

#include <stdio.h>

#include <…>

​

Int main()

/* Notre premier programme en C */

{

printf("hello, world\n");

return 0;

}

HELLO_WORLD en langage algorithmique

programme HELLO_WORLD

(* Notre premier programme en C *)

écrire "hello, world"

finprogramme

Commentaire

Instructions

Fonction

Ch2 : Notions de bases

Les fonctions

<TypeRés> <NomFonct> (<TypePar1> <NomPar1>, <TypePar2> <NomPar2>, ... )

{

<déclarations locales>

<instructions>

}

TypeRés : le type du résultat de la fonction

<TypePar1> <NomPar1>, <TypePar2> <NomPar2>, ...

Les types et les noms des paramètres de la fonction

Un block d’instruction délimité par { } qui contient :

NomFonct : le nom de la fonction

Déclaration locales : les déclarations des données locales

Instructions : la liste des instructions qui définit l'action qui doit être

exécutée

Ch2 : Notions de bases

Les identificateurs

Les noms des fonctions et variables en C, sont composés d’une suite de lettre et chiffre

Le 1^er caractère doit être un CARACTERE ou le _

L’ensemble des caractères utilisables est donc :

{a-z, A-Z, 0-9, _ }

Les identificateurs servent à désigner les différents "objets" manipulés par le programme: variables, fonctions, etc

Nom_de_variable # nom_de_variable

La longueur des identificateurs n'est pas limitée, mais C distingue seulement les 31 premiers caractères

Ch2 : Notions de bases

Les mots clés

Certains "mots clés" sont réservés par le langage à un usage bien défini et ne peuvent pas être utilisés comme identificateurs.

Auto | default | float | register | struct | volatile | break | do | for | return | switch | while |case | double | goto | short | typedef |char | else | if | signed | union |const | enum | int | sizeof | unsigned | continue | extern | long | static | void

Ch2 : Notions de bases

Les Commentaires

// ceci est un commentaire qui ne peut s’étaler que sur une ligne

Les commentaires sont tr`es important dans n’importe quel langage de programmation car ils permettent de documenter les fichiers de sources

/* ceci est un commentaire qui peut

s’étaler sur plusieurs lignes */

Ch2 : Notions de bases

Conventions d’écritures d’un programme en C

Ne jamais placer plusieurs instructions sur une même ligne ;

Avant d’aller plus loin, il convient d’établir un certain nombre de règles de

présentation que devra suivre tout bon programmeur qui souhaite écrire des

programmes C lisibles

utiliser des identificateurs significatifs

grâce à l’indentation des lignes, faire ressortir la structure syntaxique du

programme

laisser une ligne blanche entre la dernière ligne des déclarations et la première ligne des instructions ;

aérer les lignes de programme en entourant par exemple les opérateurs avec

des espaces

bien commenter les listings

Ch2 : Notions de bases

Discussion du programme Hello World

Ch2 : Notions de bases

Exercice

Les identificateurs

Hello World

Modifiez le programme 'hello world' de façon à obtenir le résultat suivant :

Ch2 : Notions de bases

Exercice

Ci-dessous, un simple programme en C. Distinguer et de classifier les éléments qui composent ce programme (commentaires, variables, déclarations, instructions, etc.)

#include <stdio.h>

/*

Ce programme calcule la somme de 4 nombres entiers

introduits au clavier.

*/

main()

{

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;

}

Ch3 : Type de base, Opérateurs & expr.�

Introduction

Les types de base du langage C se répartissent en trois grandes catégories en fonction de la nature des informations qu'ils permettent de représenter:

b1

bn

………………………….

1 Octet = 8 bits

Nombres entiers (int NomVar)

Exemple : int nombre = 12;

Nombres flottant (float NomVar)

Exemple : float pi = 3.14;

Caractères (char NomVar)

Exemple : char _unChar;

En langage C, une variable est constitué de deux choses :

Nom : qui permet de reconnaitre la variable

Valeur : La valeur qu’elle stocke

Ch3 : Type de base, Opérateurs & expr.�

Le type entier

Le mot clé int correspond à la représentation des nombres entiers relatifs

Short

int

long

Description : Entier court

Nb Octet : 2

Description : Entier Standard

Nb Octet : 2 | 4

Description : Entier long

Nb Octet : 4

En toute rigueur, chacun des trois types (short, int et long) peut être nuancé par l’utilisation du qualificatif unsigned (non signé). Dans ce cas, il n’y a plus de bit réservé au signe et on ne représente plus que des nombres positifs.

Exemple : unsigned int nombre = 12;

Ch3 : Type de base, Opérateurs & expr.�

Le type flottant

Les types flottants permettent de représenter une partie des nombres réels

float

double

Long double

Nb Octet : 4

Nb Octet : 8

Nb Octet : 10

La logique du programme c’est : combien de 2 y’a-t-il dans 5 !!?

Ch3 : Type de base, Opérateurs & expr.�

Langage algorithmique

Déclaration des

variables

En C

<Type> <NomVar1>,<NomVar2>,...,<NomVarN>

<Type> <NomVar1>,<NomVar2>,...,<NomVarN>

entier COMPTEUR,X,Y

réel HAUTEUR,LARGEUR

int COMPTEUR,X,Y

float HAUTEUR,LARGEUR

Affection des variables

Langage algorithmique

En C

En <NomVariable> ranger <Expression>

<NomVariable> = <Expression>

En Pi ranger 3.14

Pi = 3.14

En moyenne ranger A+B/2

Moyenne = A+B/2

Ch3 : Type de base, Opérateurs & expr.�

Les opérateurs

Arithmétique

Logique

Comparaison

Résultat du type int :

1 : correspond à la valeur booléan TRUE.

​

0 : correspond à la valeur booléan FALSE

Ch3 : Type de base, Opérateurs & expr.�

Les opérateurs

Affection composée

Incrémentation

X = I++ : passe d'abord la valeur de I à X et incrémente après

​

X = I-- : passe d'abord la valeur de I à X et décrémente après

​

X = ++I : incrémente d'abord et passe la valeur incrémentée à X

​

X = --I : décrémente d'abord et passe la valeur décrémentée à X

Soit N = 5

X = N++

X= ++N

X = 5 et N = 6

X = 6 et N = 6

Ch3 : Type de base, Opérateurs & expr.�

La bibliothèque

math.h

#include <math.h>

Ch3 : Type de base, Opérateurs & expr.�

Les conversions

Si un opérateur a des opérandes de différents types, les valeurs des opérandes sont converties automatiquement dans un type commun.

Lors d'une affectation, la donnée à droite du signe d'égalité est convertie dans le type à gauche du signe d'égalité. Dans ce cas, il peut y avoir perte de précision si le type de la destination est plus faible que celui de la source.

Exemple :

int I = 8; float X = 12.5; double Y;

Y = I * X;

Pour pouvoir être multiplié avec X, la valeur de I est convertie en float (le type le plus large des deux). Le résultat de la multiplication est du type float, mais avant d'être affecté a Y, il est converti en double. Nous obtenons comme résultat: Y = 100.00

Ch3 : Type de base, Opérateurs & expr.�

Les constants caractères

Pour designer un caractère imprimable, il suffit de le mettre entre apostrophes�

Exemple : ‘A’ ou ‘@’

Les seuls caractères qu’on peut pas représenter sont l’antislash et l’apostrophe qui sont désignés par \\ et \’

Les caractères non imprimables peuvent être désignés par ’\code-octal’ ou code-octal est le code en octal du caractère. On peut aussi écrire ’\xcode-hexa’ ou code-hexa est le code en hexadecimal du caractere . Par exemple, ’\33’ et ’\x1b’ désignent le caractère escape.

Ch3 : Type de base, Opérateurs & expr.�

Operateur ternaire

L’operateur conditionnel ? est un operateur ternaire. Sa syntaxe est la suivante :

Condition ? Exp1 : Exp2

L’opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d’un objet. On écrit�

Operateur de conversation

(type) objet

int i = 3, j = 2;

printf("%f \n",(float)i/j);

Ch3 : Type de base, Opérateurs & expr.�

Operateur adresse

L’operateur d’adresse & applique a une variable retourne l’adresse-memoire de cette variable. La syntaxe est�

& objet

L’opérateur de conversion de type, appelé cast, permet de modifier explicitement le type d’un objet. On écrit�

Operateur de conversation

(type) objet

int i = 3, j = 2;

printf("%f \n",(float)i/j);

Ch4 : Lire et écrire des données�

Intro

La bibliothèque standard <stdio> contient un ensemble de fonctions qui assurent la communication de la machine avec l’utilisateur

printf()

scanf()

getchar()

putchar()

Écriture formatée des données

Lecture formatée des données

Lecture d’un caractère

Ecriture d’un caractère

Ch4 : Lire et écrire des données�

Printf()

des caractères à afficher tels quels

des codes de format repérés par %

%d ou %i

%u

%o

%x

%c

%f

%e

%s

Entier relatif

Entier naturel (unsigned)

Entier exprimé en octet

Entier exprimé en hexadécimal

Caractère

Double (en notation décimal)

Double (en notation scientifique)

Chaine de caractère

Ch4 : Lire et écrire des données�

Putchar()

…

char x;

x = ‘a’;

putchar(x);

…

…

char x;

x = ‘a’;

printf(‘’%c’’, x);

…

Ch4 : Lire et écrire des données�

scanf()

La fonction scanf() est la fonction symétrique de printf()

lire <NomVariable1>,<NomVariable2>, ...

scanf("<format>",<AdrVar1>,<AdrVar2>, ...)

Langage algorithmique

En C

L’@ ou va être stocké la valeur

Détermine comment les données

Seront interprétées

Exemple :

int jour, mois, annee;

Printf(‘’Saisir votre jour de naissance : \n’’);

scanf(‘’ %d’’, &jour);

​

Printf(‘’Saisir votre mois de naissance : \n’’);

scanf(‘’ %d’’, &mois);

​

Printf(‘’Saisir votre anneede naissance : \n’’);

scanf(‘’ %d’’, &annee);

Exemple :

int jour, mois, annee;

Printf(‘’Saisir votre datede naissance : \n’’);

scanf(‘’ %d %d %d’’, &jour, &mois, &annee);

​

Ch4 : Lire et écrire des données�

scanf()

Ch4 : Lire et écrire des données�

Putchar()

…

char x;

x = getchar();

putchar(x);

…

…

char x;

x = scanf(‘’%c’’, &x);

putchar(‘’%c’’, x);

…

Ch4 : Lire et écrire des données�

Exercice

1. écrivez un programme qui lit la date du clavier et écrit les données ainsi que le nombre de données correctement reçues sur l'écran.

Exemple:

Introduisez la date (jour mois année): 18 09 2013

• données reçues : 3
• jour : 11
• mois : 11
• année : 1991

2. Testez les réactions du programme à vos entrées. Essayez d'introduire des nombres de différents formats et différentes grandeurs

3. Changez la partie format du programme de façon à séparer les différentes données par le symbole '-'

Ch4 : Lire et écrire des données�

Exercice

Quelles seront les valeurs lues dans les variables net p(de type int), par l’instruction suivante ?

scanf ("%4d %2d", &n, &p) ;

lorsqu’on lui fournit les données suivantes (le symbole ^ représente un espace et le symbole @ représente une fin de ligne, c’est-à-dire une validation) ?

a) 12^45@

b) 123456@

c) 123456^7@

d) 1^458@

e) ^^^4567^^8912@

4-3 ) Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code numérique:

Ch4 : Lire et écrire des données�

Exercice

4.4 - Ecrire un programme qui permute et affiche les valeurs de trois variables A, B, C de type entier qui sont entrées au clavier :

A ==> B , B ==> C , C ==> A

4.5 - Ecrire un programme qui affiche le quotient et le reste de la division entière de deux nombres entiers entrés au clavier

4.6 - Ecrire un programme qui affiche la résistance équivalente à trois résistances R1, R2, R3 (type double),

- si les résistances sont branchées en série: R = R1+R2+R3

- si les résistances sont branchées en parallèle: R = (R1.R2.R3)/(R1.R2+R1.R3+R2.R3)

Ch5 : La structure alternative�

Introduction

Tous les langages disposent d’instructions, nommées instructions de contrôle, permettant de réaliser des choix

Ch5 : La structure alternative�

If … else

Si la variable vaut ça

Alors faire ceci

if (Condition logique) {

faire ceci si la condition est vraie

}

if (age >= 18) {

printf(‘’Vous etes majeur’’);

}

Si la variable vaut ça

Alors faire ceci

Si non faire cela

if (Condition logique) {

faire ceci si la condition est vraie

}

Else {

faire cela si la condition est fausse

}

if (age >= 18) {

printf(‘’Vous etes majeur’’);

}

Else {

printf(‘’Vous etes mineur’’);

}

Ch5 : La structure alternative�

If … else

Le dernier else est toujours lié au if qui ne possède pas de partie else

Char sexe = ‘m’

​

if (sexe == ‘m’) {

printf(‘vous êtes un homme’’);

}

​

If (sexe != ‘m’)

{

printf(‘vous êtes une femme’’);

}

​

Else {

printf(‘euuuuh, ☺!!’’);

}

#include <stdio.h>

​

main() {

int A,B;

printf("Entrez deux nombres entiers :");

scanf("%i %i", &A, &B);

​

if (A > B)

printf("%i est plus grand que %i\n", A, B);

​

else if (A < B)

printf("%i est plus petit que %i\n", A, B);

else printf(‘’%i est egal a %i’’,A,B);

​

return 0; }

Ch5 : La structure alternative�

Exercice

5.3 - Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier et qui affiche la plus grande des trois valeurs, en utilisant:

a) if - else et une variable d'aide MAX

b) if - else if - ... - else sans variable d'aide

Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe du produit de A et B sans faire la multiplication.

Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe de la somme de A et B sans faire l'addition. Utilisez la fonction fabs de la bibliothèque <math>

Ch5 : La structure altérnative�

L’instruction switch

SWITCH

Cas 1

Cas 3

Cas 2

Cas n

default

Ch5 : La structure altérnative�

L’instruction switch

Ch5 : La structure répétitive

Introduction

C’est quoi une boucle ?

while

Do … while

for

Instruction

Instruction

Instruction

Instruction

Instruction

Ch5 : La structure répétitive

While

tant que (<expression logique>) faire

<bloc d'instructions>

ftant

Tan que la valeur logique <expression logique> fournit un résultat TRUE, exécuter <bloc d’instruction>

Int nombre = 0;

While (nombre != 12) {

printf(‘’veuillez saisir 12 pour sortir de la boucle’’);

nombre = scanf(‘’%d’’,&nombre);

}

Ch5 : La structure répétitive

Exemple

fflush(stdin);

Ch5 : La structure répétitive

do .. while

do {

<bloc d'instructions>

}

while (<expression logique>)

Tester le même exemple avec int compteur = 0

#include <stdio.h>

#include <math.h>

main()

{

float N;

do {

printf("Entrer un nombre (>= 0) : ");

scanf("%f", &N);

}

while (N < 0);

printf("La racine carrée de %.2f est %.2f\n", N, sqrt(N));

return 0;

}

Ch5 : La structure répétitive

For

For ( <expr1> ; <expr2>; <expr3> )

{

<instruction>

}

<expr1> : est évaluée une fois avant le passage de la boucle. Elle est utilisée pour initialiser les données de la boucle.

<expr2> : est évaluée avant chaque passage de la boucle. Elle est utilisée pour décider si la condition de sortie de la boucle a été atteinte

<expr3> : st évaluée à la fin de chaque passage de la boucle. Elle est utilisée pour réinitialiser les données de la boucle.

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

printf(‘’valeur de i : %d’’, i);

}

Int i ;

i = 0;

for ( ; i<10; i++) {

printf(‘’valeur de i : %d’’, i);

}

Int i ;

i = 0;

for ( ; i<10; ) {

printf(‘’valeur de i : %d’’, i);

i++;

}

Ch5 : La structure répétitive

Choix de la structure !!?

Si le bloc d'instructions ne doit pas être exécuté si la condition est fausse, alors utilisez while ou for.

Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez do - while

Si le nombre d'exécutions du bloc d'instructions dépend d'une ou de plusieurs variables qui sont modifiées à la fin de chaque répétition, alors utilisez for.

Si le bloc d'instructions doit être exécuté aussi longtemps qu'une condition extérieure est vraie (p.ex aussi longtemps qu'il y a des données dans le fichier d'entrée), alors utilisez while.

Ch6 : Les Tableaux�

Introduction

Un tableau est un ensemble d’élément du même type, désigné par un identificateur unique, sur un espace mémoire contigu

Un tableau est donc une suite de cases (espace mémoire) de même taille. La taille de chacune des cases est conditionnée par le type de donnée que le tableau contient

Les tableaux permettent une manipulation plus flexible des chaine de caractère

@

1000

1001

1002

1003

Valeur

2

5

12

9

Un tableau prend un espace contigu dans la mémoire

Toutes les cases du tableau sont du même type

Ch5 : Les Tableaux�

Les tableaux unidimensionnels

Un tableau (unidimensionnel) est une variable structurée formée d'un nombre entier N de variables simples du même type, qui sont appelées les composantes du tableau. Le nombre de composantes N est alors la dimension du tableau.

Déclaration :

Type Nom_Tableau [ TAILLE ]

Exemple :

​

int mois[12]={1,2,3,4,5,6,7,8,9,10,11,12}; // Déclaration et initialisation d’un tableau de type entier d’une taille de 12

2 * 12 = 24 Octet

Utilisation de l’opérande sizeof()

N

mois[2] = 3 // ON AJOUTE LE MOIS 3 dans le 3^ième élément du tableau

Ch5 : Les Tableaux�

Les tableaux unidimensionnels

Accès aux éléments

Int t[5] = {1,2,3,4,5};

Printf (‘’%d’’, t); ??

Pour accéder à un élément du tableau, le nom que l'on a donné à celui-ci ne suffit pas car il comporte plusieurs éléments. Ainsi, on définit un nombre �appelé indice (en anglais index) qui, combiné avec le nom du tableau, permet de décrire exactement chaque élément.

i=0

i=1

i=n-3

i=n-2

i=n-1

Pour lire une entrée dans le tableau i suffit de mettre

Printf(‘’%d’’,t[i]); 0<= i < N //N = taille du tableau

Ex : printf(‘’%d’’, t[1]) 🡪 2

1. L'indice du premier élément du tableau est 0
2. Un indice est toujours positif
3. L'indice du dernier élément du tableau est égal au nombre d'éléments - 1

1

6

70

56

3

Ch5 : Les Tableaux�

Les tableaux à deux dimensions

Un tableau à deux dimensions est interprété comme un tableau unidemensionnel de dimension L dont chaque composante est un tableau (uni-dimensionnel) de dimension C.

L : Nombre de ligne

C : Nombre de colonne

L*C composantes

L

C

Ch5 : Les Tableaux�

Les tableaux à deux dimensions

Considérons un tableau NOTES à une dimension pour mémoriser les notes de 10 étudiants dans un devoir

Si on veut mémoriser les notes de 10 étudiants dans 3 modules ??

Ch5 : Les Tableaux�

Les tableaux à deux dimensions

<Type> <NomTabl>[<DimLigne>][<DimCol>];

Mémorisation

Comme pour les tableaux à une dimension, le nom d'un tableau est le représentant de l'adresse du premier élément du tableau (c.-à-d. l'adresse de la première ligne du tableau).

short A[3][2] = {{1, 2 }, {10, 20 }, {100, 200}};

Ch5 : Les Tableaux�

Les tableaux à deux dimensions

Initialisation et réservation automatique

int T[4][4] = { {1,0,0,0}, {1,1,0,0}, {1,1,1,0}, {1,1,1,1} } ;

Accéder aux compostantes

Ch5 : Les Tableaux�

Les tableaux à deux dimensions

for (i = 0; i<L; i++) {

for (j=0; j<C; j++) {

printf(‘’%d’’, T[i][j]);

}

printf(‘’\n’’);

}

Ch5 : Les Tableaux�

Exemples

main() {

int A[5][10];

int I,J;

for (I=0; I<5; I++) {

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

printf("%d", A[I][J]);

printf("\n");

}

return 0;

}

main() {

int A[5][10];

int I,J;

for (I=0; I<5; I++)

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

scanf("%d", &A[I][J]);

return 0;

}

Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int . Remplir le tableau par des valeurs entrées au clavier et afficher le tableau.

Ecrire un programme qui transfère un tableau M à deux dimensions L et C dans un tableau V à une dimension.

Ch8 : Les chaînes de caractères�

Introduction

Contrairement à d’autre langage de programmation (JAVA,…), C ne dispose pas d’un type spécial pour traiter les chaînes de caractères

C permet de stocker UN CARACTERE à l’aide du char

char chaine[DIM];

Un tableau est un ensemble d’élément du même type, désigné par un identificateur unique, sur un espace mémoire contigu

char nom[10];

char prenom[20];

char email[20];

Lors de la déclaration , on doit indiquer l’espace a réserver en mémoire pour le stockage de la chaîne

Une chaine de char ne contient pas que des lettres, une chaine de char doit impérativement contenir un char spécial \0 qui marque la fin de la chaine

Malheureusement le compilateur C ne contrôle pas si on a réservé un octet pour le symbole de fin de chaine, l ’erreur sera remarqué lors de l’exécution du programme

Ch8 : Les chaînes de caractères�

Manipulation

Ex. :

Pour stocker le mot bonjour il faut déclarer un tableau d’une taille au minimum 8

char chaine[8] = ‘’bonjour’’;

Lire/Ecrire une chaine de char

Pour afficher une chaine de char on utilise le symbole %s de la fonction printf

Pour afficher le contenue de chaine on écrira : printf (‘’%s’’, chaine);

Ça va de même pour la lecture scanf(‘’%s’’, &chaine);

Soit en utilisant gets et puts

Gets(chaine);

Puts(chaine);

Ch8 : Les chaînes de caractères�

Travailler sur les char

La bibl. string fournit une multitude de fonctions pratiques pour le traitement des chaînes de char.

La fonction strlen

La fonction strlen fournit en résultat la longueur de la chaine (nombre de char trouvé depuis le début de la chaine jusqu’au premier char de fin de chaine le \0)

Ex :

int taille = strlen(‘’bonjour’’); //taille vaudra 7

Ou bien

Char txt[] = ‘’bonjour’’;

int taille = strlen(txt);

Ch8 : Les chaînes de caractères�

Travailler sur les char

Fonction de concaténation

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " monsieur" ;

printf ("avant : %s\n", ch1) ;

strcat (ch1, ch2) ;

printf ("après : %s", ch1) ;

}

Strcat, prend deux arguments arg1 et arg2, et concatène la valeur de arg2 avec arg1

strcat

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " monsieur" ;

printf ("avant : %s\n", ch1) ;

strncat (ch1, ch2, 6) ;

printf ("après : %s", ch1) ;

}

Strncat(arg1,arg2,lgmax), prend 3 arguments arg1 et arg2 et lgmax offrant en outre un contrôle sur le nombre de caractères qui seront concaténés à la chaîne d’arrivée (arg1)

strncat

Ch8 : Les chaînes de caractères�

Travailler sur les char

Fonction de comparaison

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " monsieur" ;

Int n = strcmp (ch1, ch2) ;

}

Strcmp, compare tous les caractères s’ils sont identiques, elle renvoie 0. Si les caractères de la ch1 sont supérieurs à ceux de la ch2, la fonction renvoie un nombre positif. Si c'est l'inverse, la fonction renvoie un nombre négatif.

strcmp

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " bon" ;

strncat (ch1, ch2, 2) ;

​

}

stricmp ( chaîne1, chaîne2 )

strnicmp ( chaîne1, chaîne2, longeur )

strncmp

Ch8 : Les chaînes de caractères�

Travailler sur les char

Fonction de copie

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " monsieur" ;

strcpy (ch1, ch2) ;

Printf(‘’%s’’,ch1);

}

Strcpy, copy le contenu de le chaine ch2 dans ch1, ATTENTION à la dimension de ch1

strcpy

#include <stdio.h>

#include <string.h>

main()

{

char ch1[50] = "bonjour" ;

char ch2[50] = " monsieur" ;

strncat (ch1, ch2, 2) ;

​

}

limite la recopie au nombre de caractères précisés par l’expression entière longeur (dans notre cas c’est 2)

strncpy

Ch8 : Les chaînes de caractères�

Travailler sur les char

Fonction de recherche dans un chaine

Recherche dans chaîne la première position où apparaît le caractère mentionné

strchr ( chaîne, caractère )

réalise le même traitement que strchr, mais en explorant la chaîne concernée à partir de la

fin. Elle fournit donc la dernière occurrence du caractère mentionné.

strrchr ( chaîne, caractère )

strstr ( chaîne, sous-chaîne )

recherche, dans chaîne, la première occurrence complète de la sous-chaîne mentionnée

Ch8 : Les chaînes de caractères�

Travailler sur les char

Conversion d’une chaîne en valeur numérique

Il existe trois fonctions permettant de convertir une chaîne de char, en valeur numérique de type int, long et double

atoi( chaîne)

fournit un résultat de type int

atol ( chaîne)

fournit un résultat de type long

atof ( chaîne)

fournit un résultat de type double

Les fonctions de <ctype>

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

Ch8 : Les chaînes de caractères�

Travailler sur les char

Les fonctions de <ctype>

Ch8 : Les chaînes de caractères�

Tableau de chaîne de caractère

Pour mémoriser une suite de mots ou de phrases dans des variables. Il est pratique de créer un tableau de chaînes de caractères, ce qui allégera les déclarations des variables et simplifiera l'accès aux différents mots 

Déclaration

Char jour[7][10]

7

Chaînes de caractères

10 caractères par chaînes

char JOUR[7][9]= {"lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"};

Ch8 : Les chaînes de caractères�

Tableau de chaîne de caractère

int I = 2;

printf("Aujourd'hui, c'est %s !\n", JOUR[I]);

JOUR[I] : représentent l'adresse du premier élément d'une chaîne de caractères. N'essayez donc pas de 'modifier' une telle adresse par une affectation directe !

Sol :

Utilisez la fonction strcpy 🡪 strcpy(JOUR[I], ‘’votre chaine’’);

Ch9 : Les pointeurs�

Introduction

Le nom d’une variable, permet d’accéder directement à la valeur de cette variable

Le nom de la variable nous permet d’accéder à la valeur de la variable 🡪 Adressage directe

Int N;

N = 5

Si nous ne voulons ou ne pouvons pas utiliser le nom d'une variable N, nous pouvons copier l'adresse de cette variable dans une variable spéciale P, appelée 

pointeur. Ensuite, nous pouvons retrouver l'information de la variable N en passant par le pointeur P 🡪 Adressage indirecte

Soit N une variable contenant la valeur 5 et P un pointeur qui contient l'adresse de N. En mémoire, N et P peuvent se présenter comme suit:

10E3

40A5

N

P

10E3

Ch9 : Les pointeurs�

Les pointeurs

Un pointeur est une variable spéciale qui peut contenir l'adresse d'une autre variable.

Lors du travail avec les pointeurs on aura besoin de :

• D’un opérateur ‘’adresse de : &’’; pour obtenir l’@ d’une variable
• D’un opérateur ‘’ contenu de : * ‘’; pour accéder au contenue de l’@
• D’une syntaxe de déclaration pour pouvoir déclarer le pointeur

type *Identificateur

Ex. : int *p;

@

5

P

A

P = &A

@A

5

P

A

50

B

P = &A;

B = *P;

*P = 20;

• P pointe sur A,
• le contenu de A (référencé par *P) est affecté à B
• le contenu de A (référencé par *P) est mis à 20.

5

20

Ch9 : Les pointeurs�

Les opérations élémentaires sur pointeurs

Si un pointeur P pointe vers une variable A, alors *P désigne le contenue de la case vers laquelle le pointeur P pointe (càd le contenue de A)

Si on a P = &X

Ch9 : Les pointeurs�

Les tableaux et pointeurs

• Relation étroite entre les pointeurs et les tableaux;
• Manipulation des tableaux se fait par leur adresse

element_i = adresse_base + i * Taille_Type

int T[10];

T[2] = T + 2 * 4

Adresse du 1^er élément du tableau (&T[0])

L’indice de élément dont on veut chercher la valeur

Taille des entier en octet

60FE3C – 60FE34 = 8 octet

Ch9 : Les pointeurs�

Les tableaux et pointeurs

Conversion des tableaux en pointeur

P point sur le 1^er élément du tableau, alors p+1 pointe sur la composante suivante.

*(p+i) 🡪 T[i]

*(p+1) = 20 🡪 T[1] = 20

Int T

• T : désigne l'adresse de la première composante de T;
• T[i] : désigne le contenu de la composante i du tableau ;
• &T[i] : désigne l'adresse de la composante i du tableau

En utilisant le formalise pointeur :

• P = T;
• P + i : désigne l'adresse de la composante i de T;
• *(P + i) : désigne le contenu de la composante i du tableau

Ch9 : Les pointeurs�

Excercice

main() {

int A = 1; int B = 2; int C = 3;

int *P1, *P2;

P1=&A;

P2=&C;

*P1=(*P2)++;

P1=P2;

P2=&B;

*P1-=*P2;

++*P2;

*P1*=*P2;

A=++*P2**P1;

P1=&A;

*P2=*P1/=*P2;

return 0; }

�

�

Ch10 : Les fonctions�

introduction

La structuration de programmes en sous-programmes se fait en C à l'aide de fonctions

Une fonction exécute des actions et renvoie un résultat. C'est un morceau de code qui sert à faire quelque chose de précis. On dit qu'une fonction possède des I/O

1. L’entrée : on fait rentrée des informations (généralement des variables) pour le traitement

Nous avons déjà utilisé des fonctions prédéfinies dans des bibliothèques standard (printf de <stdio>, strlen de <string>, pow de <math>, etc.)

2. Traitement : Grâce aux Entrée la fonction fait le traitement

3. Résultat : Une fois le traitement terminée la fonction retourne un résultat ou pas

Ch10 : Les fonctions�

Modularisation de programmes

Pourquoi ?

Exemple :

Supposant qu’on veut réaliser un programme qui affiche un rectangle d’étoile de longueur L et hauteur H.

Meilleurs lisibilité – Diminution des risques d’erreurs - possibilité de tests sélectifs – Réutilisation – Simplicité d’entretien - …

Ch10 : Les fonctions�

Les fonctions

Les variables déclarées au début de la fonction principale main

ne sont pas des variables globales, mais elles sont locales à main !

Déclaration d’une fonction

TypeRetour NomFonction(parametres)

{

INSTRUCTIONS

return type_retour //généralement une variable ou un résultat de calcule

}

Variable globale

Ch10 : Les fonctions�

Modularisation de programmes

Ch10 : Les fonctions�

Paramètre d’une fonction

Les arguments d'une fonction sont des données de l'extérieur et déterminent les actions et le résultat de la fonction. Techniquement, nous pouvons résumer le rôle des paramètres en C de la façon suivante:

Les paramètres d'une fonction sont simplement des variables locales qui sont initialisées par les valeurs obtenues lors de l'appel.

Lors d'un appel, le nombre et l'ordre des paramètres doivent nécessairement correspondre aux indications de la déclaration de la fonction. Les paramètres sont automatiquement convertis dans les types de la déclaration avant d'être passés à la fonction.

Void tracerRec(int L, double H);

En C, le passage des paramètres se fait toujours par la valeur, �c.-à-d. les fonctions n'obtiennent que les valeurs de leurs paramètres et n'ont pas d'accès aux variables elles-mêmes.

Ch10 : Les fonctions�

Passage de l’adresse d’une variable

Pour changer la valeur de la variable il faut procéder comme suit :

• la fonction appelante doit fournir l'adresse de la variable et
• la fonction appelée doit déclarer le paramètre comme pointeur.

Void permuter (int A, int B)

{

int tmp;

tmp = A;

A=B;

B=tmp;

}

Int maint()

{

int X = 10;

Int Y = 20;

permuter(X,Y);

Printf (‘’X = %d, Y = %d’’,X,Y)

}

Ch10 : Les fonctions�

Passage de l’adresse d’une variable

Pour pouvoir modifier le contenue de X et Y on doit procéder comme suit :

Void permuter (int *A, int *B)

{

int tmp;

tmp = *A;

*A=*B;

*B=tmp;

}

Int maint()

{

int X = 10;

Int Y = 20;

permuter(&X,&Y);

Printf (‘’X = %d, Y = %d’’,X,Y)

}

Ch10 : Les fonctions�

Passage de l’adresse d’un tableau à une dimension

Comme il est impossible de passer 'la valeur' de tout un tableau à une fonction, on fournit l'adresse d'un élément du tableau

Déclaration :

Type nom[] Ou bien Type *nom

Ex :

Int calcSommeTab(int *note)

int strlen(char *S) {

int N;

for (N=0; *S != '\0'; S++)

N++;

return N;

}

La fonction LIRETAB lit N données pour un tableau (unidimensionnel) du type int et les mémorise à partir de l'adresse indiquée par le pointeur PTAB. PTAB et N sont fournis comme paramètres

void LIRE_TAB(int N, int *PTAB)

{

printf("Entrez %d valeurs : \n", N);

while(N) {

scanf("%d", PTAB++);

N-- }

}

Ch10 : Les fonctions�

Exercice

Ecrire un programme se servant d'une fonction MOYENNE du type float pour afficher la moyenne arithmétique de deux nombres réels entrés au clavier

Ecrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum de deux nombres réels.

Ecrire un programme se servant des fonctions MIN et MAX pour déterminer le minimum et le maximum de quatre nombres réels entrés au clavier.

Ch11 : Les fichiers

introduction

Un fichier est un ensemble structuré de données stocké en général sur un support externe

Dans des fichiers séquentiels, les enregistrements sont mémorisés consécutivement dans l'ordre de leur entrée et peuvent seulement être lus dans cet ordre

Comment pouvons-nous relier le nom d'un fichier sur un support externe avec les instructions qui donnent accès au contenu du fichier ?

Fichier Séquentiel

1 - On appelle la fonction d'ouverture de fichier fopen qui nous renvoie un pointeur sur le fichier.

2 - On vérifie si l'ouverture a réussi (c'est-à-dire si le fichier existait) en testant la valeur du pointeur qu'on a reçu. Si le pointeur vaut NULL, c'est que l'ouverture du fichier n'a pas fonctionné, dans ce cas on ne peut pas continuer.

4 -Une fois qu'on a terminé de travailler sur le fichier, il faut le fermer avec la fonction fclose.

3 - Si l'ouverture a fonctionné (pointeur différent de NULL ), alors on peut lire et écrire dans le fichier à travers des fonctions.

Ch11 : Les fichiers

Le Type FILE*

Pour pouvoir travailler avec un fichier, un programme a besoin d'un certain nombre d'informations :

- adresse de la mémoire tampon,

- position actuelle de la tête de lecture/écriture,

- type d'accès au fichier: écriture, lecture, ...

• ….

Ces informations sont regroupées dans FILE

Créer et afficher un fichier séquentiel

FILE* fopen( const char* nomDuFichier, const char* modeOuverture);

Le nom du fichier à ouvrir

Mode d’ouverture (Lecture ou Ecriture)

Ch11 : Les fichiers

Le Type FILE*

File_pointer = fopen(‘’test.txt’’, ‘’r’’)

Si un fichier existant est ouvert en écriture, alors son contenu est perdu.

Ouverture d’un fichier

File_pointer = fopen(‘’test.txt’’, ‘’w’’)

||

" r" : lecture seule.

​

"w" : écriture seule.

​

"a" : mode d'ajout. Vous écrirez dans le fichier. Si le fichier n'existe pas, il sera créé.

​

"r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier.

​

"w+" : lecture et écriture, avec suppression du contenu au préalable.. Si le fichier n'existe pas, il sera créé.

​

"a+" : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la fin du fichier. Si le fichier n'existe pas, il sera créé.

Ch11 : Les fichiers

Le Type FILE*

Le pointeur  File_pointer devrait contenir l'adresse de la structure de type FILE qui sert de descripteur de fichier. Celui-ci a été chargé en mémoire par la fonction fopen().

Tester l’ouverture d’un fichier

FILE* fichier = NULL;

fichier = fopen("test.txt", "r+");

if (fichier != NULL)

{

}

else

{

// On affiche un message d'erreur

printf("Impossible d'ouvrir le fichier test.txt");

}

Tester la fermeture d’un fichier

int fclose(FILE* pointeurSurFichier);

0 : Si la fermeture a marché

EOF : Si la fermeture a échoué

Ch11 : Les fichiers

Lire & Ecrire dans les fichiers séquentiels

Nous pouvons utiliser quasiment les mêmes fonctions que pour l'écriture, le nom change juste un petit peu :

• fgetc : lit un caractère ;
• fgets : lit une chaîne ;
• fscanf : lit une chaîne formatée.

Lire depuis un fichier

char* fgets(char* chaine, int nbreDeCaracteresALire, FILE* pointeurSurFichier);

Ch11 : Les fichiers

Lire & Ecrire dans les fichiers séquentiels

Il existe plusieurs fonctions capables d'écrire dans un fichier. Ce sera à vous de choisir celle qui est la plus adaptée à votre cas.�Voici les trois 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,

Ecrire dans un fichier

char* fputs(const char* chaine, FILE* pointeurSurFichier);

Ch11 : Les fichiers

Le Type FILE*

Ch11 : Les fichiers

Le Type FILE*

Ch11 : Les fichiers

Se déplacer dans un fichier

Chaque fois que vous ouvrez un fichier, il existe en effet un curseur qui indique votre position dans le fichier

Il existe trois fonctions :

​

• ftell : indique à quelle position vous êtes actuellement dans le fichier ;

​

• fseek : positionne le curseur à un endroit précis ;

​

• rewind : remet le curseur au début du fichier.

ftell :

long ftell(FILE* pointeurSurFichier);

Cette fonction est très simple à utiliser. Elle renvoie la position actuelle du curseur sous la forme d'un long, le nombre renvoyé indique donc la position du curseur dans le fichier.

Ch11 : Les fichiers

Se déplacer dans un fichier

fseek :

int fseek(FILE* pointeurSurFichier, long deplacement, int origine);

La fonction fseek permet de déplacer le curseur d'un certain nombre de caractères (indiqué par deplacement) à partir de la position indiquée par origine

SEEK_SET : indique le début du fichier ;

​

SEEK_CUR : indique la position actuelle du curseur ;

​

SEEK_END : indique la fin du fichier.

Le code suivant place le curseur deux caractères après le début :

fseek(fichier, 2, SEEK_SET);

​

Le code suivant place le curseur quatre caractères avant la position courante :

fseek(fichier, -4, SEEK_CUR);

​

Le code suivant place le curseur à la fin du fichier :

fseek(fichier, 0, SEEK_END);

Ch11 : Les fichiers

Renommer/Supprimer un fichier

fseek :

int fseek(FILE* pointeurSurFichier, long deplacement, int origine);

La fonction fseek permet de déplacer le curseur d'un certain nombre de caractères (indiqué par deplacement) à partir de la position indiquée par origine

SEEK_SET : indique le début du fichier ;

​

SEEK_CUR : indique la position actuelle du curseur ;

​

SEEK_END : indique la fin du fichier.

Le code suivant place le curseur deux caractères après le début :

fseek(fichier, 2, SEEK_SET);

​

Le code suivant place le curseur quatre caractères avant la position courante :

fseek(fichier, -4, SEEK_CUR);

​

Le code suivant place le curseur à la fin du fichier :

fseek(fichier, 0, SEEK_END);

Ch11 : Les fichiers

Récapitulatif

FILE *FP;

FP = fopen("C:\\main.c", "r");

if (!FP)// CE IF PERMET DE TESTER SI LE FICHIER A ÉTÉ BIEN OUVERT

char* fputs(const char* chaine, FILE* pointeurSurFichier);

while (!feof(FP)) // PERMET DE PARCOURIR LE FICHIER JUSQU’À SA FIN

Ch12 : Les types avancées

Structure

Le langage C nous permet de créer nos propres types de variables

Créer et utiliser une structure

Une structure est en fait un regroupement de variables, de n'importe quels types, ainsi une structure peut contenir des variables de type int, char, double, ...�Contrairement aux tableaux qui eux obligent aux éléments de ce tableau d'être tous du même type

Tout d'abord il faut savoir qu'il est préférable de créer une structure en dehors d'une fonction car l'avantage des structures c'est qu'elles permettent un accès à leurs attributs (= sous-variables qu'elles contiennent) qui s'étend sur toutes les fonctions du programme.�Ainsi si vous créez une structure dans une fonction, seule celle-ci y'aura accès.

Ch12 : Les types avancées

Structure

struct MaStructure {

int var1;

long var2;

double varN;

};

struct MaStructure {

int var1 = 10;

long var2 = 40000;

double varN = 12.5;

};

struct personne�{�char nom[20];�char prenom[20];�int no_employe;�} p1,p2;�

struct personne p = {« Bentajer", « Ahmed", 1234};�

Ch12 : Les types avancées

Structure

Accès aux membres des structures�

Pour designer un membre d'une structure, il faut utiliser l'operateur de sélection de membre qui se note . (point)�

struct personne�{�char nom[20];�char prenom[20];�int no_employe;�} p1,p2;�

P1.nom

​

P1.nom[2]

​

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

Printf(‘%c’, p1.nom[i]);�

Ch12 : Les types avancées

Structure

Accès aux membres des structures�

Pour designer un membre d'une structure, il faut utiliser l'operateur de sélection de membre qui se note . (point)�

struct personne�{�char nom[20];�char prenom[20];�int no_employe;�} p1,p2;�

P1.nom

​

P1.nom[2]

​

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

Printf(‘%c’, p1.nom[i]);�

Aucune comparaison n'est possible sur les structures, même pas les operateurs == et !=.

Ch12 : Les types avancées

Structure

Tableaux de structures

Une déclaration de tableau de structures se fait selon le même modèle que la déclaration d'un tableau don t les éléments son t de type simple.

struct personne t[100];

T[i].nom

Pour référencer le nom de la personne qui a l'index i dans t on écrira�

Ch12 : Les types avancées

Structure

Pointeurs & structures

struct personne *p;

P = &p1

*p désigne la structure pointée. Pour afficher le nom de la personne on aurait recours a *p.nom

Mais il faut savoir que les operateurs d’indirection (*) et de sélection (.) ont eux aussi un ordre de priorité. (l’indirection a une priorité inferieur a celle de la sélection)

*p.nom sera interprété comme * (p.nom) Cela aurait un sens si p était une structure dont un des membres s'appelait nom et était un pointeur.

​

Dans ce cas il faut ecrire *(p).nom ou p->nom

Ch12 : Les types avancées

Structure

Passage d’une structure en paramètre

struct date�{�int jour,mois,annee;�};

Pour ecrire une fonction qui compare deux dates

int cmp_date( struct date d1, struct date d2)�{

….

}�

Ch13 : Les Piles et Files

Piles

Le principe des piles en programmation est de stocker des données au fur et à mesure les unes au-dessus des autres pour pouvoir les récupérer plus tard.

EMPILER

DEPILER

algorithme LIFO,

Ch13 : Les Piles et Files

Piles

Implémentation :

L’implémentation des Piles se base sur un tableau P de n éléments.

Le tableau possède un élément sommet qui indique le dernier élément inséré.

La pile se constitue des éléments P[1..sommet] où P[1] est l'élément de base de la pile (le plus ancien) et P[sommet] est l'élément situé au sommet (le plus récent).�

Ch13 : Les Piles et Files

Piles

Traitement

Quand P[sommet] = 0 🡪 La pile est vide

Fonction PileVide(P){

if P[sommet] = 0;

return true;

else

return false;

}

Si P[sommet] > n 🡪 Pile déborde.

Dépiler une PILE vide provoque une erreur

Ch13 : Les Piles et Files

Piles

Ch13 : Les Piles et Files

Files

Le principe des files en programmation est de stocker des données au fur et à mesure les unes au-dessus des autres pour pouvoir les récupérer plus tard.

1

4

3

2

EMFILER

DEFILER

algorithme FIFO,

Ch13 : Les Piles et Files

Files

Implémentation :

La FILE représente une liste linéaire ou :

• Toutes les insertions se font par une extrémité (queue arrière)
• Toutes les extractions se font par l’autre extrémité (avant-tete)

Les FILEs correspondent aux Files d’attente : 1^er arrive 1^er servi

Ch13 : Les Piles et Files

Piles

Opération sur les FILES

Les FILEs possèdent un ensemble d’opération qui permettent de les manipuler

• Création d’une FILE,
• Déterminer si la FILE est vide,
• Déterminer si la FILE est pleine,
• Enfiler
• Défiler

​

Ch13 : Les Piles et Files

Files