Informatique 2

Support de cours Classe Préparatoire

2025/2026
Dr Fopa
 Présentation enseignant
Guy Bertrand FOPA
 Doctorat/PhD Informatique
 MBA
 Ingénieur IT
 Consultant en système d’information et
transformation digitale
 Enseignant associé Digital Collège Cameroun
(Université Française Marketing digital)
 Certifié Prince2, Togaf9, CCNA, CCNP, Agile Scrum,
ITIL 4, Marketing Digital, Cybersécurité
 18 années d’expérience au Cameroun et Canada
1- LES CHAÎNES DE CARACTÈRES
Utilisez le type char pour stocker une lettre

Le type char est en fait prévu pour stocker une lettre ! Attention, j'ai
bien dit UNE lettre.
Comme la mémoire ne peut stocker que des nombres, on a
inventé une table qui fait la conversion entre les nombres et les
lettres. Ainsi, cette table indique par exemple que le nombre 65
équivaut à la lettre A.
Le langage C permet de faire très facilement la traduction lettre
<=> nombre correspondant. Pour obtenir le nombre associé à une
lettre, il suffit d'écrire cette lettre entre apostrophes, comme
ceci : 'A' . À la compilation, 'A' sera remplacé par la valeur
correspondante.
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES

int main()
{
char lettre = 'A';

printf("%d\n", lettre);

return 0;
}
1- LES CHAÎNES DE CARACTÈRES

int main()
{
char lettre = 0;
scanf("%c", &lettre);
printf("%c\n", lettre);
return 0;
}
1- LES CHAÎNES DE CARACTÈRES

int main()
{
char lettre = 0;
scanf("%c", &lettre);
printf("%c\n", lettre);
return 0;
}
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES

Voyez les chaînes comme des tableaux de

type char,
Une chaîne de caractères n'est en fait rien d'autre
qu'un tableau de type Char
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES
Pourquoi faut-il que la chaîne de caractères se termine
par un \0 ?
Tout simplement pour que votre ordinateur sache
quand s'arrête la chaîne ! Le caractère\0permet de
dire : "Stop, c'est fini, y'a plus rien à lire après,
circulez !".
Par conséquent, pour stocker le mot "Salut" (qui
comprend 5 lettres) en mémoire, il ne faut pas un
tableau de 5 char, mais de 6 :
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES
1- LES CHAÎNES DE CARACTÈRES

Une chaîne de caractères est un tableau de caractères

se terminant par le caractère spécial ’\0’ (qui a 0 pour
code ASCII).
1- LES CHAÎNES DE CARACTÈRES

Le caractère ’\0’ sert à repérer la fin de la chaîne, évitant d’avoir à connaître

le nombre de caractères de la chaîne. On peut ainsi passer une chaîne de
caractères en paramètre à une fonction, sans avoir besoin de passer un
deuxième paramètre contenant le nombre de caractères.

/* ******* version allocation statique ******** */

char chaine[100];
 1- Les STRUCTURES

Une structure est un assemblage de variables qui peuvent avoir

différents types.
Contrairement aux tableaux qui vous obligent à utiliser le même
type dans tout le tableau, vous pouvez créer une structure
comportant des variables de
types long , char , int et double à la fois. Une structure
est composée de plusieurs champs, chaque champ correspondant à une donnée.
 1- Les STRUCTURES

Exemple
Voici la déclaration d’une structure Point qui contient
trois champs x, y et z de type float.
struct point { /* déclaration de la structure */
float x,y; /* trois champs x, y, z */
float z;
};

La déclaration d’une variable de type struct point se fait

ensuite comme pour une autre variable :
struct point P; /* Déclaration d’une variable P */
 1- Les STRUCTURES

UTILISATION D’UNE STRUCTURE

Une fois la variable déclarée, on accède aux données x,y,z du point P
par un point.
Ces données sont désignées dans le programme par P.x,P.y,P.z. Ces
données P.x,P.y,P.z, ici de type float, sont traitées comme n’importe
quelle autre donnée de type float dans le programme.
Notons que l’on pourrait rajouter d’autres données des types que l’on
souhaite à la suite des données x,y,z dans la structure. Voici un
exemple de programme avec une structure point.
 1- Les STRUCTURES
UTILISATION D’UNE STRUCTURE
#include <stdio.h>
struct point
{
float x,y,z;
}; /* ne pas oublier le point-virgule */
int main(void)
{
struct point P;
puts("Veuillez entrer les coordonnées d’un point 3D :");
scanf("%f %f %f", &P.x, &P.y, &P.z);
puts("L’homothétie de centre O et de rapport 3");
printf("appliquée à ce point donne :’’);
printf("(%.2f, %.2f, %.2f)\n", 3*P.x, 3*P.y, 3*P.z);
return 0;
}
 1- Les STRUCTURES

Pour éviter la répétition du mot struct, lors de la déclaration des variables

de type struc point, on peut définir un raccourci par un typedef lors de la
définition de la structure, pour donner un nouveau nom à ce type :
 1- Les STRUCTURES
#include <stdio.h>
typedef struct point
{ /* déclaration de la structure */
float x,y,z;
}Point3D;
/* la fonction suivante prend un Point3D en paramètre */
void Affiche(Point3D P)
{
/* Affichage des champs : */
printf("(%f, %f, %f)", P.x, P.y, P.z);
}
/* la fonction suivante retourne la structure */
Point3D SaisiePoint3D(void)
{
Point3D P; /* variable de type Point3D */
printf("Entrez trois coordonnées séparées par des espaces\n");
scanf("%f %f %f", &P.x, &P.y, &P.z); /* saisie des champs */
return P; /* on retourne la variable */
}
 1- Les STRUCTURES

Point3D Addition(Point3D P1, Point3D P2)

{
Point3D resultat;
resultat.x = P1.x + P2.x; /* calcul des coordonnées */
resultat.y = P1.y + P2.y; /* accès aux champs par un . */
resultat.z = P1.y + P2.z;
return resultat; /* la fonction retourne la structure */
}
 1- Les STRUCTURES
int main(void)
{
Point3D p1, p2, add;
printf("Entrez les coordonnées de deux points");
p1 = SaisiePoint3D(); /* on récupère la structure saisie */
p2 = SaisiePoint3D();
add = Addition(p1,p2); /* appel de la fonction addition */
printf("L’addition vaut : ");
Affiche(add);
printf("\n");
return 0;
}
 1- Les STRUCTURES
Typedef struct Personne{
char nom[100];
char prenom[100];
char adresse[100];
int age;
int etudiant; // Booléen : 1 = etudiant, 0 = non etudiant
} Personne;
int main()
{ Personne utilisateur;
printf("Quel est votre nom ? ");
scanf("%s", [Link]);
printf("Votre prenom ? ");
scanf("%s", [Link]);
printf("Vous vous appelez %s %s", [Link],
[Link]);
return 0;
}
 1- Les STRUCTURES

Personne joueurs[2];
 Exercices

Exo1

Définir une structure Nombre Rationnel permettant de coder un nombre

rationnel, avec numérateur et dénominateur. On écrira des fonctions de
saisie, d’affichage, de multiplication et d’addition de deux rationnels.
Pour l’addition, pour simplifier, on ne cherchera pas nécessairement le
plus petit dénominateur commun.
 Exercices

Exo2
Un grossiste en composants électroniques vend quatre types de produits :
• Des cartes mères (code 1) ;
• Des processeurs (code 2) ;
• Des barettes mémoire (code 3) ;
• Des cartes graphiques (code 4).
Chaque produit possède une référence (qui est un nombre entier), un prix en euros et
des quantités disponibles.
a) Définir une structure Produit qui code un produit.
b) Écrire une fonction de saisie et d’affichage des données d’un produit.
c) Écrire une fonction qui permet à un utilisateur de saisir une commande d’un
produit. L’utilisateur saisit les quantités commandées et les données du produit.
L’ordinateur affiche toutes les données de la commande, y compris le prix.
 Exercices

Exo3
Créez un programme de gestion d'étudiants avec :
• Une structure Etudiant contenant (nom, prénom, âge,
moyenne)
• Créer un tableau de 10 étudiants
• Le programme demande à l’utilisateur de saisir les données
d'un étudiant
• Compte le nombre d’étudiants dont la moyenne est ≥ 15
 3- Les Pointeurs
Analysez le schéma de la mémoire vive

Chaque cellule a un numéro, c'est son adresse.

La mémoire comporte un grand nombre d'adresses,
commençant à l'adresse numéro 0 et se terminant à
l'adresse numéro (insérez un très grand nombre ici).
Le nombre d'adresses disponibles dépend en fait de la
quantité de mémoire dont dispose votre ordinateur.

À chaque adresse, on peut stocker UN SEUL nombre (et

votre mémoire ne peut stocker ni des lettres, ni des
phrases).
 3- Les Pointeurs
Rappelez-vous comment faire afficher la valeur d'une variable
Quand vous créez une variable age de type int en
tapant ceci :
Int age =10;

Votre programme demande au système d'exploitation

(Windows, par exemple) la permission d'utiliser un peu de
mémoire. Le système d'exploitation répond en indiquant à quelle
adresse en mémoire il vous laisse le droit d'inscrire votre
nombre.
 3- Les Pointeurs
Revenons à notre variable age. La valeur 10 a été inscrite quelque part en mémoire,
disons par exemple à l'adresse n° 4655.
Ce qu'il se passe (et c'est le rôle du compilateur), c'est que le mot age dans votre
programme est remplacé par l'adresse 4655 à l'exécution. Cela fait que, à chaque fois
que vous avez tapé le mot age dans votre code source, il est remplacé par "4655", et
votre ordinateur voit ainsi à quelle adresse il doit aller chercher en mémoire ! Du coup,
l'ordinateur se rend en mémoire à l'adresse 4655, et répond fièrement : "La
variable age vaut 10".
On sait donc comment récupérer la valeur de la variable : il suffit de taper age dans son
code source. Si on veut afficher l'âge, on peut utiliser la fonction printf :

printf("La variable age vaut : %d", age);

 3- Les Pointeurs
Faites afficher l'adresse d'une variable
Pour afficher l'adresse de la variable, on doit :
[Link] le symbole%p (le p du mot « pointeur »)
dans le printf .
[Link] à la fonction printf non pas la
variable age , mais son adresse… Et pour faire
cela, vous devez mettre le symbole & devant la
variable age
printf("L'adresse de la variable age est : %p",
&age);
 3- Les Pointeurs

Eh bien en fait, je veux vous faire retenir ceci :

•age désigne la valeur de la variable ;
•&age désigne l'adresse de la variable.
Avec age , l'ordinateur lit la valeur de la variable en
mémoire et vous renvoie cette valeur.
Avec &age , votre ordinateur vous dit en revanche à quelle
adresse se trouve la variable.
 3- Les Pointeurs

Utilisez des pointeurs

Jusqu'ici, nous avons uniquement créé des variables
faites pour contenir des nombres. Maintenant, nous
allons apprendre à créer des variables faites pour
contenir des adresses : ce sont justement ce qu'on
appelle des pointeurs.
 3- Les Pointeurs

Créez un pointeur et donnez-lui une valeur par défaut

Pour créer une variable de type pointeur, on rajoute le symbole * devant le
nom de la variable.

int *monPointeur;
Notez qu'on peut aussi écrire int* monPointeur; . Cela
revient exactement au même.

Cependant, la première méthode est à préférer. En effet, si vous voulez

déclarer plusieurs pointeurs sur la même ligne, vous serez obligé de
mettre l'étoile devant le nom :int *pointeur1, *pointeur2,
*pointeur3;
 3- Les Pointeurs

Pour initialiser un pointeur, c'est-à-dire lui donner une valeur

par défaut, on n'utilise généralement pas le nombre 0 mais le
mot-clé NULL (veillez à l'écrire en majuscules) :

int *monPointeur = NULL;

Ce code va réserver une case en mémoire comme si vous aviez
créé une variable normale.
Cependant, et c'est ce qui change, la valeur du pointeur est faite
pour contenir une adresse. L'adresse… d'une autre variable.
Vous savez maintenant comment indiquer l'adresse d'une
variable (au lieu de sa valeur) en utilisant le symbole &
 3- Les Pointeurs

int age = 10;

int *pointeurSurAge = &age;

[Link] première ligne signifie : "Créer une variable de type int dont la valeur
vaut 10".
[Link] seconde ligne signifie : "Créer une variable de type pointeur dont la
valeur vaut l'adresse de la variable age ". La seconde ligne fait donc deux
choses à la fois. Si vous le souhaitez, pour ne pas tout mélanger, sachez
qu'on peut la découper en deux temps :
 3- Les Pointeurs

int age = 10;

int *pointeurSurAge; // 1) signifie "Je crée un pointeur«
pointeurSurAge = &age; // 2) signifie "pointeurSurAge
contient l'adresse de la variable age"
 3- Les Pointeurs

on doit indiquer le type de variable pour laquelle le pointeur va contenir

l'adresse.
Comme notre pointeur pointeurSurAge va contenir l'adresse de la
variable age (qui est de type int ), alors mon pointeur doit être de
type int* !
Si ma variable age avait été de type double , alors j'aurais dû
écrire double *monPointeur .
Vocabulaire : on dit que le pointeur pointeurSurAge pointe sur la
variable age
 3- Les Pointeurs
Dans ce schéma :
•la variable age a été placée à l'adresse 177450 (vous
voyez d'ailleurs que sa valeur est 10) ;
•et le pointeur pointeurSurAge a été placé à l'adresse 3
(c'est tout à fait le fruit du hasard).

Lorsque mon pointeur est créé, le système

d'exploitation réserve une case en mémoire
comme il l'a fait pour age . La différence ici,
c'est que la valeur de pointeurSurAge est
un peu particulière. Regardez bien le schéma :
c'est l'adresse de la variable age !
3- Les Pointeurs

int age = 10;

int *pointeurSurAge = &age;
printf("%d", pointeurSurAge);
printf("%d", &age);
printf("%d", age);
printf("%d", &pointeurSurAge);

En fait, cela n'est pas très étonnant. On demande la valeur

de pointeurSurAge , et sa valeur, c'est l'adresse de la
variable age
3- Les Pointeurs
int age = 10;
int *pointeurSurAge = &age;
printf("%d", *pointeurSurAge);

En plaçant le symbole * devant le nom du pointeur, on

accède à la valeur de la variable age . Si au contraire on
avait utilisé le symbole & devant le nom du pointeur, on
aurait obtenu l'adresse à laquelle se trouve le pointeur
3- Les Pointeurs
 Exo de base Pointeurs

int main(){
int A = 10;
int *p;
p = &A;
printf("Valeur : %d", *p);
return 0;
}
 Exo de base Pointeurs

int main(){
int X = 5;
int *ptr = &X;
*ptr = *ptr + 10;
printf("X = %d", X);
return 0; }
 Exo de base Pointeurs

int main(){
int n = 20;
int *p1 = &n;
int *p2; p2 = p1;
*p2 = 50;
printf("n = %d", n);
return 0;
}
 Exo de base Pointeurs

int main(){
int tab[2] = {100, 200};
int *p = tab;
printf("%d", *(p + 1));
return 0; }
 Exo de base Pointeurs

void modifier(int *a) {

*a = 0;
}
int main(){
int b = 99;
modifier(&b);
printf("b = %d", b);
return 0;
}
 Exo de base Pointeurs

int main(){
char *str = "Hello";
printf("%c", *(str + 1));
return 0;
}
Pointeurs et index de tableaux
Un nom de tableau sans les crochets est un pointeur vers le
premier élément du tableau.
Par conséquent, vous pouvez accéder au premier élément de
ce tableau avec l’opérateur
indirect (*). Si tab[] est un tableau, l’expression *tab
représente le premier élément de
ce tableau, *(tab+1) est le deuxième élément, etc. En
généralisant, nous obtenons les
relations suivantes :
Pointeurs et index de tableaux
*(tab) == tab[0]
*(tab+1) == tab[1]
*(tab+2) == tab[2]
etc.
*(tab+n) == tab[n]
Pointeurs et index de tableaux
Supposons, par exemple, que l’on effectue la déclaration suivante
:
int t[10]
La notation t est alors totalement équivalente à &t[0].
L’identificateur t est considéré comme étant de type pointeur sur
le type correspondant aux éléments du tableau, c’est-à-dire, ici,
int *. Ainsi, voici quelques exemples de notations
équivalentes :
t+1 &t[1]
t+i &t[i]
t[i] * (t+i)
 4- Manipulez des chaînes à l'aide de fonctions

La bibliothèque string.h fournit de nombreuses fonctions dédiées aux

calculs sur des chaînes.
Je vais vous présenter les principales :
[Link] pour calculer la longueur d'une chaîne.
[Link] pour copier une chaîne dans une autre.
[Link] pour concaténer 2 chaînes.
[Link] pour comparer 2 chaînes.
[Link] pour rechercher un caractère.
[Link] pour rechercher le premier caractère de la liste.
[Link] pour rechercher une chaîne dans une autre.
[Link] pour écrire dans une chaîne.
 4- Manipulez des chaînes à l'aide de fonctions
[Link] pour calculer la longueur d'une chaîne.
strlen (pour "string length") est une fonction qui calcule la longueur d'une
chaîne de caractères (sans compter le caractère\0 ) :

int main(int argc, char *argv[])

{ char chaine[] = "Salut";
int longueurChaine = 0; // On récupère la longueur de la
chaîne dans longueurChaine
longueurChaine = strlen(chaine); // On affiche la longueur de
la chaîne
printf("La chaine %s fait %d caracteres de long", chaine,
longueurChaine);
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
2. Copiez une chaîne dans une autre avec strcpy
La fonction strcpy(pour "string copy") permet de
copier une chaîne à l'intérieur d'une autre.
Voici son prototype :
int main(int argc, char *argv[]){
/* On crée une chaîne "chaine" qui contient un peu de texte et une
copie (vide) de taille 100 pour être sûr d'avoir la place pour la copie */
char chaine[] = "Texte", copie[100] = {0};
printf("copie vaut : %s\n", copie);
strcpy(copie, chaine); // On copie "chaine" dans "copie"
// Si tout s'est bien passé, la copie devrait être identique à chaine
printf("chaine vaut : %s\n", chaine);
printf("copie vaut : %s\n", copie);
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
3. Concaténez deux chaînes avec strcat

La fonction strcat (pour "string catenate") ajoute une

chaîne à la suite d'une autre. On appelle cela la
concaténation.

int main(int argc, char *argv[]){

/* On crée 2 chaînes. chaine1 doit être assez grande pour accueillir le
contenu de chaine2 en plus, sinon risque de plantage */
char chaine1[100] = "Salut ", chaine2[] = "Mateo21";
strcat(chaine1, chaine2); // On concatène chaine2 dans chaine1 // Si tout
s'est bien passé, chaine1 vaut "Salut Mateo21"
printf("chaine1 vaut : %s\n", chaine1); // chaine2 n'a pas changé :
printf("chaine2 vaut toujours : %s\n", chaine2);
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
4. Comparez deux chaînes avec strcmp
strcmp (pour "string compare") compare 2 chaînes entre elles.
Voici son prototype :

int main(int argc, char *argv[]){

char chaine1[] = "Texte de test", chaine2[] = "Texte de test";
if (strcmp(chaine1, chaine2) == 0) // Si chaînes identiques
{ printf("Les chaines sont identiques\n");

} else
{ printf("Les chaines sont differentes\n");
}
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
Recherchez un caractère avec strchr
La fonction strchr recherche un caractère dans une chaîne.
Voici son prototype :

int main(int argc, char *argv[]){

char chaine[] = "Texte de test", *suiteChaine = NULL;
suiteChaine = strchr(chaine, 'd');
if (suiteChaine != NULL) // Si on a trouvé quelque chose
{ printf("Voici la fin de la chaine a partir du premier d :
%s", suiteChaine);
}
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
Recherchez le premier caractère d'une liste avec strpbrk
Cette fonction recherche un des caractères dans la liste que vous lui
donnez sous forme de chaîne, contrairement à strchr qui ne peut
rechercher qu'un seul caractère à la fois.
int main()
{ char *suiteChaine; // On cherche la première occurrence de x, d ou s dans
"Texte de test"
suiteChaine = strpbrk("Texte de test", "xds");
if (suiteChaine != NULL)
{ printf("Voici la fin de la chaine a partir du premier des caracteres trouves :
%s", suiteChaine);
}
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
Recherchez une chaîne dans une autre avec strstr
La fonction strstr (pour "string string") recherche la première
occurrence d'une chaîne dans une autre chaîne.

int main(int argc, char *argv[])

{ char *suiteChaine;
// On cherche la première occurrence de "test" dans "Texte de test" :
suiteChaine = strstr("Texte de test", "test");
if (suiteChaine != NULL)
{ printf("Premiere occurrence de test dans Texte de test : %s\n",
suiteChaine);
}
return 0;
}
 4- Manipulez des chaînes à l'aide de fonctions
Écrivez dans une chaîne avec sprintf

Cette fonction se trouve dans stdio.h , contrairement aux autres fonctions que
nous avons étudiées jusqu'ici, qui étaient dans string.h .
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{ char chaine[100];
int age = 15; // On écrit "Tu as 15 ans" dans chaine
sprintf(chaine, "Tu as %d ans !", age);
// On affiche chaine pour vérifier qu'elle contient bien cela :
printf("%s", chaine);
return 0;
}
 Excercices

Exo 1 :Écrire un programme en C qui lit une chaîne de

caractères au clavier et compte le
nombre d’espaces contenus dans cette chaîne.
 ALLOCATION DYNAMIQUE

GESTION DE LA MÉMOIRE CENTRALE

Jusqu’à maintenant, le nombre des éléments d’un tableau était
limité par une constante (en général définie dans un #define). Dans
cette partie, nous verrons comment créer un tableau en cours de
programme, la taille de ce tableau pouvant être donnée par une
variable, et résulter d’un calcul ou être saisie par l’utilisateur.
L’outil pour faire cela est l’allocation dynamique de mémoire.
Cette technique permet de créer des tableaux dont la taille mémoire
est variable en fonction des besoins, et de libérer cette mémoire
après utilisation. On obtient ainsi des programmes plus performants
en termes de consommation de mémoire.
 ALLOCATION DYNAMIQUE

Pour créer un tableau en cours d’exécution du programme, il faut

réserver un emplacement dans la mémoire centrale. Le
programmeur indique la taille de l’emplacement mémoire (en gros
le nombre d’octets), et, lors de l’exécution du programme, le
système réserve un emplacement mémoire et donne l’adresse de cet
emplacement. Cette opération s’appelle l’allocation dynamique de
mémoire.
 ALLOCATION DYNAMIQUE

Les fonctions d’allocation en C sont les fonctions malloc

et calloc. On parle d’allocation dynamique parce que
l’allocation de mémoire a lieu à mesure des besoins, par
opposition à l’allocation statique de tableaux étudiée
ALLOCATION AVEC malloc
La fonction malloc alloue un certain nombre d’octets, c’est-à-dire
qu’elle réserve des octets pour une utilisation par le programme. Le
nombre d’octets est passé en paramètre à la fonction malloc. La
fonction malloc retourne l’adresse du premier octet réservé. On
mémorise cette adresse dans un pointeur.
ALLOCATION AVEC malloc
Pour calculer le nombre total d’octets nécessaires à un
tableau, on utilise la fonction sizeof qui donne le nombre,
d’octets nécessaires à une variable de type float, int, char,
etc. et on multiplie par le nombre d’éléments du tableau.
Après utilisation de la mémoire, la mémoire doit
impérativement être libérée avec la fonction free. Celle-ci
prend en paramètre l’adresse du bloc mémoire qui doit être
libéré. Lors de l’appel à free, la mémoire est rendue au
système qui peut la réemployer pour une autre utilisation.
ALLOCATION AVEC malloc
#include <stdio.h>
#include <stdlib.h>
int main() {
int n, i;
int *tableau;
// Demander à l'utilisateur combien de valeurs il veut entrer
printf("Entrez le nombre d'entiers à stocker : ");
scanf("%d", &n);
// Allocation dynamique avec malloc
tableau = (int *)malloc(n * sizeof(int));

// Vérification si l'allocation a réussi

if (tableau == NULL) {
printf("Échec de l'allocation mémoire.\n");
return 1; // Quitter le programme avec une erreur
}
ALLOCATION AVEC malloc
// Saisie des valeurs dans le tableau
printf("Entrez %d entiers :\n", n);
for (i = 0; i < n; i++) {
printf("Entier %d : ", i + 1);
scanf("%d", &tableau[i]);
}

// Affichage des valeurs

printf("\nLes entiers saisis sont :\n");
for (i = 0; i < n; i++) {
printf("tableau[%d] = %d\n", i, tableau[i]);
}
// Libération de la mémoire
free(tableau);
return 0;
}
ALLOCATION AVEC calloc
La fonction calloc, comme la fonction malloc, alloue un
emplacement mémoire et retourne l’adresse du premier octet. La
syntaxe des deux fonctions diffère légèrement. La fonction calloc
prend deux paramètres, le nombre d’éléments et le nombre d’octets
de chaque élément. La fonction calloc, contrairement à malloc,
initialise tous les octets à 0.
#include <stdio.h>
#include <stdlib.h>

int main() {
int n, i;
int *tableau;
// Demande à l'utilisateur combien d'entiers il veut stocker
printf("Entrez le nombre d'entiers à allouer : ");
scanf("%d", &n);
// Allocation dynamique avec calloc
tableau = (int *)calloc(n, sizeof(int));
// Vérifie si l'allocation a réussi
if (tableau == NULL) {
printf("Échec de l'allocation mémoire.\n");
return 1;
}
// Affichage des valeurs initialisées (par défaut à 0)
printf("\nValeurs initiales dans le tableau (grâce à calloc) :\n");
for (i = 0; i < n; i++) {
printf("tableau[%d] = %d\n", i, tableau[i]);
}
// Saisie des valeurs par l'utilisateur
printf("\nEntrez %d entiers :\n", n);
for (i = 0; i < n; i++) {
printf("Entier %d : ", i + 1);
scanf("%d", &tableau[i]);
}

// Affichage des valeurs saisies

printf("\nLes entiers saisis sont :\n");
for (i = 0; i < n; i++) {
printf("tableau[%d] = %d\n", i, tableau[i]);
}

// Libération de la mémoire
free(tableau);

return 0;
}
•calloc(n, size) alloue et initialise à zéro un bloc de
mémoire.
•Comparé à malloc, calloc évite d’avoir des valeurs
indéterminées au départ.
LES FICHIERS

Dans un ordinateur, il y a principalement deux sortes de mémoire : la

mémoire centrale et la mémoire disque. Les données stockées en
mémoire centrale sont les variables des différents programmes et ne
durent que le temps de l’exécution d’un programme. Les tableaux
stockent les données en mémoire centrale. Pour mémoriser des données
de manière permanente, il faut les stocker sur un disque (ou un
périphérique tel qu’une clef USB).
LES FICHIERS

Un fichier est une série de données stockées sur un disque ou dans un

périphérique de stockage. Un fichier texte est un fichier qui contient du
texte AS CII.
On appelle lecture dans un fichier le transfert de données du fichier vers
la mémoire centrale. La lecture dans un fichier texte est analogue à la
lecture au clavier : le texte vient du fichier au lieu de venir du clavier.
LES FICHIERS

On appelle écriture dans un fichier le transfert de données de la mémoire

centrale vers le fichier. L’écriture dans un fichier texte est analogue à
l’écriture à l’écran : le texte va dans le fichier au lieu de s’afficher.
OUVERTURE ET FERMETURE D’UN FICHIER TEXTE

Pour pouvoir utiliser les fichiers texte, on doit inclure la bibliothèque d’entrées sorties :
#include<stdio.h>
Pour lire ou écrire dans un fichier texte, nous avons besoin d’un pointeur de fichier. Le
pointeur de fichier nous permet de désigner le fichier dans lequel nous souhaitons lire
ou écrire. Un pointeur de fichier est de type FILE *. On déclare un tel pointeur comme
toute autre variable :
FILE *fp; /* déclaration d’un pointeur de fichier fp */
OUVERTURE ET FERMETURE D’UN FICHIER TEXTE

Avant de pouvoir écrire ou lire dans le fichier, il faut lier le pointeur de fichier à un
fichier sur le disque. On appelle cette opération l’ouverture du fichier. L’ouverture se
fait avec la fonction fopen, qui prend en paramètre le nom du fichier sur le disque.
OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
Prenons le cas de l’ouverture d’un fichier en lecture, c’est-à-dire qu’on ouvre le
fichier uniquement pour pouvoir lire des données dedans.

FILE *fp;
fp = fopen("[Link]","r");
/* (exemple de chemin relatif : répertoire local) */

FILE *fp;
fp = fopen("C:\\remy\\algo\\[Link]","r");
/* (exemple de chemin absolu sous Windows) */

Le premier paramètre est le nom du fichier, ou plus exactement le chemin vers le fichier
dans l’arborescence des répertoires.
Le deuxième paramètre de la fonction fopen est le mode, et "r" signifie “fichier ouvert en
lecture seule”.
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
Les différents modes possibles pour un fichier texte sont :
• "r" : mode lecture seule. Le fichier est ouvert à son début prêt à lire les données.
Toute tentative d’écriture dans le fichier provoque une erreur de segmentation.
• "w" : mode écriture seule. Le fichier est initialement vide. Si le fichier existait déjà
avant l’appel de fopen, il est écrasé et les données qui se trouvaient dans le fichier
sont perdues. Après l’appel de fopen, le fichier est prêt pour l’écriture de données.
Toute tentative de lecture provoque une erreur de segmentation.
• "a" : mode ajout. Le fichier n’est pas écrasé mais est prêt à écrire à la suite des
données existantes. Toute tentative de lecture provoque une erreur de segmentation.
• "r+" : mode lecture-écriture. Le fichier est prêt pour lire et écrire au début du
fichier. Le fichier n’est pas écrasé.
• "w+" : mode lecture-écriture. Le fichier est écrasé.
• "a+" : mode lecture-écriture. Le fichier n’est pas écrasé mais est prêt pour écrire à
la suite des données existantes.
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE

La fonction fopen retourne le pointeur NULL en cas d’erreur d’ouverture de fichier

(fichier inexistant, erreur dans le nom de fichier, ou permissions, en lecture, écriture,
selon le cas, insuffisantes pour accéder au fichier au niveau du système). Le pointeur
NULL est très souvent utilisé comme code d’erreur pour les fonctions retournant un
pointeur.
Après avoir utilisé un fichier, il faut le refermer en utilisant fclose. La fonction
fclose prend en paramètre le pointeur de fichier et ferme le fichier.
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fichier;
char nomFichier[100];
char texte[500];

// Demander le nom du fichier

printf("Entrez le nom du fichier à créer : ");
scanf("%s", nomFichier);

// Ouvrir le fichier en mode écriture

fichier = fopen(nomFichier, "w");

// Vérifier si le fichier a été ouvert correctement

if (fichier == NULL) {
printf("Erreur lors de l'ouverture du fichier !\n");
return 1;
}
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
// Vider le tampon d'entrée avant d'utiliser fgets
getchar();

// Demander à l'utilisateur le texte à écrire

printf("Entrez le texte à écrire dans le fichier :\n");
fgets(texte, sizeof(texte), stdin);

// Écrire dans le fichier

fprintf(fichier, "%s", texte);

// Fermer le fichier
fclose(fichier);

printf("Données écrites avec succès dans le fichier \"%s\".\n", nomFichier);

return 0;
}
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fichier;
char caractere;

// Ouvrir le fichier en mode lecture ("r")

fichier = fopen("mon_fichier.txt", "r");

if (fichier == NULL) {
printf("Erreur : impossible d'ouvrir le fichier.\n");
return 1; // On retourne une erreur
}
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
printf("Contenu du fichier :\n");

// Lire caractère par caractère jusqu'à la fin du fichier

while ((caractere = fgetc(fichier)) != EOF) {
putchar(caractere);
}

// Fermer le fichier
fclose(fichier);

return 0;
}
OUVERTURE ET FERMETURE D’UN FICHIER TEXTE

•FILE *fichier; : pointeur vers un fichier.

•fopen("mon_fichier.txt", "r"); : ouvre le fichier en lecture.
•fgetc(fichier) : lit un caractère à la fois.
•putchar(caractere); : affiche le caractère lu.
•fclose(fichier); : ferme proprement le fichier.
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE
#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *fichier;
char texte[256];

// Ouvrir le fichier en mode ajout ("a")

fichier = fopen("mon_fichier.txt", "a");

if (fichier == NULL) {
printf("Erreur : impossible d'ouvrir le fichier.\n");
return 1;
}
 OUVERTURE ET FERMETURE D’UN FICHIER TEXTE

printf("Entrez le texte à ajouter au fichier :\n");

fgets(texte, sizeof(texte), stdin); // Lecture d'une ligne de texte

// Écrire le texte dans le fichier

fprintf(fichier, "%s", texte);

// Fermer le fichier
fclose(fichier);

printf("Texte ajouté avec succès !\n");

return 0;
}
 LISTE CHAÎNÉE

Une liste chaînée est un ensemble de cellules liées entre elles par
des pointeurs. Chaque cellule est une structure contenant les champs
suivants :
• une ou plusieurs données comme dans n’importe quelle structure ;
• un pointeur suivant sur la cellule suivante.
 LISTE CHAÎNÉE

On accède à la liste par un pointeur L sur la première cellule, puis en

parcourant la liste d’une cellule à l’autre en suivant les pointeurs
suivants. Le dernier pointeur suivant vaut NULL, ce qui indique la fin de
la liste.
LISTE CHAÎNÉE

DÉCLARER UNE LISTE CHAÎNÉE

Pour créer une liste chaînée, il faut déclarer une nouvelle structure de données : la
structure qui représentera une cellule

typedef struct Cell

{
float donnee; /* définition des données */
/* on peut mettre ce qu’on veut comme donnée */
struct Cell *suivant; /* pointeur sur la structure suivante */
/* (de même type que celle qu’on est en train de définir) */
}TypeCellule;
LISTE CHAÎNÉE

DÉCLARER UNE LISTE CHAÎNÉE

Pour créer une liste chaînée, il faut déclarer une nouvelle structure de données : la
structure qui représentera une cellule

On déclare ensuite le pointeur qui donne l’adresse de la première cellule (NULL

si la liste est vide) :

TypeCellule *L; /* déclaration d’une liste */

LISTE CHAÎNÉE

#include <stdio.h>
#include <stdlib.h>

struct Node {
int data;
struct Node* next;
};

int main() {
// Création des 3 nœuds
struct Node* head = NULL;
struct Node* second = NULL;
struct Node* third = NULL;
LISTE CHAÎNÉE

// Allocation mémoire dynamique pour chaque nœud

head = (struct Node*) malloc(sizeof(struct Node));
second = (struct Node*) malloc(sizeof(struct Node));
third = (struct Node*) malloc(sizeof(struct Node));

// Attribution des données

head->data = 10;
head->next = second;

second->data = 20;
second->next = third;

third->data = 30;
third->next = NULL;
LISTE CHAÎNÉE
// Parcours et affichage de la liste
struct Node* current = head;
printf("Contenu de la liste chaînée : ");
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");

// Libération de la mémoire
free(head);
free(second);
free(third);

return 0;
}
INTRODUCTION LANGAGE C++
INTRODUCTION LANGAGE C++
Le langage C++ n'est en fait rien d'autre que le langage C avec
plusieurs nouveautés. Il s'agit de concepts de programmation
poussés comme la programmation orientée objet, le
polymorphisme, ….
INTRODUCTION LANGAGE C++
Le concepteur
C'est Bjarne Stroustrup, un informaticien originaire du
Danemark, qui a conçu le langage C++. Insatisfait des
possibilités oertes par le C, il a créé en 1983 le C++ en y
ajoutant les possibilités qui, selon lui, manquaient.
INTRODUCTION LANGAGE C++
#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!" << endl;
return 0;
}
Les tableau en C++
#include <iostream>
#include <vector>
using namespace std;

int main() {
int taille;

// Demande la taille du tableau

cout << "Entrez la taille du tableau : ";
cin >> taille;

vector<int> tableau;
Les tableau en C++
// Saisie des éléments du tableau
for (int i = 0; i < taille; i++) {
int valeur;
cout << "Entrez l'élément " << i + 1 << " : ";
cin >> valeur;
tableau.push_back(valeur);
}
// Affichage des éléments avec la méthode .at()
cout << "\nContenu du tableau : ";
for (int i = 0; i < [Link](); i++) {
cout << [Link](i) << " ";
}
cout << endl;
return 0;
}