2.4 calificadores constantes

2.4 calificadores constantes

La palabra clave const agrega un límite al tipo de la variable

const int bufSize = 12;

El objeto modificado por const no puede cambiar su valor una vez que se crea, por lo que el objeto modificado por él debe inicializarse.
En comparación con los objetos de tipo no constante, los objetos modificados por constante pueden realizar la mayoría de las operaciones de los objetos no constantes, pero no se pueden modificar ni reasignar.

De forma predeterminada, los objetos constantes solo están disponibles en archivos.

Cuando una variable modificada const se inicializa en tiempo de compilación, el compilador cambiará todos los lugares donde se usa la variable en el valor correspondiente durante la compilación.

("Primer manual de C++")

2.4.1 Constantes de referencia

Una constante de referencia no puede modificar el objeto al que está vinculada, y una referencia que no es constante no puede apuntar a un objeto constante

int i = 10;
const int &r = i;
r = 11; // 错误：表达式必须是可修改的左值

const int i  = 10;
int &r = i; //错误：将 "int &" 类型的引用绑定到 "const int" 类型的初始值设定项时，限定符被丢弃

inicialización y referencia a const

El tipo de la referencia debe ser coherente con el tipo del objeto al que se hace referencia. Excepción:
se permite utilizar cualquier expresión como valor inicial al inicializar una referencia constante, siempre que el resultado de la expresión se pueda convertir al tipo de referencia. .

int i = 10;
const int &r = i; // 允许常量引用绑定到一个普通int对象上
const int &r1 = 45; // 正确：r1是一个常量引用
const int &r2 = r*2; // 正确：r2是一个常量引用
int &r3 = r1*2; // 错误：r3是一个普通的非常常量引用

Una referencia a const puede referirse a un objeto que no es const

Una referencia constante solo limita las operaciones en las que puede participar la referencia y no limita si el objeto al que se hace referencia en sí mismo es una constante. Dado que un objeto también puede no ser constante, se permiten otros medios para cambiar el valor de una referencia constante.

int i = 10;
const int &r = i;
i = 15;
cout << r << endl; // 15
int &r1 = i;
r1 = 16;
cout << r << endl; // 16

2.4.2 const y punteros

Los punteros pueden apuntar a constantes o no constantes. Para almacenar la dirección de un objeto constante, el puntero debe modificarse con la palabra clave const. Un puntero a una constante no se puede usar para cambiar el valor del objeto al que apunta.

const double i = 3.14; // 常量对象
const double *p = &i; // 正确：p是指向常量的指针
*p = 12; // 错误：指向常量的指针不能用于改变其指向的对象的值
double *p1 = &i; //错误："const double *" 类型的值不能用于初始化 "double *" 类型的实体

El tipo de un puntero a una constante debe ser el mismo que el tipo del objeto apuntado, excepción:
un puntero a una constante apunta a un objeto no constante

int i = 10;
const int *p = &i; // 正确：常量指针指向了非常量对象
 i = 15; // 可以通过修改非常量对象的值来修改指向常量的指针
 cout<< *p << endl; // 15

puntero constante

Los punteros son objetos y las referencias no lo son, por lo que, al igual que otros tipos de objetos, se permite colocar el puntero como una constante. El puntero constante (const pointer) debe ser inicializado Una vez que se completa la inicialización, el valor del puntero (la dirección almacenada) no se puede cambiar.

const int i = 10;
const int *const pip = &i; // pip是一个指向常量的常量指针

	int i = 15;
    int *const p = &i;
    cout << *p << endl;//15
    *p = 45;
    cout << *p << endl;//45
    i = 10;
    cout << *p <<endl;//10
    int k = 33;
    p = &k; // 错误：常量指针所存放的地址不可以被改变

El puntero al objeto constante debe ser un puntero modificado por const. El puntero a la constante puede almacenar la dirección del objeto no constante o el objeto constante, y la dirección almacenada por el puntero const es fija.

2.4.3 Constante de nivel superior

El puntero en sí mismo es un objeto. Si el puntero en sí mismo es una constante y si el objeto al que apunta el puntero es una constante son dos cuestiones independientes. Para distinguir estos dos términos, use la constante de nivel superior y la constante de nivel inferior . constante para distinguir.

tipo	constante de nivel superior	constante subyacente
explicar	los punteros son objetos constantes	puntero a un objeto constante
ejemplo	int *const p = &i;	int const i = 10;const int *p =&i;

Amplíe la definición de const de nivel superior y const de nivel inferior: la const de nivel superior se refiere a cualquier objeto constante, mientras que la const de nivel inferior está relacionada con los tipos básicos de tipos compuestos, como punteros y referencias.

int i = 10;
int *const p1 = &i;// 不可以修改p1的值，这是一个顶层const
const int *p2 = &i; // 可以修改p2的值，这是一个底层const
const int ci = 12;// 不可以修改ci的值，这是一个顶层const

Al realizar operaciones de copia, existe una clara distinción entre la constante de nivel superior y la constante de nivel inferior. La const de nivel superior no se ve afectada, porque el objeto modificado por la const de nivel superior es un objeto constante y no se puede modificar. Realizar una operación de copia no cambiará el valor del objeto copiado, por lo que si el objeto se copió o copió out es una constante no importa.

 int i = 11;
    const int ci = 10;

    const int *p1 = &ci; // p1:底层cosnt
    const int *const p2 = p2; // 第一个const是底层const，第二个是顶层const
    i= ci; // 正确：拷贝ci的值，ci是一个顶层const对此操作无影响
    p1 = p2; // 正确：p2和p3指向的对象类型相同，p3顶层const的部分不影响

Para constantes subyacentes, los objetos copiados y copiados deben tener la misma calificación subyacente

const int ci = 10;
const int *p2 = &i; 
int *p = p2; // 错误：p2是底层const，而p无底层const资格

2.4.4 constexpr y expresiones constantes

Una expresión constante es una expresión cuyo valor no cambia y cuyo resultado se puede obtener durante la compilación. Los valores literales son expresiones constantes, y los objetos const inicializados con expresiones constantes también son expresiones constantes. El tipo de datos y el valor inicial determinan si un objeto o expresión es una expresión constante.

const int  i = 10;// i是常量表达式
const int  l = i +1; // l是常量表达式
int s = 2;// s不是常量表达式，其数据类型只是一个普通的int
const int  k = get_size();// k不是常量表达式，因为常量k的初始值是要运行函数之后才能够获取到

variable constexpr

El nuevo estándar C++11 estipula que las variables pueden declararse como tipos constexpr para que el compilador pueda verificar si el valor de la variable es una expresión constante. Una variable declarada como cosntexpr debe ser una constante y debe inicializarse con una expresión constante.

constexpr int i = 20; // 20是常量表达式
constexpr int l = size(); // 当size函数是一个cosntexpr函数时才是一条正确的语句

variable constexpr

El tipo utilizado al declarar constexpr se convierte en un "tipo de valor literal". Los tipos aritméticos, los tipos de referencia y los punteros pertenecen a tipos de valor literal, y las clases personalizadas, las bibliotecas de E/S y los tipos de cadenas no pertenecen a tipos de valor literal.
El valor inicial de un puntero constexpr debe ser nullptr o 0, o un objeto almacenado en una dirección fija.
Las variables en el cuerpo de la función generalmente no se almacenan en direcciones fijas, por lo que los punteros de constexpr no pueden apuntar a dichas variables, y las direcciones fijas de los objetos definidos en todos los cuerpos de la función se pueden usar para inicializar constexpr.

constexpr y punteros

Si un puntero se define en una declaración constexpr, el calificador constexpr solo es válido para el puntero y no tiene nada que ver con el objeto al que apunta el puntero.

const int *p = nullptr; // p是一个指向整型常量的指针
constexpr int *q = nullptr; //q是一个指向整数的常量指针

constexpr establece el objeto q definido en el nivel superior.