2.3.1- Qu'est ce qu'un pointeur ? Declaration et utilisation

Un pointeur est une variable particulière, c'est une variable qui contient une adresse de variable dans la mémoire vive. La mémoire vive est divisée en emplacemens d'un octet numérotés séquentiellement :

Numérotation des emplacements ->	34	35	36	37	38	39	40
	10100001	10111011	01010101	10110001

Dans le tableau représentant la mémoire vive, on a mis une variable codé sur 4 entiers. C'est par exemple un entier long. Dans ce cas, On dira que l'adresse de la variable long est 34. Les adresses sont codées sous forme hexadécimale. Soit une adresse apparaîtra comme 0x22ff74 par exemple.
Pour voir apparaître une adresse :

#include <iostream>

int main()
	{
	int a;
	std::cout << &a; 	
	return 0;
	}

Opérateur &

Pour obtenir l'adresse d'une variable, on utilise l'opérateur &. Soit le code suivant :

#include 

int main()
	{
	int i=0;
	std::cout << "L'adress de i : " << &i;
	}

Déclarer une variable pointeur : *

Soit la déclaration suivante :

int *a=0;

Ce code déclare a non pas comme une variable entière, mais comme un pointeur sur un entier de type int. Donc a recevra l'adresse d'une variable de type int. On peut tester la taille réservée à un pointeur en mémoire vive :

int *a;
std::cout << "La taille pour socker un pointeur : " << sizeof(a);

On constate qu'un pointeur est stocké sur 4 octets. Noter : 2^4*8=16⁸, cf le fait que l'on présente les adresses codées sur 8 hexadécimaux. Il est bon de déclarer les variables pointeurs en les indexant par p, et donc, pour l'exemple précédent, de déclarer int *pA; Ceci permet de distinguer les variables.

Dangers de la manipulation des pointeurs

Comme un pointeur est une variable, il a un espace dédié en mémoire. Lors de sa déclaration, ce qui est stocké à cet espace est imprévisible. La valeur de la variable, ie l'adresse stockée est donc imprévisible. On risque de produire une erreur grave en utilisant l'adresse stockée, par exemple en modifiant le contenu stocké à cette adresse. En effet, l'information contenue à cette adresse peut être fondamentale pour le fonctionnement du système d'exploitation. Pour éviter ce type de désagrement majeur, une bonne habitude consiste à affecter une valeur au pointeur dès sa déclaration. Deux solutions pour affecter une valeur à un pointeur : soit on affecte le pointeur nul, soit on affecte l'adresse d'une variable.

double x=7;
double *pteur1=0;
double *pteur2=&x;
std::cout << pteur1 << " et " << pteur2;

Indirection

L'indirection consiste à accéder la valeur contenue à l'adresse enregistrée dans un pointeur. On parle aussi de déréferencement d'un pointeur. Dans le cas d'une variable standard, recupérer son contenu n'est pas difficile :

double y;
double x=7;
y=x;

double y;
double x=7;
double *pZ=&x;
y=*pZ;

double x=5;
double *pX=&x;
*pX=7;
cout << "La valeur de x : " << x;

double x=5;
double *pX;
pX=&x;
*pX=7;
cout << "La valeur de x : " << x;

double x=5;
double *pX;
*pX=7;
cout << "La valeur de x : " << x;

Usage des pointeurs

Les pointeurs sont utilisés :

• Passer des variables par référence à des fonctions


• Accéder aux données membres et aux fonctions de classes


• Gérer les données dans l'espace mémoire adressable, on peut mettre en place des listes chainées par exemple.

Les usages seront développés et exemplifiés plus tard.

2.3.2- Création dynamique d'objet

new et delete

void methode1()
	{
	Action a();
	int j;
		for(int i=0;i<7;i++)
		{
		Action a2();
		int j2;
		}
	}

void variation(Action a,int j)
	{
	....
	}

int main()
	{
	Action a;
	variation(&a,5);
	}

void variation(Action *a,int j)
	{
	....
	}

int main()
	{
	Action *a;
	a=new Action();
	variation(a,5);
	}

void variation(Action *a,int j)
	{
	....
	}

Action *a=new Action();
delete a;

int i=0;
int j=5;
Action *a=new Action(i,j);

Les types primitifs

int *pInt;
pInt=new int;

int *pInt=new int;

delete pInt;

#include 

class A{
      public : 
        int k;
        double e;
	A(int i,int j);
	void doubleK();
};

A::A(int j,int a)
        {
	k=j;        
        e=a; 
	}

void A::doubleK()
	{
	k=k*2;
	}
         
int main()
	{
    A *varA=new A(5,7);
    std::cout << sizeof(A) << "\n";
    std::cout << sizeof(int);
    }

Forme d'acces

varA->k=5;
varA->doubleK();
int j=varA->k;

Destruction

#include 

using namespace::std;

class A
	{
	public :
	int num;
	~A();
	A(int j);
	donneNum();
	};

A::A(int j)
	{
	num=j;
    	cout << "\nAppel du constructeur de A pour l'objet de num :  " << num;
	}

A::donneNum()
	{
	cout << "\nLe chat de num  " << num;
	}


A::~A()
	{
	cout << "\nAppel du destructeur de A pour l'objet de num :  " << num;
	}

int main()
	{
	cout << "\nCreation de l'objet objA : dans la pile";
	A objA(1);
	cout << "\nOn reserve un espace mémoire pour un objet de type A dans le tas";
	A *pA=new A(5);
	
	delete pA;
	return 0;
	}

class B{
public :
	B();
	~B();
private : 
	int *att1_B;
	int *att2_B;

};

B::B()
	{
	att1_B=new int;
	att2_B=new int
	}

B::~B()
	{
	delete att1_B;
	delete att2_B;
	}

Le pointeur this

#inlcude 
classe Rectangle{
public :
	Rectangle();
	~Rectangle();
	void defLongueur(int longueur);
	int lireLongueur() const;
	void defLargeur(int largeur);
	int lireLargeur() const;
private : 
	int saLongueur;
	int saLargeur;	
};

Rectangle::Rectangle()
	{
	saLargeur=5;
	saLongueur=10;
	}

Rectangle::~Rectangle()
	{
	}

Rectangle::defLongueur(int l)
	{
	this->saLongueur=l;
	}

Rectangle::defLargeur(int l)
	{
	this->saLargeur=l;
	}

int main()
	{
	Rectangle theRect;
	cout << "theRect mesure " << theRect.lireLongueur() << " cm de long.\n";
	cout << "theRect mesure " << theRect.lireLargeur() << " cm de largeur.\n";
	theRect.defLongueur(20);
	theRect.defLargeur(10);
	cout << "theRect mesure " << theRect.lireLongueur() << " cm de long.\n";
	cout << "theRect mesure " << theRect.lireLargeur() << " cm de largeur.\n";
	return 0;
	}

2.3.3- Dangers de la gestion directe de la mémorie

Fuite de mémoire

Réaffecter une valeur à un pointeur alors que celui est l'unique référence d'un espace mémoire fait perdre la référence d'un espace mémoire que la machine considère comme affecté. Par exemple :

int *pX=new int;
pX=new int;

Danger des pointeurs

2.3.4- Tableaux et opérations sur pointeurs

Un tableau

#include 
 
int main()
    {
    int tab[5];
    int *a=tab;
    }

Opérations sur les pointeurs

#include 


         
int main()
	{
    int tab[5];
    int *a=tab;
    
    tab[0]=0;
    tab[1]=1;
    tab[2]=2;
    tab[3]=3;
    tab[4]=4;
    int temp=*(tab+1);
    std::cout << temp;
    }

#include 
    
int main()
	{
    int tab[5];
    int *a=tab;
    
    tab[0]=0; tab[1]=1; tab[2]=2; tab[3]=3; tab[4]=4;
             for(int i=0;i<5;i++)
             std::cout << *(tab+i) << " ";
    std::cout << "\n";
             for(int i=0;i<5;i++)
             std::cout << tab[i] << " ";
    }

Fonctions qui renvoient un pointeur

int *f1()
	{
	}

Pointeur sur pointeur

int **t;