Pointeurs

Exercice 1

  • 1. Déclarer un pointeur sur int et l'initialiser par le pointeur NULL.

  • 2. Déclarer un pointeur sur pointeur sur int.

  • 3. Déclarer une variable de type int.

  • 4. Initialiser le pointeur sur int par l'adresse de cette variable.

  • 5. Initialiser le pointeur sur pointeur sur int par l'adresse du pointeur sur int.

  • 6. Allouer dynamiquement un espace de mémoire suffisant pour contenir une variable de type int, et stocker son adresse dans le pointeur sur int.

Solution

//Q1 :
int * pointeur = NULL;
//Q2 :
int ** pointeurSurPointeur;
//Q3 :
int variable;
//Q4 :
pointeur = &variable;
//Q5 :
pointeurSurPointeur = &pointeur;
//Q6 :
pointeur = malloc(sizeof(int));
//Ou
pointeur = malloc(sizeof( *pointeur ));

Exercice 2

  • 1. Déclarer deux pointeurs sur float .

  • 2. Déclarer deux variables de type float .

  • 3. Initialiser chacun des pointeurs avec les adresses des deux variables float .

  • 4. Affecter la valeur 12.5 à la première variable en utilisant son pointeur.

  • 5. Affecter la valeur 5.76 à la deuxième variable en utilisant son pointeur.

  • 6. Échanger le contenu des deux variables en utilisant leurs pointeurs.

//Q1 :
float * ptr1 , * ptr2 ;
//Q2 :
float variable1 , variable2 ;
//Q3 :
ptr1 = &variable1;
ptr2 = &variable2;
//Q4 :
*ptr1 = 12.5;
//Q5 :
*ptr2 = 5.76;
//Q6 :
float variableIntermediaire;

variableIntermediaire = * ptr1;
*ptr1 = *ptr2;
*ptr2 = variableIntermediaire;

Exercice 3 (problème)

  • Écrire une procédure "permute" qui permet de permuter les valeurs de deux variables entières et écrire un programme dans lequel on saisira deux nombres entiers avant de faire appel a cette procédure et d'afficher le contenue de ces variable afin de vérifier la permutation.

Exercice 4 (problème)

Pointeurs et références(exercice wikipedia).

  • Donner et expliquer le résultat de l'exécution du programme suivant :

#include <stdio.h>
#define taille_max 5
 
void parcours(int *tab)
{
     int *q=tab;
     do
     {
         printf("%d:%d\n", q-tab, *q-*tab);
     }
     while (++q-tab < taille_max);
}
 
void bizarre(int **copie, int *source)
{
     *copie=source;
}
 
int main(void)
{
     int chose[taille_max] = {1,3,2,4,5}, *truc;
     printf("chose : \n");

     parcours(chose);

     bizarre(&truc, chose);

     printf("truc : \n");

     parcours(truc);
 
     return 0;
}

Tableaux unidimensionnels

Exercice 1

  • Déclarer de façon automatique un tableau à 15 variables de type double . Et initialiser ce tableau avec des zéros.

Solution

double tab[15];
int i;

for(i=0 ; i< 15 ; i++)
    tab[i] = 0;

Exercice 2 (problème)

  • Utiliser l'allocation dynamique pour créer un tableau de 15 variables de type float . Initialiser ce tableau avec des zéros, puis libérer la mémoire allouée si l'allocation a été effectuée avec succès.

Exercice 3 (problème)

  • Déclarer un double pointeur sur float , puis utiliser une fonction pour effectuer l'allocation dynamique d'un tableau de 15 variables de type float (de deux façon, par utilisation du retour de la fonction, puis par un passage par référence).

  • Utiliser une fonction pour initialiser ce tableau avec des zéros si l'allocation a été effectuée avec succès.

  • Puis libérer la mémoire allouée toujours si l'allocation a été effectuée avec succès.

Exercice 4 (problème)

  • Ecrire de deux façons différentes, un programme qui vérifie sans utiliser une fonction de <string>, si une chaîne CH introduite au clavier est un palindrome:

  • a) en utilisant uniquement le formalisme tableau

  • b) en utilisant des pointeurs au lieu des indices numériques

Rappel : Un palindrome est un mot qui reste le même qu'on le lise de gauche à droite ou de droite à gauche.

Exemples :

PIERRE : n'est pas un palindrome

OTTO : est un palindrome

23432 : est un palindrome

Exercice 5 (problème)

  • Écrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier et qui ajoute les éléments de B à la fin de A. Utiliser le formalisme pointeur à chaque fois que cela est possible.

Exercice 6 (problème)

  • Écrire un programme qui demande à l'utilisateur de saisir la dimension N d'un tableau T du type int (dimension maximale: 50), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.

  • Calculer et afficher ensuite la somme des éléments du tableau.

  • Copiez ensuite toutes les composantes strictement positives dans un deuxième tableau TPOS et toutes les valeurs strictement négatives dans un troisième tableau TNEG.

  • Afficher les tableaux TPOS et TNEG.

Tableaux multidimensionnels

Exercice 1 (problème)

  • Écrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne en n'utilisant qu'une variable d'aide pour la somme.

Exercice 2 (problème)

  • Écrire un programme qui lit un texte (sur plusieurs lignes) saisi par l'utilisateur (chaque ligne peut avoir un nombre maximal de 100 caractères). La fin de la saisie sera validée par l'entrée d'une ligne vide.

  • Écrire une fonction qui demande à l'utilisateur de saisir un mot, elle recherchera ce mot dans le texte saisi (que nous lui passerons sous forme d'argument) et retourne le numéro de la ligne du premier mot trouvé dans le texte.

En conclusion nous allons donc retenir les choses suivantes :

  • Un pointeur n'est pas un tableau.

  • Un tableau n'est pas un pointeur.

  • Un pointeur doit toujours être initialisé, soit par une allocation dynamique soit en pointant sur une variable.

Ayez également en esprit que les codes les plus simples sont souvent les plus robustes et fiables. Ne cherchez pas automatiquement la solution compliquée, appliquez ce que vous avez appris dans ce cours qui en fin de compte a été rédigé dans un but de vous montrer comment utiliser correctement chaque technique (d'allocation, libération, traitement d'erreur, initialisation...). Définissez vos contraintes de portabilité et de conformité à l'une des normes dés la rédaction de votre cahier des charges, et avancez dans le développement de vos programmes en respectant cette contrainte.

Ainsi vous amoindrirez le risque de bogue, et vous obtiendrez un programme fiable en gestion d'erreurs en ce qui concerne tableaux et pointeurs :) .

Merci pour votre attention, et n'hésitez pas à me faire part de vos remarques.

L'auteur