-σσ 58 605892】 Para uso con Q 【8099468】 Planificación precisa del cinturón, guía individual 【Manillar de fuerza de juego ilimitado】

　　1 ¿Qué es const?
　　
　　(Tipo constante) El tipo constante se refiere al tipo especificado por el modificador de tipo constante El valor de una variable u objeto de tipo constante no se puede actualizar. (Pero puedes robar el rayo y cambiar la columna para actualizar) 2 ¿Por qué
　　
　　introducir const?
　　
　　El propósito inicial de const era reemplazar la instrucción precompilada, eliminar sus defectos y heredar sus ventajas.
　　
　　3 El rol principal
　　
　　(1) puede definirse const constante, con inmutabilidad.
　　
　　Por ejemplo: const int Max = 100; int Array [Max];
　　
　　(2) Es conveniente para la verificación de tipos, de modo que el compilador comprenda mejor el contenido de procesamiento, eliminando algunos peligros ocultos.
　　
　　Por ejemplo: void f (const int i) {.........} El compilador sabrá que i es una constante y no se le permite modificar;
　　
　　(3) Puede evitar la aparición de números ambiguos, y también es muy conveniente Ajusta y modifica los parámetros. Al igual que con la definición de macros, puede ser lo mismo que es, ¡y todo cambiará!
　　
　　Como en (1), si desea modificar el contenido de Max, solo necesita: const int Max = desea;
　　
　　(4) Puede proteger las cosas modificadas, prevenir modificaciones accidentales y mejorar la solidez del programa. Aún así, el ejemplo anterior, si i se modifica en el cuerpo de la función, el compilador informará un error;
　　
　　por ejemplo: void f (const int i) {i = 10; // error!}
　　
　　(5) puede ahorrar espacio y evitar memoria innecesaria Distribución. Por ejemplo:
　　
　　#define PI 3.14159 // macro constante
　　
　　constante doble Pi = 3.14159; // En este momento, Pi no está en RAM ...
　　
　　double i = Pi; // asigna memoria para Pi en este momento, ¡ya no se asignará en el futuro!
　　
　　doble I = PI; // Reemplazo de macro durante la compilación, asignación de memoria
　　
　　doble j = Pi; // Sin asignación de memoria
　　
　　doble J = PI; // ¡Reemplazo de macro, asignación de memoria nuevamente!
　　
　　Desde la perspectiva del ensamblaje, const define constantes, pero solo proporciona la dirección de memoria correspondiente, en lugar de proporcionar datos inmediatos como #define, por lo que las constantes definidas por const solo tienen una copia durante la ejecución del programa, y ​​# Hay varias copias de la constante definida en la memoria.
　　
　　(6) Mejorar la eficiencia.
　　
　　El compilador generalmente no asigna espacio de almacenamiento para constantes constantes ordinarias, sino que las guarda en la tabla de símbolos, lo que la convierte en una constante durante la compilación, sin operaciones de almacenamiento y lectura de memoria, lo que la hace muy eficiente.
　　
　　4 Cómo limitar el contenido de la
　　
　　variable de límite constante :
　　
　　Ejemplo: el siguiente compilador de código informará un error, ¿puedo preguntar qué afirmación es incorrecta?
　　
　　typedef char * pStr;
　　
　　char string [4] = "bbc";
　　
　　const char * p1 = string; // 1 type
　　
　　const pStr p2 = string; // 2 type
　　
　　p1 ++;
　　
　　p2 ++;
　　
　　Respuesta y análisis: El
　　
　　problema radica en p2 ++.
　　
　　La forma básica de const: const tipo m; el límite m es inmutable. Reemplace m en la forma básica como * p1 en la fórmula 1, después del reemplazo const char * p1; el límite * p1 no es variable, por supuesto, p1 es variable, por lo que p1 ++ es correcto en la pregunta. Reemplace el tipo en la forma básica con pStr en el tipo 2 y reemplácelo con const pStr m; limite m para que sea inmutable. El pStr en la pregunta es un tipo nuevo, por lo que p2 no se puede cambiar [1] en la pregunta y p2 ++ está mal.
　　
　　const solo modifica las variables que siguen, y no importa si const se coloca antes o después del tipo. Tales como: const int a e int const a ambos modifican a a const. Un método de juicio simple: el operador de puntero * es de derecha a izquierda, por ejemplo: char const * pContent, puede entenderse como char const (* pContent), es decir, * pContent es const y pContent es variable.
　　
　　int const * p1, p2;
　　
　　p2 es const; (* p1) es un todo, entonces (* p1) es const, pero p1 es variable. int * p1, p2 solo significa que p1 es un puntero a un número entero. Para indicar que p1 y p2 son punteros, debe escribir int * p1, * p2. Entonces, ya sea * const p1, p2 o const * p1, p2, el * en él pertenece a p1.
　　
　　int const * const p1, p2;
　　
　　p2 es const, modificado por el const anterior, * p1 también es modificado por el const anterior, y p1 es modificado por el último const.
　　
　　int * const p1, p2;
　　
　　p1 es const, (* const p1) es el todo, por lo que const no modifica p2.
　　
　　Puntero y el cambio del valor de la variable
　　
　　Si const está a la izquierda de *, el valor de la variable señalada por el puntero es inmutable; a la derecha de *, el puntero es inmutable. Se abrevia como "Configuración izquierda, orientación derecha".
　　
　　1) El valor de la variable apuntada por el puntero no se puede cambiar, apuntando a la variable
　　
　　int x = 1;
　　
　　int y = 2;
　　
　　const int * px = & x;
　　
　　int const * px = & x; // Estas dos expresiones tienen el mismo efecto
　　
　　px = & y ; // correcto, permitir cambiar el punto
　　
　　* px = 3; // incorrecto, no permitir cambiar el valor
　　
　　de la variable señalada por el puntero 2) el valor de la variable señalada por el puntero se puede cambiar, señalar inmutable
　　
　　int x = 1;
　　
　　int y = 2;
　　
　　int * const px = & x;
　　
　　px = & y; // Error, no está permitido cambiar el puntero al punto
　　
　　* px = 3; // Sí, está permitido cambiar el valor
　　
　　de la variable señalada por el puntero 3) El valor de la variable señalada por el puntero es inmutable Cambiar
　　
　　int x = 1;
　　
　　int y = 2;
　　
　　const int * const px = & x;
　　
　　int const * const px = & x;
　　
　　px = & y; // error, no está permitido cambiar el puntero al punto
　　
　　* px = 3; // error, no Se permite cambiar el valor de la variable señalada por el puntero. El puntero de la variable
　　
　　declarada como constante solo puede asignarse al puntero declarado como constante al mismo tiempo.
　　
　　// constant_values4.cpp
　　
　　#include <stdio.h>
　　
　　int main () {
　　
　　const char * mybuf = "test";
　　
　　char * yourbuf = "test2";
　　
　　printf_s ("% s \ n", mybuf);
　　
　　const char * bptr = mybuf; // Puntero a datos constantes
　　
　　printf_s ("% s \ n", bptr);
　　
　　// * bptr = 'a'; // Error
　　
　　}
　　
　　no puede declarar un constructor o destructor con la palabra clave const.
　　
　　Al calificar una función miembro:
　　
　　declare una función miembro especificada con la palabra clave const. La función es una función de "solo lectura" y no modifica el objeto cuando se llama. Una función miembro constante no puede modificar ningún miembro de datos no estático ni llamar a ninguna función miembro que no sea una constante. Para declarar una función miembro constante, coloque la palabra clave const después del paréntesis de cierre de la lista de parámetros y coloque la palabra clave const entre la tabla de parámetros de la función y el cuerpo de la función. Alguien puede preguntar: ¿por qué no poner const antes de la declaración de función? Porque hacerlo significa que el valor de retorno de la función es constante y el significado es completamente diferente. La palabra clave const se requiere en declaraciones y definiciones.
　　
　　// constant_member_function.cpp
　　
　　class Date
　　
　　{
　　
　　public:
　　
　　Date (int mn, int dy, int yr);
　　
　　int getMonth () const;
　　
　　void setMonth (int mn); // Una función de escritura; no puede ser const
　　
　　private:
　　
　　int mes;
　　
　　};
　　
　　int Date :: getMonth () const
　　
　　{
　　
　　return month; // No modifica nada
　　
　　}
　　
　　void Date :: setMonth (int mn)
　　
　　{
　　
　　month = mn; // Modifica miembro de datos
　　
　　}
　　
　　int main ()
　　
　　{
　　
　　Date MyDate (7, 4, 1998);
　　
　　const Date BirthDate (1, 18, 1953);
　　
　　MyDate.setMonth (4); // Okay
　　
　　BirthDate.getMonth (); // Okay
　　
　　BirthDate.setMonth (4); // C2662 Error
　　
　　}
　　
　　El parámetro del valor pasado de la función limitada:
　　
　　función vacía (const int Var); // El parámetro pasado no se puede cambiar dentro de la función.
　　
　　Tipo de valor de retorno de función limitada
　　
　　Const int function (); // const no tiene sentido en este momento
　　
　　const myclassname function (); // La función devuelve el tipo personalizado myclassname.
　　
　　Tipo de función calificada.
　　
　　void function () const; // La función miembro constante, la función miembro constante es una función que no puede cambiar el valor de la variable miembro
　　
　　Las funciones de miembros no constantes no pueden ser llamadas por objetos de miembros constantes porque puede intentar modificar miembros de datos constantes. Cualquier función que no modifique los datos de miembros debe declararse como una función constante, lo que ayuda a mejorar la legibilidad y fiabilidad del programa.
　　
　　void AddElem (const int);
　　
　　bool Set :: Member (const int elem) const;
　　
　　const Set s;
　　
　　s.AddElem (10); // ilegal: AddElem no es una función miembro constante
　　
　　s.Member (10); // correcto
　　
　　pero Los constructores y destructores son una excepción a esta regla. Nunca se definen como miembros constantes, pero pueden ser llamados por objetos constantes (llamados automáticamente). También pueden asignar valores a miembros de datos constantes, a menos que los propios miembros de datos sean constantes.
　　
　　función miembro const y objeto const
　　
　　De hecho, la función miembro const también tiene otra función, a saber, objeto constante. Para los tipos de datos integrados, podemos definir sus constantes, así como las clases definidas por el usuario, que pueden definir sus objetos constantes. Por ejemplo, el método para definir una constante entera es:
　　
　　const int i = 1;
　　
　　Del mismo modo, también puede definir un objeto constante, suponiendo que haya una clase classA, el método para definir un objeto constante de esta clase es:
　　
　　const classA a (2);
　　
　　Aquí, a es un objeto constante de la clase classA, "2" se pasa a su parámetro constructor. Los miembros de datos de los objetos const no se pueden cambiar durante la vida útil del objeto. Sin embargo, ¿cómo asegurarse de que los miembros de datos de esta clase no cambien?
　　
　　Para garantizar que los miembros de datos de los objetos const no se modifiquen, en C ++, los objetos const solo pueden llamar a las funciones miembro const. Si una función miembro no modifica realmente el miembro de datos de ninguna manera, pero no está limitada por la palabra clave const, no puede ser invocada por un objeto constante. Aquí hay un ejemplo para ilustrar este problema:
　　
　　clase C
　　
　　{
　　
　　int X;
　　
　　public:
　　
　　int GetX ()
　　
　　{
　　
　　return X;
　　
　　}
　　
　　void SetX (int X)
　　
　　{
　　
　　this-> X = X;
　　
　　}
　　
　　};
　　
　　void main ()
　　
　　{
　　
　　const C constC;
　　
　　cout << constC.GetX ();
　　
　　}
　　
　　Si compilamos el código del programa anterior, el compilador emitirá un mensaje de error: constC es un objeto constante, solo puede llamar a funciones miembro de const. Aunque la función GetX () en realidad no cambia el miembro de datos X, dado que no está calificada por la palabra clave const, el objeto constC no puede llamarla. Si 　　reescribimos el código anterior:
　　
　　int GetX ()
　　
como:
　　
　　int GetX () const
　　
　　Recompile nuevamente, no habrá problema.