1. Les Pointeurs :

1.1. Un peu de théorie :

1.2. Le type pointeur :

• Le type d'un pointeur :
  Le type d'un pointeur est donné explicitement par l'objet pointé. Si a est un entier et pa son pointeur lors, pa est de type pointeur d'entier.
  
  
• Opérateur &
  C'est un opérateur unaire, il s'applique à tout objet pouvant être en partie gauche d'une affectation. Il renvoie l'adresse du premier octet de l'objet, attention &(&x) n'a pas de sens.
  
  
• Opérateur *
  C'est l'opérateur d'indirection, s'applique sur un pointeur et renvoie l'objet situé à l'adresse indiquée par le pointeur (en tenant compte de sa taille). Notez que *(&a) et a désigne le même objet.
  
  
• Déclaration de pointeur :
  Pour déclarer un entier vous faites int a ? ce qui signifie : a est un entier codé sur 2 octets. Avec les pointeurs c'est équivalent, pour déclarer un pointeur vous écrirez int *pa, ce qui signifiera *pa est un entier codé sur 2 octets donc pa est un pointeur d'entier sur 2 octets.
  
  Notez que dans un cas il y'a un * et dans l'autre non. Une autre façon de voir les choses est de dire qu'a int le type entier, on associe (int *) le type pointeur d'entier. Comme pour le déclaration habituelle, il n'y a que réservation de la mémoire et non-initialisation.
  Il est bien-sûr possible d'avoir des pointeurs de pointeurs :
  int x,*px;
  int * *ppx;
  
  
  
• Manipulations des pointeurs :
  Le mieux est encore de prendre un exemple
  
  int x,y,*px;
  x=0;
  y=1;
  p=&x;
  y=*p;
  *p=*p+10;
  
  
  A votre avis que vaut x, y ? et sur quoi pointe p ? pour le savoir exécutez le programme suivant :
  

  #include <stdio.h>
  
  int main (void)
  
  {
  
  int x,y,*p;
  
  x=0;
  
  y=1;
  
  p=&x;
  
  y=*p;
  
  *p=*p+10;
  
  printf("\n la variable x vaut %d", x);
  
  printf("\n la variable y vaut %d", y);
  
  if (*p== x ) { printf("\n le pointeur p contient l'adresse de x\n");}
  
  else { printf("\n le pointeur p contient l'adresse de y\n");}
  
  return(1);
  
  }
  
  

  
  
• Opérations sur les pointeurs :
  • NULL est une valeur constante de pointeur qui signifie que le pointeur ne pointe vers rien. Il est possible de faire p=NULL. A la déclaration, tous les pointeurs contiennent NULL.
    
  • 
    Il est possible affecter la valeur d'un pointeur à un autre pointeur du même type :
    
    int x,*q,*p;
    p=&x;
    q=p;
    
    
    
  • 
    Mais cela est impossible entre pointeurs de types différents, pour cela il faut convertir explicitement l'un des types :
    
    long x,*px;
    char *pc;
    px=&x;
    pc = (char *)px;
    
    
    
  • 
    De même, il est impossible d'affecter une valeur entière à un pointeur, car un pointeur est de type pointeur de quelques choses. Néanmoins, en utilisant une conversion explicite on y parvient :
    
    long *px;
    px = (long *) 0x43; #en notation hexadecimale
    
    
    
  • 
    Il est possible en revanche d'incrémenter la valeur d'un pointeur, mais attention rajouter 1 à un pointeur d'entier sur 4 octets, augmente sa valeur de 4 octets. Idem pour la soustraction.
    
    
  • 
    Il est également possible de comparer les valeurs de pointeurs :
    
    point1 ==(int *) 0x80;
    *point2 == 15;
    point3 <= point4;
    
    
    
  • 
    S'il n'est pas possible de déclarer des variables de type void , il est en revanche possible de déclarer des variables de type pointeur de void. Ces pointeurs ne sont pas déréférençables, mais sont compatibles (sans besoin de conversion explicite) avec tous les types pointeurs.
    
    
  
  

1.3. Pointeur et tableau :

&(Tab[ i ]) équivaut à Tab + i

Tab[ i ] équivaut à *(Tab+i)

&(Tab[0]) équivaut à Tab

1.4. Pointeur de structure :

1.5. Allocation dynamique de la mémoire :

• malloc(taille) : retourne un pointeur sur un espace mémoire reservé de taille : "taille" ou bien NULL si la demande ne peut être satisfaite.
  
• calloc(nbre_objet,taille) : retourne un pointeur sur un espace mémoire réservé à un tableau de "nbre_objet" de taille "taille". Ou bien NULL si la demande ne peut être satisfaite.
  
• free(pointeur) : libère l'espace pointé par p mais ne fait rien si p vaut NULL.
  

#include <stdio.h>

#include <stdlib.h>

int main (void)

{

int *pointeur;

printf("\n Allocation dynamique de la mémoire ...");

pointeur=(int *) malloc (sizeof(int));

printf("\n On teste l'allocation ...");

if (pointeur==NULL) {printf("\n Pb d'allocation !"); exit(1);}

printf("\n Allocation reussie !");

*pointeur= 10;

printf("\n Libération de la mémoire ... \n");

free(pointeur);

return(1);

} 

2. Les Entrées/Sorties :

#include <stdio.h>

#include <string.h>



int main (void)

{



struct {

char nom[20];

char prenom[20];

} fiche;

FILE *fichier;/* fichier est le nom local du fichier */

fichier=fopen("data.txt","r");/* initialisation de fichier, qui représentera, le

fichier data.txt ouvert en lecture */

/*Vérification d'usage */

if(fichier==NULL){printf("Pb d'ouverture de fichier"); exit(1);}

printf("Liste des noms et prénoms ...");

while (!feof(fichier))/* tant qu'on n'est pas à la fin du fichier */

{

/* on récupère le nom et le prénom de l'individu

et les stockent dans une structure */

fscanf(fichier,"%s %s", &fiche.nom, &fiche.prenom);

/* Aussitôt on l'affiche à l'écran */

printf("%s %s \n", fiche.nom, fiche.prenom);

fflush(stdout);/* forcer l'écriture à l'écran */

}

fclose(fichier);/* on ferme le fichier */

return(1);

}

• fichier :
  Il s'agit d'un pointeur de fichier c'est à partir de lui que je manipule le fichier data.txt.
  
  
• fopen :
  C'est la fonction qui me permet d'ouvrir un fichier, vous indiquez d'abord le chemin relatif vers le fichier, puis le mode d'ouverture. w : création ou réinitialisation, r : lecture, a : création ou ajout en fin de fichier. Comme il s'agit d'une allocation dynamique, il convient de vérifier qu'elle s'est bien terminée.
  
  
• feof(fichier)
  Renvoie 0 si on est en fin de fichier et un autre entier après la première tentative de lecture au-delà de la fin.
  
  
• fscanf
  fscanf(fichier,"format",&arg) et fprintf(fichier,"format",arg) sont les équivalents de fscanf("format",&arg) et fprintf("format",arg) mais pour les fichiers. Leur utilisation est exactement la même. Le champ fichier permet de spécifier quel fichier est manipulé.
  
  
• fflush
  fflush(stdout) force l'écriture à l'écran, pour fichier j'aurais mis fflush(fichier).
  
  
• fclose(fichier)
  Ferme fichier.