Résumé de l'utilisation courante de const en c ++

Tout d'abord, const modifie les variables de type ordinaire:

cosnt int a=7;
int b=a;//正确
a=8;//错误
const int c;//错误。但是作为函数入参（形参）时，可以这样直接定义，不用初始化。

Modifiez la variable const:

#include<iostream>
 using namespace std;
 int main(void)
{
    const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;
    system("pause");
    return 0;
}

Pour la variable const a, nous prenons l'adresse de la variable et convertissons l'affectation en un pointeur en int, puis utilisons * p = 8; pour réaffecter la valeur dans l'adresse de la variable a, puis émettons la valeur de visualisation a. Vous pouvez voir dans la fenêtre de débogage ci-dessous que la valeur de a est changée à 8, mais la sortie est toujours 7.


La raison en est que le compilateur a été optimisé et que l'optimisation du compilateur peut être const int a = 7;modifiée pour l' éviter volatile const int a = 7;. De cette façon, le débogage et la sortie sont 8.

Deuxièmement, la variable de pointeur modifiée const

1. const modifie le contenu pointé par le pointeur, puis le contenu est invariable ( pointeur constant, pointeur constant, c'est-à-dire que le contenu pointé est constant )

const int *p=8;//const位于*左边，指向内容不可变

2. pointeur modificateur const, le pointeur n'est pas variable ( pointeur constant, pointeur est constant, c'est-à-dire que l'adresse est constante)

int a=8;
int* const p=&a;
p++;//错误，地址不可变
(*p)++//正确，指向内容可以改变

3. Si const modifie le pointeur et le contenu pointé par le pointeur, le pointeur et le contenu pointé sont tous deux immuables.

int a=8;
const int * const p=&a;//地址和指向内容都不可变

Trois, transfert de paramètres modifié const

1. La modification const du transfert de valeur est passée. Généralement, la modification const n'est pas nécessaire dans ce cas, car la fonction générera automatiquement des variables temporaires pour copier la valeur réelle du paramètre.

#include<iostream>
using namespace std;
void Cpf(const int a){
    cout<<a;
    // ++a;  是错误的，a 不能被改变
}
int main(){
    Cpf(8);
    return 0;
}

2. Lorsque le paramètre const est un pointeur, vous pouvez empêcher que le pointeur ne soit accidentellement altéré. (Identique à la constante du pointeur)

#include<iostream>
using namespace std;
void Cpf(int *const a){
    cout<<*a<<" ";
    *a = 9;
}
 int main(){
    int a = 8;
    Cpf(&a);
    cout<<a; // a 为 9
    return 0;
}

3. Passage de paramètres de type personnalisé . Des paramètres de copie d'objets temporaires sont nécessaires. Pour la construction d'objets temporaires, il est nécessaire d'appeler le constructeur, ce qui est une perte de temps. Par conséquent, nous prenons la méthode du passage const plus référence . Et pour les types intégrés généraux tels que int, double, etc., nous n'utilisons pas la méthode de transfert de référence.

#include<iostream>
using namespace std;
class Test{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const{
       return _cm;
    }
private:
    int _cm;
}; 
void Cmf(const Test& _tt){
    cout<<_tt.get_cm();
}
 int main(){
    Test t(8);
    Cmf(t);
    return 0;
}

Quatre, valeur de retour de fonction modifiée const

1. const modifie la valeur de retour des types intégrés. La modification équivaut à ne pas modifier la valeur de retour.

#include<iostream> 
using namespace std; 
const int Cmf(){
    return 1;
}
int Cpf(){
    return 0;
}
int main(){
    int _m = Cmf();
    int _n = Cpf();
    cout<<_m<<" "<<_n;
    return 0;
}

2. const modifie un type personnalisé comme valeur de retour. Pour l'instant, la valeur renvoyée ne peut pas être utilisée comme valeur l, ni affectée ni modifiée.

3. const modifie le pointeur ou la référence retourné, qu'il renvoie un pointeur à const dépend de ce que nous voulons que l'utilisateur fasse.

Cinquièmement, les fonctions membres de la classe const modifiée

Le but de la fonction membre de la classe de modificateur const est d'empêcher la fonction membre de modifier la valeur de l'objet appelé. Si nous ne voulons pas modifier la valeur d'un objet appelant, toutes les fonctions membres doivent être déclarées comme fonctions membres const.
Remarque: Le mot clé const ne peut pas être utilisé avec le mot clé static, car le mot clé static modifie une fonction membre statique. La fonction membre statique ne contient pas ce pointeur, c'est-à-dire qu'il ne peut pas être instancié. La fonction membre const doit être spécifique à une certaine instance.
La fonction get_cm () const; suivante utilise une fonction membre const:

#include<iostream>
using namespace std;
class Test{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const{
       return _cm;
    }
 
private:
    int _cm;
};
void Cmf(const Test& _tt){
    cout<<_tt.get_cm();
}
int main(){
    Test t(8);
    Cmf(t);
    return 0;
}

Si get_cm () supprime la modification const, le const _tt passé par Cmf ne change pas la valeur de l'objet, le compilateur pense que la fonction va changer la valeur de l'objet, donc nous essayons d'utiliser toutes les fonctions qui n'ont pas besoin de changer le contenu de l'objet comme const Fonction membre.

Que faire s'il existe une fonction membre qui souhaite modifier un certain membre de l'objet? À ce stade, nous pouvons utiliser le mot clé mutable pour modifier ce membre. La signification de mutable est également variable et facile à changer. Les membres modifiés par le mot clé mutable peuvent être en constante évolution, comme dans l'exemple suivant.

#include<iostream>
using namespace std;
class Test{
public:
    Test(int _m,int _t):_cm(_m),_ct(_t){}
    void Kf()const{
        ++_cm; // 错误
        ++_ct; // 正确
    }
private:
    int _cm;
    mutable int _ct;
};
int main(){
    Test t(8,7);
    return 0;
}

Ici, nous modifions la valeur de _ct par ++ _ ct; dans Kf () const, mais la modification de _cm par ++ _ cm signalera une erreur. Parce que ++ _ cm n'est pas décoré de mutable.