Primero comprendamos algunas consideraciones sobre referencias y punteros.
- Una referencia no es un objeto
- Una referencia debe inicializarse
- Una referencia solo puede vincularse a un objeto, y no puede vincularse a un valor literal ni al resultado del cálculo de una expresión.
- El tipo debe coincidir estrictamente
int &a = 10; //错误:引用类型的初始值必须是一个对象 double a = 3.14; int &b = a; //错误:此处引用类型的初始值必须是int型对象
El puntero en sí mismo es un objeto
El tipo del puntero debe coincidir estrictamente con el objeto al que apunta
double dval; double *pd = &dval; //正确 double *pd2 = pd; //正确 int *pi = pd; //错误:指针pi的类型和pd的类型不匹配 pi = &dval; //错误:试图把double型对象的地址赋给int型指针
Hay una excepción: la introducción del calificador const
Referencia constante
Al inicializar una referencia constante, se permite utilizar cualquier expresión como valor inicial
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; //错误
Puntero constante
Definición:También se llama puntero constante; puede entenderse como el puntero de una constante, es decir, esto es un puntero, pero apunta a una constante; esta constante es el valor del puntero (la dirección), no el valor al que apunta la dirección.
Puntos clave:
- 1. El objeto al que apunta un puntero a constante no puede modificarse a través de este puntero, pero aún puede modificarse mediante la declaración original;
- 2. A un puntero a constante se le puede asignar la dirección de una variable; la razón por la que se llama puntero a constante es que limita la modificación del valor de la variable a través de este puntero;
- 3. El puntero también puede apuntar a otro lugar, porque el puntero en sí es solo una variable y puede apuntar a cualquier dirección;
Forma de código:
Puntero a constante (
const int* ptr): el contenido al que apunta el puntero es una constante y no puede modificarse a través de ese puntero. Pero el puntero en sí (es decir, la dirección que guarda el puntero) puede cambiar.Puntero constante (
int* const ptr): el puntero en sí (es decir, la dirección que guarda el puntero) es una constante y no puede cambiar, pero el contenido al que apunta el puntero sí puede modificarse.Puntero constante a constante (
const int* const ptr): tanto el puntero en sí (es decir, la dirección que guarda el puntero) como el contenido al que apunta son constantes. No pueden modificarse ni la dirección del puntero ni el contenido al que apunta.
Puntero constante
Definición:En esencia es una constante, pero modificada por un puntero. Su propio valor (es decir, la dirección del puntero) es una constante y no puede cambiar. En otras palabras, después de la inicialización, la variable puntero siempre apunta a la misma dirección. Aunque la dirección del puntero es fija, el contenido al que apunta sí puede modificarse a través del puntero.
Puntos clave:El puntero en sí (es decir, la dirección que guarda el puntero) es una constante y no puede cambiar, pero el contenido al que apunta puede modificarse.
Forma de código:
int* const p;
Puntero constante a constante
Definición:Un puntero constante que apunta a una constante es una constante, y el objeto al que apunta también es una constante.
Puntos clave:
- 1. Un puntero constante apunta a un objeto puntero;
- 2. El objeto puntero al que apunta es además una constante, es decir, el objeto al que apunta no puede cambiar;
Forma de código:
const int* const p;
Entonces, ¿cómo distinguir estos tipos? Los que llevan dos const son sin duda punteros constantes que apuntan a una constante, lo cual es fácil de entender; la cuestión principal es cómo distinguir entre puntero a constante y puntero constante:
Una forma es observar el orden de * y const, por ejemplo
int const* p; //const * 即常量指针 const int* p; //const * 即常量指针 int* const p; //* const 即指针常量
Otra forma es ver a cuál está más cerca const, es decir, mirar de derecha a izquierda, por ejemplo
int const* p; //const修饰的是*p,即*p的内容不可通过p改变,但p不是const,p可以修改,*p不可修改; const int* p; //同上 int* const p; //const修饰的是p,p是指针,p指向的地址不能修改,p不能修改,但*p可以修改;
Ejemplo
//-------常量指针------- 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,仍然可以通过原来的声明修改值
En la práctica, el puntero a constante se usa más que el puntero constante; por ejemplo, el puntero a constante se usa con frecuencia al pasar parámetros a funciones, para evitar que se modifique el contenido dentro de la función.
size_t strlen(const char* src); //常量指针,src的值不可改变; char a[] = "hello"; char b[] = "world"; size_t a1 = strlen(a); size_t b1 = strlen(b);
Aunque a y b son modificables, se puede garantizar que dentro de la función strlen no se modificará el contenido de a y b.
Puntero nulo, puntero salvaje
Ya que hemos hablado de punteros, aprovechemos para mencionar el problema de los punteros nulos y los punteros salvajes.
Un puntero nulo es un puntero cuya dirección almacenada está vacía; al usar un puntero, primero se debe comprobar si es un puntero nulo; muchos problemas se deben precisamente a este paso.
Un puntero salvaje se produce cuando, tras hacer delete del puntero, no se establece a 0, lo que hace que el puntero apunte arbitrariamente a una dirección de memoria; si se continúa utilizando, puede causar errores de memoria impredecibles.
Además, el mal uso de los punteros puede causar fácilmente errores (bugs) o fugas de memoria.
Veamos el código:
//-------空指针-------//
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
Dirección de referencia:
http://blog.csdn.net/Rueing839/article/details/48416907
http://www.cnblogs.com/lizhenghn/p/3630405.html