C++中常量#define和const修饰符区别

目录

1、常量需要初始化值

2、1类型和安全检查不同 

2、2编译器处理不同

2、3存储方式不同

2、4定义域不同

2、6是否可以做函数参数

3、 const关键字

4、#define关键字

5、const在指针上的应用

---

1、常量需要初始化值

//错误写法
const double pi;//会报未初始化本地变量
pi=3.14

#define PI;  //会报未输入表达式

//正确写法
const double pi=3.14;

const int A;          //错误，没有赋初始值。
extern const int A;   //正确，使用extern的外部变量。

#define PI 3.14;

2、1类型和安全检查不同 

宏定义(#define)是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边界效应等错误

const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查

2、2编译器处理不同

宏定义是一个"编译时"概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束与编译时期；

const常量是一个"运行时"概念，在程序运行使用，类似于一个只读行数据

2、3存储方式不同

宏定义是直接替换，不会分配内存，存储于程序的代码段中；

const常量需要进行内存分配，存储于程序的数据段中

 起作用方式而言

#define N 2+3     // 我们预想的 N 值是 5，我们这样使用 
Ndouble a = N/2;  // 我们预想的  a 的值是 2.5，可实际上 a 的值是 3.5

 占用空间而言

#define PI 3.14     //预处理后 占用代码段空间
const float PI=3.14;    // 本质上还是一个 float，占用数据段空间

2、4定义域不同

void f1 ()
{
    #define N 12
    const int n 12;
}
void f2 ()
{
    cout<<N <<endl; //正确，N已经定义过，不受定义域限制
    cout<<n <<endl; //错误，n定义域只在f1函数中
}

 2、5定义后能否取消

宏定义可以通过#undef来使之前的宏定义失效

const常量定义后将在定义域内永久有效

void f1()
{
  #define N 12
  const int n = 12;

  #undef N //取消宏定义后，即使在f1函数中，N也无效了
  #define N 21//取消后可以重新定义
}

2、6是否可以做函数参数

宏定义不能作为参数传递给函数

const常量可以在函数的参数列表中出现

3、 const关键字

const是constant的简写，只要一个变量前面用const来修饰，就意味着该变量里的数据可以被访问，不能被修改。也就是说const意味着只读（readonly）。

规则：const离谁近，谁就不能被修改；

const修饰一个变量，一定要给这个变量初始化值，若不初始化，后面就无法初始化。

本质：const在谁后面谁就不可以修改，const在最前面则将其后移一位，二者等效。

const关键字作用

• 为给读你代码的人传达非常有用的信息，声明一个参数为常量是为了告诉用户这个参数的应用目的；
• 通过给优化器一些附加信息，使关键字const也许能产生更紧凑的代码；
• 合理使用关键字const可以使编译器很自然的保护那些不希望被修改的参数，防止无意的代码修改，可以减少bug的出现；

const关键字应用

• 欲阻止一个变量被改变，可使用const，在定义该const变量时，需先初始化，以后就没有机会改变他了；
• 对指针而言，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
• 在一个函数声明中，const可以修饰形参表明他是一个输入参数，在函数内部不可以改变其值；
• 对于类的成员函数，有时候必须指定其为const类型，表明其是一个常函数，不能修改类的成员变量；
• 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”

4、#define关键字

预处理#define变量定义后，不能用分号，否则就会计算错误，但是程序不会报错

#define age  12
#define age1 10

#define age2  12;
#define age3 10;

int main()
{
   int dd  ; 
   dd = age + age1;
   cout  << "值=" << dd << endl; //值22
   dd = age2 + age3;
   cout  << "值=" << dd << endl; //值12
    return 0;  
}

5、const在指针上的应用

const 关键字出现在 * 的左边：指针指向的内容不能被修改。称其为指向常量打的指针，此时也被称为底层const

const 关键字出现在 * 的右边：指针本身不能被修改，称其为常量指针，此时也被称为顶层const，

const 关键字出现在 * 的两边: 指针指向的内容和指针本身都不能被修改。此时同时拥有底层和顶层const。

几点注意：

（1）底层指针指向的内容并非不可修改，只是无法通过该指针进行修改，换句话来说，底层指针“自作多情”地认为自己指向的内容是无法修改的，实际上可以通过赋值等方法改变其指向的内容。

（2）在使用中，顶层const只用来修饰指针，无法修饰引用（因为引用不是变量）；而底层const可以修饰指针和引用，其意义为指向或引用的内容是一个常量。只需要记住，底层const限定指向或引用的对象是常量，对指针或引用并没有限定；顶层const限定指针是常量，对其指向的内容没有限定。

（3）底层const会给变量施加一个限制，在执行拷贝操作时，非底层const的对象无法给具有底层const的变量赋值。

int main()
{
    int a = 1;
    //底层const, 也可以用int const *p1 = &a;.
    const int *p1 = &a; 
        
    //非法, 无法通过p1更改a的值.    
    *p1 = 2;  
                  
    //合法, p1的值(指向的地址)是可以更改的.    
    p1++;  
                     
    //合法, 只是无法通过p1解引用的方式更改a的值, 其他方式可以.    
    a = 2;                      

    //顶层const, p2是常量.    
    int *const p2 = &a;    
     
    //合法, p2指向地址的内容可以更改.    
    *p2 = 3;   
    
    //非法, p2的值(指向的地址)无法更改.            
    p2++; 
    
    //合法, p2指向地址的内容可以更改.                    
    a = 4;    

    //同时具有底层和顶层const, p3的值(指向的地址)无法修改, 且无法通过p3解引用进行更改.                  
    const int *const p3 = &a; 

    //非法, p1是const *int(底层const), 无法给普通int*赋值.
    int *p4 = p1; 

    //合法, p2是*const int(顶层const), 赋值时没有限制.         
    int *p5 = p2;    

    //合法, p6也是const *int(底层const), 可以获得p1的赋值.      
    const int *p6 = p1;         
}