Analyse et explication de l'utilisation courante des constantes const en C++

Expliquez d'abord le const en langage C et le const en C++. La variable modifiée par const dans le premier n'est pas une vraie constante. Elle indique simplement au compilateur que la variable ne peut pas apparaître sur le côté gauche du symbole d'affectation. Ce dernier C++ évolue const sur la base du C.

1. const en langage C :

• const La variable modifiée est en lecture seule, et l'essence est toujours une variable

• constLes variables locales modifiées allouent de l'espace sur la pile

• constLes variables globales modifiées allouent de l'espace dans la zone de stockage en lecture seule

• const n'est utile qu'au moment de la compilation, non valide au moment de l'exécution

• constImpossible de définir de vraies constantes

constLa variable modifiée n'est pas une vraie constante, elle indique simplement au compilateur que la variable ne peut pas apparaître sur le côté gauche du symbole d'affectation. const Les variables locales allouent de l'espace sur la pile, et la valeur dans cet espace peut être modifiée via un pointeur. Après la période de compilation, les caractéristiques constantes et les caractéristiques en lecture seule des variables const ont disparu. Les caractéristiques en lecture seule ne sont valables que pendant la période de compilation et n'ont aucun effet au moment de l'exécution. Les variables globales modifiées par const allouent de l'espace dans la zone de stockage en lecture seule. Par conséquent, si un pointeur est utilisé pour modifier la variable globale modifiée par const, le programme plantera à cause du contenu dans la zone de stockage en lecture seule. du programme est modifié, la plupart des programmes Un crash s'est produit.

2. const en C++ :

Le C++ a évolué const sur la base du C, comme le montre :

• constLors de la déclaration, placer les constantes dans la table des symboles

• Lors du processus de compilation, on constate que les constantes sont directement remplacées par des valeurs dans la table des symboles (pliage des constantes)

• Lors du processus de compilation, un espace de stockage peut également être alloué aux constantes correspondantes :

• const est utilisé globalement ou le static la description du mot-clé est utilisée, stockée dans la zone de données en lecture seule

  extern const int i = 10;
  static const int i = 10;
  
  // 或者修饰全局变量
  const int a =10;
  int main()
  {}

• les variables locales utilisent l'opérateur const pour la constante & et allouent de l'espace dans la zone de pile

Remarque : Bien que le compilateur C++ puisse allouer de l'espace pour les const constantes, il n'utilisera pas la valeur dans son espace de stockage

La table des symboles est une structure de données générée lors du processus de compilation

#include <iostream>
#include <string>
using namespace std;

const int i = 10;          // 如果通过指针去改变i，就会出现段错误：尝试修改只读数据区数据
int main()
{
    const int a = 5;
    int *p = (int *)&a;    // &a， 给a标识符分配空间了，并用p指向了该空间，
                           // 可以通过*p访问这个地址，但是不能通过a来访问
    *p = 10;               // 不能通过指针去改变a的值
    cout << a << endl;
    cout << *p << endl;
    
    return 0;
}

3. Comparaison avec la définition de la macro

La constante const en C++ est similaire à la définition de la macro

const int c = 5;
// 类似于
#define c 5

mais il y a une différence entre cosnt et la définition de la macro. La raison est :

• constLes constantes sont traitées par le compilateur

• Le compilateur effectue une vérification de type et une vérification de portée sur les cosntconstantes

• Les définitions de macro sont traitées par le préprocesseur et sont simplement des remplacements de texte

#include <stdio.h>

void f()
{
    #define a 3
    const int b = 4;
}

void g()
{
    printf("a = %d\n", a);
    // 在g函数中访问f函数中的宏定义，完全没有问题
    // 在预处理的时候就进行了宏替换，对编译器来说，就是printf("a = %d\n", 3);
    // 宏是没有作用域的概念
    
    // const 定义的常量，被编译器处理，是有作用域的，不能访问b
    printf("b = %d\n", b);
}

int main()
{
    const int A = 1;
    const int B = 2;
    int array[A + B] = {0};    
    /* C编译
    const修饰得到的只是具有只读特性的变量，数组的大小是由两个变量的大小决定的，
    两个变量相加的结果需要在运行的时候才能直到，因此编译器编译的时候不知道这个数组长度，直接报错
    */
    
    /* C++编译
    const是定义的真正意义上的常量，直接从符号表中取值，编译的时候就知道A和B的值，
    可以得到数组的长度，不会报错
    */
    int i = 0;
    
    for(i=0; i<(A + B); i++)
    {
        printf("array[%d] = %d\n", i, array[i]);
    }
    
    f();
    g();
    
    return 0;
}

Articles associés :

Analyse de la différence entre const et definition en php

Vidéos associées :

Tutoriel vidéo d'analyse sous-jacente PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!