Tout d'abord, ayons une compréhension préliminaire de quelques points à noter concernant les références et les pointeurs.

  • Une référence n'est pas un objet
  • Une référence doit être initialisée
  • Une référence ne peut être liée qu'à un objet, et ne peut pas être liée à une valeur littérale ou au résultat d'une expression
  • Les types doivent correspondre strictement
int &a = 10;             //错误:引用类型的初始值必须是一个对象  
  
double a = 3.14;  
int &b = a;              //错误:此处引用类型的初始值必须是int型对象

Un pointeur est lui-même un objet

Le type du pointeur doit correspondre strictement à l'objet vers lequel il pointe

double dval;  
double *pd = &dval;      //正确  
double *pd2 = pd;        //正确  
  
int *pi = pd;            //错误:指针pi的类型和pd的类型不匹配  
pi = &dval;              //错误:试图把double型对象的地址赋给int型指针  

Il y a une exception : introduire le qualificateur const

Référence constante

Lors de l'initialisation d'une référence constante, toute expression est autorisée comme valeur initiale

int i = 42;  
const int &r1 = i;       //正确:允许将const int & 绑定到一个普通int对象上  
const int &r2 = 42;      //正确  
const int &r3 = r1 * 2;  //正确  
int &r4 = r1 * 2;        //错误  
  
double dval = 3.14;  
const int &ri = dval;    //正确  
//等价于  
const int temp = dval;  
const int &ri = temp;  
  
int i = 42;  
int &r1 = i;  
const int &r2 = i;  
r1 = 0;                  //正确  
r2 = 0;                  //错误  

Pointeur constant

Définition :Aussi appelé pointeur constant, il peut être compris comme un pointeur vers une constante. C'est-à-dire qu'il s'agit d'un pointeur, mais ce vers quoi il pointe est une constante. Cette constante est la valeur (adresse) du pointeur, et non la valeur pointée par l'adresse.

Points clés :

  • 1. L'objet pointé par un pointeur constant ne peut pas être modifié via ce pointeur, mais il peut toujours être modifié via la déclaration d'origine ;
  • 2. Un pointeur constant peut se voir affecter l'adresse d'une variable ; la raison pour laquelle il est appelé pointeur constant est qu'il restreint la modification de la valeur de la variable via ce pointeur ;
  • 3. Le pointeur peut également pointer ailleurs, car le pointeur lui-même n'est qu'une variable et peut pointer vers n'importe quelle adresse ;
 

Forme du code :

  1. Pointeur vers une constante (const int* ptr): Le contenu pointé par le pointeur est une constante et ne peut pas être modifié via le pointeur. Cependant, le pointeur lui-même (c'est-à-dire l'adresse stockée dans le pointeur) peut être modifié.

  2. Pointeur constant (int* const ptr): Le pointeur lui-même (c'est-à-dire l'adresse stockée dans le pointeur) est une constante et ne peut pas être modifié, mais le contenu pointé par le pointeur peut être modifié.

  3. Pointeur constant vers une constante (const int* const ptr): Le pointeur lui-même (c'est-à-dire l'adresse stockée dans le pointeur) et le contenu pointé par le pointeur sont tous deux des constantes. Ni l'adresse du pointeur ni le contenu pointé ne peuvent être modifiés.

Pointeur constant

Définition :Il s'agit essentiellement d'une constante, modifiée par un pointeur. Sa propre valeur (c'est-à-dire l'adresse du pointeur) est une constante et ne peut pas être modifiée. En d'autres termes, après initialisation, la variable pointeur pointe toujours vers la même adresse. Bien que l'adresse du pointeur soit fixe, le contenu vers lequel il pointe peut être modifié via le pointeur.

Points clés :Le pointeur lui-même (c'est-à-dire l'adresse stockée dans le pointeur) est une constante et ne peut pas être modifié, mais le contenu pointé par le pointeur peut être modifié.

 

Forme du code :

int* const p;

Pointeur constant vers une constante

Définition:Une constante pointeur pointant vers une constante est une constante, et l'objet vers lequel elle pointe est aussi une constante.

Points clés :

  • 1. Une constante pointeur pointe vers un objet pointeur ;
  • 2. L'objet pointeur vers lequel elle pointe est aussi une constante, c'est-à-dire que l'objet vers lequel elle pointe ne peut pas changer ;

Forme du code :

const int* const p;

Alors, comment distinguer ces types ? Celui avec deux qualificateurs const est définitivement un pointeur constant vers une constante, ce qui est facile à comprendre. L'essentiel est de savoir comment distinguer un pointeur constant d'une constante pointeur :

Une façon est de regarder l'ordre d'arrangement de * et const, par exemple

int const* p;    //const * 即常量指针
const int* p;    //const * 即常量指针
int* const p;    //* const 即指针常量

Une autre façon est de voir à laquelle const est le plus proche, c'est-à-dire, lire de droite à gauche, par exemple

int const* p;    //const修饰的是*p,即*p的内容不可通过p改变,但p不是const,p可以修改,*p不可修改;
const int* p;    //同上
int* const p;    //const修饰的是p,p是指针,p指向的地址不能修改,p不能修改,但*p可以修改;

Exemple

//-------常量指针-------
const int *p1 = &a;
a = 300;     //OK,仍然可以通过原来的声明修改值,
//*p1 = 56;  //Error,*p1是const int的,不可修改,即常量指针不可修改其指向地址
p1 = &b;     //OK,指针还可以指向别处,因为指针只是个变量,可以随意指向;

//-------指针常量-------//
int*  const p2 = &a;
a = 500;     //OK,仍然可以通过原来的声明修改值,
*p2 = 400;   //OK,指针是常量,指向的地址不可以变化,但是指向的地址所对应的内容可以变化
//p2 = &b;     //Error,因为p2是const 指针,因此不能改变p2指向的内容

//-------指向常量的常量指针-------//
const int* const p3 = &a;
//*p3 = 1;    //Error
//p3 = &b;    //Error
a = 5000;    //OK,仍然可以通过原来的声明修改值

Dans les applications pratiques, les pointeurs constants sont plus souvent utilisés que les constantes pointeur. Par exemple, les pointeurs constants sont souvent utilisés dans le passage de paramètres de fonction pour éviter de modifier le contenu à l'intérieur de la fonction.

size_t strlen(const char* src); //常量指针,src的值不可改变;
char a[] = "hello";
char b[] = "world";
size_t a1 = strlen(a);
size_t b1 = strlen(b);

Bien que a et b puissent être modifiés, on peut garantir que le contenu de a et b ne sera pas modifié à l'intérieur de la fonction strlen.

Pointeur nul, pointeur sauvage

Puisque nous avons parlé des pointeurs, mentionnons aussi les problèmes des pointeurs nuls et des pointeurs sauvages.

Un pointeur nul est un pointeur qui stocke une adresse vide. Lors de l'utilisation d'un pointeur, vous devez d'abord déterminer s'il s'agit d'un pointeur nul ; de nombreux problèmes sont causés par cette étape.

Un pointeur sauvage est un pointeur qui, après que le pointeur est supprimé, n'est pas mis à 0, ce qui fait que le pointeur pointe arbitrairement vers une adresse mémoire. S'il continue d'être utilisé, il causera des erreurs de mémoire imprévisibles.

De plus, une mauvaise utilisation des pointeurs peut facilement causer des bogues ou des fuites de mémoire.

Regardez le code :

//-------空指针-------//
int *p4 = NULL;
//printf("%d",*p4); //运行Error,使用指针时必须先判断是否空指针

//-------野指针(悬浮、迷途指针)-------//
int *p5 = new int(5);
delete p5;
p5 = NULL; //一定要有这一步
printf("%d",*p5);  //隐藏bug,delete掉指针后一定要置0,不然指针指向位置不可控,运行中可导致系统挂掉

//-------指针的内存泄漏-------//
int *p6 = new int(6);
p6 = new int(7); //p6原本指向的那块内存尚未释放,结果p6又指向了别处,原来new的内存无法访问,也无法delete了,造成memory leak

Adresse de référence :

http://blog.csdn.net/Rueing839/article/details/48416907

http://www.cnblogs.com/lizhenghn/p/3630405.html