El problema entre const y puntero, referencia, método miembro en C++

El tipo modificado por const es el tipo formado más cercano a él, y el resto son lo que él modificó.

1. La relación entre constante y puntero

1.1 El problema de la conversión forzada de constante constante y puntero

①Si se asigna una variable constante a una variable, entonces C++ implementa el principio de sustitución al compilar y asigna el valor de la variable constante directamente a la variable.
El siguiente problema de ejemplo (pegue el código en el tablero de dibujo):

En la primera función principal, que es nuestro código, asigne la variable constante a a la variable b, luego, cuando C ++ compile, reemplazará a con 10 y luego se lo asignará a b. Después del reemplazo, la segunda función principal en el figura arriba, luego generará: a = 10, b = 10, * p = 100.

Sin embargo, las reglas de compilación de .c son diferentes de las de C++. .C asignará el valor después de la conversión forzada a b, por lo que cuando *p se convierte en 100, entonces a también es 100, por lo que b es igual al valor cambiado después una conversión forzada 100, la salida final: a=100,b=100,*p=100.

Pregunta: ¿Cómo saber si nuestro programa está compilado por el método C o por el método C++?
Qué forma de importar a través de __cplusplus
:
qué forma de imprimir:

②Eliminar la permanencia y forzar el cambio
Explicación: eliminar la permanencia de la variable

1.2 Comprensión profunda

La comprensión de "la capacidad se puede contraer pero no expandir", ¿cuál de las siguientes oraciones se puede compilar y no se puede compilar?

int a=10,b=20;
const int *p=&a;//这里的const修饰之后，p的指向可以改变，但是*P不能改变

//下面四句话中，s0，s3不可以编译通过，因为这两行会把*p的能力进行扩展
int *s0=p;
const int *s1=p;
int *const s2=p;
const int * const s3=p;

int a=10,b=20;
int* const p=&a;//这里的const修饰之后，p的指向不能进行改变，但是*p可以改变

//下面四句话都可以编译通过，因为p的指向被限制了，但是其他指针可以指向p，也可以指向其他的地址，并不会因为p的指向固定而被限制
int *s0=p;
const int *s1=p;
int * const s2=p;
const int * const s3=p;

2. La relación entre constante y referencia

2.1 Conceptos básicos:

La habilidad puede ser contratada, por ejemplo:

int main()
{
    
    
    int a=10;
    int& b=a;
    const int&c=a;
    a+=100;//编译通过
    b+=100;//编译通过
    //c+=100;//编译出错，因为前面有const进行修饰，所以c不能改变
}

La habilidad no se puede extender, por ejemplo:

int main()
{
    
    
    const int a=10;
    //int& b=a;//这里编译不通过
}

2.2 La relación entre referencia de puntero y constante

①Ejemplo:

Para el código en el cuadro verde de arriba, si s=&b, p2 también apuntará a b, por lo que el valor de b es 20.

②Ejercicio:
Para las siguientes declaraciones, ¿cuáles se pueden compilar y cuáles no?
(La respuesta ya está dada en la imagen de abajo)

2.3 La naturaleza de las citas

①Explicación:
El código antes de la compilación es el siguiente: El código después de la compilación es el siguiente:

¿Diferencia entre referencia y puntero?
Sintaxis: la referencia es un alias para una variable (referencia segura)
Ensamblaje/Nivel bajo: la referencia es equivalente a un puntero que es en sí mismo constante

②¿Cuál de los siguientes resultados x, y, z es correcto?
Respuesta: Solo x es verdadera.
Aunque y también imprime 20, el valor de la dirección de la variable local no se altera. Si la dirección de la variable local se asigna por completo y se reasigna a la dirección de la variable local, la y impresa ya no es 20.
z imprimirá un valor aleatorio, porque cout perturbará la referencia de espacio de marco de pila devuelta por funref antes de la liberación de

la dirección de la variable local, y esta dirección se liberará para obtener un valor aleatorio. (No se puede obtener la dirección del espacio inválido)
Resumen: ¿Cómo devolver la variable como referencia?
Esta variable no se ve afectada por el tiempo de vida de la función
Variables globales Variables
locales estáticas Variables
ingresadas por referencia
Por ejemplo:

2.4 ¿Se puede usar una función para implementar tanto get como set?

//实现双向函数
class Object
{
    
    
private:
    int value;
public:
    Object(int x = 0) :value(x) 
    {
    
    
    }
    ~Object()
    {
    
    
    }
    void SetValue(int x)
    {
    
     
        value = x; 
    }
    int GetValue() 
    {
    
     
        return value; 
    }
    // 使用一个函数实现 SetValue 和 GetValue() 函数的功能
    int& Bidirectional_function()
    {
    
    
        return value;
    }
    const int& Bidirectional_function()const//常对象调用常方法
    {
    
    
        return value;
    }
    //上面两个成员方法是函数重载。因为虽然函数名称一样，形参个数一样，但是形参的类型不一样
};
void fun(const Object& obj)
{
    
    
    const int& x = obj.Bidirectional_function();
}
int main()
{
    
    
    Object obj(10);
    int x = 0;
    x = obj.Bidirectional_function();//获取成员变量的值
    obj.Bidirectional_function () += 100;//改变成员变量的值
}

3. La relación entre los métodos miembro definidos en clases y const

class CGoods
{
    
    
private:
    char Name[21];
    int Amount;
    float Price;
    float Total_value;
public:
     void RegisterGoods(char[],int,float);
     void CountTotal(void);
     void GetName(char[]);
     int GetAmount(void);
     float GetPrice(void);
     float GetTotal_value(void);
}

①Para la clase anterior, si agrega const a uno de los métodos de miembro, entonces este método es un método regular, porque después de que se ingresa la const, significa que los atributos de miembro en el método de miembro del objeto no se pueden cambiar de la siguiente manera :

void CountTotal(void)const

②Si no desea cambiar este puntero, debe agregar una const, de la siguiente manera:

//为了和常方法的const进行区别，这里加上this指针,所以为了使得this指针不改变，给this前面加上const
//所以第一个const表示常方法，这个类的成员属性只能读，不能改
//第二个const表示这个this指针指向当前的对象，不能指向其他的对象
void CountTotal(const CGoods* const this)

③Agregue const antes del método para indicar que el valor devuelto es constante

const  float GetPrice(void);

④¿Por qué hacer que algunos métodos miembro sean métodos regulares?
Motivo: Puede usar objetos normales para llamar a métodos regulares, y puede usar objetos regulares para llamar a métodos regulares, de modo que una función se pueda usar en una variedad más amplia de lugares.