Sortie attendue
Question 1
Quelle est la sortie du programme suivant ?
#include <stdio.h>
int main(void) {
int x = 210;
int *p = &x;
printf("%d %p %d\n", x, p, *p);
return 0;
}
A) 210 adresse_de_x 210
B) 210 adresse_de_p 210
C) adresse_de_x 210 210
D) Erreur de compilation
Question 2
Quelle est la sortie du code suivant ?
#include <stdio.h>
int main(void) {
char c = 'L', *p = &c;
printf("%c %p %zu\n", *p, p, sizeof(p));
return 0;
}
A) L adresse_de_c 1
B) L adresse_de_c 8
C) adresse_de_c L 8
D) Erreur de compilation
Exercice sur l'arithmétique des pointeurs
Quel sera le résultat affiché par ce programme ?
#include <stdio.h>
int main(void) {
int t[] = {10,20,30,40};
int *p = t + 2;
printf("%d %d\n", *(p - 1), *(p + 1));
return 0;
}
A) 10 30
B) 20 40
C) 20 erreur
D) erreur erreur
Exercice sur les Structures et Pointeurs
Que produit le programme suivant ?
#include <stdio.h>
struct Player {
char fname[20];
int rank;
};
int main(void) {
struct Player p = {"Novak", true};
struct Player *q = &p;
printf("%s %d\n", q->fname, q->active);
return 0;
}
A) Novak true
B) Novak 1
C) Erreur de compilation
D) Djokovic true
Exercice sur les pointeurs et chaînes de caractères :
Quel est l'affichage produit par le programme suivant?
#include <stdio.h>
int main() {
char *s = "linux";
char *p = s + 2;
printf("%c %c\n", *p, *(p - 1));
return 0;
}
A) l i
B) n i
C) n l
D) Erreur d'exécution
Exercice sur les fonctions et pointeurs
Quelle sera la sortie du programme suivant?
#include <stdio.h>
void increment(int *x){
(*x)++;
}
int main() {
int val = 5;
int *ptr = &valeur;
incrementer(ptr);
printf("%d\n", val);
}
void incrementer(int *x){
(*x)++;
}
void solve() {
int x = 10;
incrementer(&x);
printf("%d\n", x);
}
void incrementer(int *y){
(*y)+=5;
}
int main(){
solve();
return 0;
}
A) 10
B) 15
C) Erreur de compilation
D) Erreur d'exécution
Exercice sur les pointeurs et tableaux
Quelle sera la sortie du programme suivant?
#include <stdio.h>
int main() {
int tab[5] = {5,4,3,2,1};
int *ptr = tab + 4;
printf("%d %d\n", ptr[-3], *(ptr - 1));
return 0;
}
A) 2 4
B) 4 2
C) Erreur d'exécution
D) Résultat indéfini
Exercice sur la mémoïsation avec variable statique
Quelle sera la sortie du programme suivant?
#include <stdio.h>
int compteur(){
static int n = 0;
return ++n;
}
int main(){
printf("%d ", compteur());
printf("%d ", compteur());
printf("%d\n", compteur());
return 0;
}
int compteur(){
static int cpt = 0;
return ++cpt;
}
A) 1 1 1
B) 1 2 3
C) 1 erreur erreur
D) Erreur de compilation
Exercice sur les entrées/sorties standard
Quelle sera la sortie si on entre au clavier: "abcDEF" suivi d'entrée?
#include <stdio.h>
#define BUFFER_SIZE 10
int main(void){
char c1=getchar(), c2=getchar(), c3=getchar();
char line[BUFFER_SIZE];
fgets(line, BUFFER_SIZE , stdin);
printf("3 premiers caractères: %c %c %c\n", c1,c2,c3);
printf("Reste de ligne: %s\n", line);
return 0;
}
Exercices de Code sur les Pointeurs en C avec Lignes à
Compléter
Exercice 1 : Manipulation de Base des Pointeurs
Complétez les lignes manquantes pour que ce programme affiche correctement la valeur,
l'adresse et le résultat de différentes opérations sur un entier via un pointeur.
#include <stdio.h>
int main() {
int nombre = 42;
int *ptr;
// Complétez cette ligne pour que ptr pointe vers nombre
ptr = /* À compléter */;
printf("Valeur de nombre: %d\n", nombre);
printf("Adresse de nombre: %p\n", &nombre);
printf("Valeur stockée dans ptr: %p\n", ptr);
// Complétez cette ligne pour modifier la valeur de nombre via ptr
/* À compléter */ = 100;
printf("Nouvelle valeur de nombre: %d\n", nombre);
// Complétez cette ligne pour déclarer et initialiser un second pointeur qui
pointe vers ptr
/* À compléter */;
printf("Valeur via double pointeur: %d\n", **ptr2);
return 0;
}
Exercice 2 : Parcours de Tableau avec Arithmétique des Pointeurs
Complétez les sections manquantes pour que ce programme parcoure un tableau en
utilisant uniquement l'arithmétique des pointeurs.
#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};
int *p = tableau;
int sum = 0;
// Complétez cette boucle pour parcourir le tableau en utilisant des pointeurs
// N'utilisez PAS la notation tableau[i]
for (/* À compléter */) {
// Complétez cette ligne pour ajouter chaque élément à la somme
sum += /* À compléter */;
// Complétez cette ligne pour avancer le pointeur
/* À compléter */;
}
printf("Somme des éléments: %d\n", sum);
// Complétez ce code pour afficher les éléments du tableau en ordre inverse
// en utilisant uniquement l'arithmétique des pointeurs
printf("Éléments en ordre inverse: ");
for (/* À compléter */) {
printf("%d ", /* À compléter */);
}
printf("\n");
return 0;
}
Exercice 6 : Manipulation de Fichiers avec Pointeurs
Complétez les lignes manquantes pour créer un programme qui copie le contenu d'un
fichier dans un autre.
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *fichierSource, *fichierDestination;
char nomSource[100], nomDestination[100];
char caractere;
printf("Nom du fichier source: ");
scanf("%s", nomSource);
printf("Nom du fichier destination: ");
scanf("%s", nomDestination);
// Complétez cette ligne pour ouvrir le fichier source en mode lecture
fichierSource = /* À compléter */;
if (fichierSource == NULL) {
printf("Impossible d'ouvrir le fichier source\n");
return 1;
}
// Complétez cette ligne pour ouvrir le fichier destination en mode écriture
fichierDestination = /* À compléter */;
if (fichierDestination == NULL) {
printf("Impossible d'ouvrir le fichier destination\n");
fclose(fichierSource);
return 1;
}
// Complétez cette boucle pour copier caractère par caractère
while (/* À compléter */) {
// Complétez cette ligne pour écrire le caractère dans le fichier destination
/* À compléter */;
}
printf("Copie terminée avec succès!\n");
// Complétez ces lignes pour fermer les fichiers
/* À compléter */;
/* À compléter */;
return 0;
}
Exercice 5 : Allocation Dynamique de Mémoire
Complétez les lignes manquantes pour implémenter une gestion correcte de mémoire
dynamique.
#include <stdio.h>
#include <stdlib.h>
// Complétez cette fonction pour qu'elle alloue dynamiquement un tableau d'entiers
int* creerTableau(/* À compléter */) {
// Complétez cette ligne pour allouer la mémoire
int *tableau = /* À compléter */;
if (tableau == NULL) {
printf("Erreur d'allocation de mémoire\n");
exit(1);
}
return tableau;
}
// Complétez cette fonction pour qu'elle remplisse le tableau avec des valeurs
void remplirTableau(/* À compléter */) {
for (int i = 0; i < taille; i++) {
// Complétez cette ligne pour assigner des valeurs
/* À compléter */ = i * 2;
}
}
// Complétez cette fonction pour qu'elle libère la mémoire du tableau
void libererTableau(/* À compléter */) {
// Complétez cette ligne pour libérer la mémoire
/* À compléter */;
}
int main() {
int taille;
printf("Entrez la taille du tableau: ");
scanf("%d", &taille);
// Complétez cette ligne pour créer le tableau
int *monTableau = /* À compléter */;
remplirTableau(monTableau, taille);
printf("Contenu du tableau: ");
for (int i = 0; i < taille; i++) {
printf("%d ", monTableau[i]);
}
printf("\n");
// Complétez cette ligne pour libérer la mémoire
/* À compléter */;
return 0;
}
Exercice 4 : Utilisation de Pointeurs de Fonctions
Complétez les lignes manquantes pour implémenter un système utilisant des pointeurs de
fonctions.
#include <stdio.h>
// Fonctions d'opérations mathématiques
int addition(int a, int b) { return a + b; }
int soustraction(int a, int b) { return a - b; }
int multiplication(int a, int b) { return a * b; }
int division(int a, int b) { return b != 0 ? a / b : 0; }
// Complétez la définition du tableau de pointeurs de fonctions
/* À compléter */ operations[4] = {/* À compléter */};
// Complétez cette fonction qui applique une opération sur chaque paire d'éléments des
tableaux
void appliquerOperation(int *tableau1, int *tableau2, int *resultat, int taille, /* À
compléter */) {
for (int i = 0; i < taille; i++) {
// Complétez cette ligne pour appliquer l'opération aux éléments
correspondants
resultat[i] = /* À compléter */;
}
}
int main() {
int t1[4] = {10, 20, 30, 40};
int t2[4] = {2, 5, 3, 8};
int resultat[4];
char *noms_operations[4] = {"Addition", "Soustraction", "Multiplication",
"Division"};
for (int i = 0; i < 4; i++) {
// Complétez cette ligne pour appeler appliquerOperation avec la bonne
fonction
appliquerOperation(t1, t2, resultat, 4, /* À compléter */);
printf("%s: ", noms_operations[i]);
for (int j = 0; j < 4; j++) {
printf("%d ", resultat[j]);
}
printf("\n");
}
return 0;
}
Exercice : Recherche d'Erreurs
Analysez et corrigez le code suivant qui contient plusieurs erreurs liées aux
pointeurs:
#include <stdio.h>
#include <stdlib.h>
int main() {
int *p;
*p = 10;
int *tab = malloc(5);
for(int i = 0; i <= 5; i++) {
tab[i] = i*2;
}
printf("Valeur: %d\n", *tab[2]);
return 0;
}
Exercice : Manipulation de Fichiers
Écrivez un programme qui utilise des pointeurs de fichier (FILE*) pour lire un fichier
texte ligne par ligne et compter le nombre de mots. Gérez correctement les erreurs
d'ouverture de fichier.
Exercice : Fonction qsort
Utilisez la fonction qsort de la bibliothèque standard pour trier un tableau d'une
structure personnalisée (par exemple, des étudiants avec nom et note). Implémentez la
fonction de comparaison nécessaire.
Exercice 1 : Déclaration et Déréférencement
Écrivez un programme C qui déclare un entier et un pointeur vers cet entier.
Initialisez l'entier avec une valeur, puis affichez à l'écran la valeur de l'entier,
son adresse mémoire, la valeur du pointeur et la valeur obtenue par déréférencement du
pointeur. Le résultat devrait être similaire à l'exemple du cours montrant la relation
entre une variable et son pointeur.
Exercice 2 : Manipulation de Valeurs via Pointeurs
Écrivez un programme C qui lit deux entiers saisis par l'utilisateur à l'aide de
pointeurs (comme dans l'exemple du PANDACODEUR). Utilisez ces pointeurs pour calculer
la somme, la différence, le produit et le quotient des deux nombres, puis affichez les
résultats.
Exercice 3 : Conversion de Qualificateurs
Écrivez un programme qui démontre les différentes conversions de pointeurs avec le
qualificatif const . Créez un pointeur en lecture seule ( const int *p ) et un pointeur
constant ( int *const q ) et montrez comment le compilateur réagit lorsque vous essayez
de modifier les valeurs ou les pointeurs eux-mêmes.
Arithmétique des Pointeurs
Exercice 4 : Traversée de Tableau
Écrivez un programme qui déclare un tableau d'entiers et utilise l'arithmétique des
pointeurs pour parcourir et afficher les éléments du tableau. N'utilisez pas la
notation d'indice ( tableau[i] ) mais uniquement des opérations de pointeurs ( *
(pointeur + i) ou *pointeur++ ).
Exercice 5 : Comparaison de Pointeurs
Créez un programme qui démontre l'utilisation des opérateurs de comparaison sur les
pointeurs. Déclarez un tableau et plusieurs pointeurs pointant vers différentes
positions du tableau, puis utilisez les opérateurs == , != , < , > , <= et >= pour
comparer ces pointeurs. Affichez les résultats de ces comparaisons.
Exercice 6 : Arithmétique et Tailles des Types
Écrivez un programme qui démontre comment l'arithmétique des pointeurs prend en compte
la taille du type pointé. Créez trois pointeurs de types différents ( char , int ,
double ) et montrez comment l'incrémentation de chaque pointeur modifie son adresse
en fonction du type.
Fonctions et Pointeurs
Exercice 7 : Fonction d'Échange (Swap)
Implémentez une fonction swap qui échange les valeurs de deux variables de
différents types ( int , char , double ) en utilisant des pointeurs. Cette fonction
devrait fonctionner avec n'importe quel type de données en utilisant des pointeurs
génériques ( void* ).
Exercice 8 : Mémoïsation avec Variables Statiques
Implémentez une fonction récursive qui calcule le nombre de Fibonacci avec
mémoïsation, comme montré dans l'exemple du PDF. Comparez les performances avec une
version sans mémoïsation en mesurant le temps d'exécution pour calculer F(40) .
Exercice 9 : Pointeurs de Fonctions
Créez un programme qui utilise des pointeurs de fonctions pour appliquer différentes
opérations mathématiques (addition, soustraction, multiplication, division) sur deux
nombres. Implémentez une fonction map générique comme dans l'exemple du PDF qui
applique une fonction passée en paramètre à chaque élément d'un tableau.
Structures et Pointeurs
Exercice 10 : Adresses dans une Structure
Créez une structure Point avec des coordonnées x et y , puis écrivez un programme
qui affiche les adresses de chaque champ de la structure. Illustrez l'utilisation de
l'opérateur -> avec un pointeur vers cette structure.
Exercice 11 : Liste Chaînée Simple
Implémentez une liste chaînée simple avec des opérations de base (insertion,
suppression, affichage). Utilisez une structure Node qui contient une donnée et un
pointeur vers le nœud suivant.
Gestion de la Mémoire
Exercice 12 : Allocation Dynamique d'un Tableau
Écrivez un programme qui demande à l'utilisateur la taille d'un tableau, puis alloue
dynamiquement un tableau d'entiers de cette taille. Remplissez-le avec des valeurs,
affichez-les, puis libérez correctement la mémoire.
Exercice 13 : Détection d'Erreurs de Pointeurs
Créez délibérément plusieurs programmes contenant des erreurs courantes liées aux
pointeurs (déréférencement de pointeur NULL , déréférencement de pointeur non
initialisé, accès hors limites, etc.). Utilisez des outils de débogage pour identifier
ces erreurs.
Entrées/Sorties et Pointeurs
Exercice 14 : Manipulation de Fichiers avec Pointeurs
Écrivez un programme qui utilise des pointeurs de fichier ( FILE* ) pour lire un
fichier texte ligne par ligne et compter le nombre de mots. Utilisez les fonctions de
la bibliothèque stdio.h vues dans le cours.
Exercice 15 : Implémentation de qsort
Utilisez la fonction qsort de la bibliothèque standard pour trier un tableau d'une
structure personnalisée (par exemple, des étudiants avec nom et note ). Implémentez
la fonction de comparaison nécessaire.
Exercices Avancés
Exercice 16 : Implémentation de bsearch
Créez un programme qui utilise bsearch pour rechercher un élément dans un tableau
trié. Comparez les performances avec une recherche linéaire classique sur des tableaux
de dif
