c++ const限定符

const限定符：

1、当某个变量不希望被改变时，使用const限定符，例如：const int i = 5；将i定义为常量，不可修改。因为const对象一旦创建后其值就不能再改变，所以const对象必须初始化。初始化方式可以是多样的：

const int i = get_value(); //运行时初始化

const int i = 2;//编译时初始化

2、c和c++的const区别

虽然C++借鉴了C语言中的关键字const，但C++版本更有用。例如，对于外部const值，C++版本有内部链接，而不是变量和C中的const所使用的默认外部链接。这意味着使用const的程序中的每个文件都必须定义该const。使用内部链接时，可以将const定义放在工程中的各种文件中。对于外部链接，这将导致编译错误，但对于内部链接，情况并非如此。举一个例子，有三个文件，分别是add.c、add.h、main.c，如下所示：

add.h

#ifndef __ADD_H__
#define __ADD_H__
const int LENGTH = 10;
extern int add(int a);
#endif

add.c

#include <stdio.h>
#include "add.h"
int add(int a)
{
    return a + LENGTH;
}

main.c

#include <stdio.h>
#include "add.h"


int main()
{
    printf("add = %d\n", add(5));
}

在这三个文件中，LENGTH定义在add.h中，而main.c和add.c都包含了该文件，导致LENGTH多次定义，使用gcc编译，会产生如下报错：

/tmp/cc8hVp0f.o:(.rodata+0x0): multiple definition of `LENGTH'
/tmp/ccC4rZsb.o:(.rodata+0x0): first defined here
collect2: ld 返回 1

也就是说重定义了，但是如果使用g++编译，可以正常产生可执行文件，没有任何报错。这时因为const在C++中只在本文件内可见，所以在add.c和main.c中的LENGTH定义不不冲突，因为彼此之间是不可见的。在这种情况下，C都是使用#define实现该功能，但是在C++中，一般比较推荐使用const代替#define。

还有一个差别是在C++中可以使用函数等复杂的表达式初始化其值，但是在C中，就不能使用函数初始化。举个例子：

#include <stdio.h>

int get_data()
{
    return 5;
}

const int DATA = get_data();

int main()
{
    printf("data = %d\n", DATA);
}

使用gcc编译这段代码，会报错，但是可以使用g++编译通过，并得到正确的结果。在C中，也不能使用像变量这种初始化const修饰的常量，但是C++都是可以的，所以，C++对const极大的扩宽了其可用性

3、指针和const

使用const即可以限定指针本身为常量，也可以限定指针指定的内容为常量，还可以同时限定，是位置决定的。

int i = 1;

const int *p = &i;//p指向的内容为常量，表示不能通过p指针改变i的值

int * const p = &i;//p本身是常量，表示p不可以改变但是可以通过p修改i的值，例如p= p + 1;//非法    *p = 2; //合法，i==2

const int *const p = &i;//p本身是常量，p指向的内容也是常量，都不可以修改

3、顶层const和底层const

指针本身是一个对象，它又可以指向另外一个对象。因此，指针本身是不是常量以及指针所指的是不是一个常量就是两个相互独立的问题。用名词顶层const（top-level const）表示指针本身是个常量，而用名词底层const（low-level const）表示指针所指的对象是一个常量。

更一般的，顶层const可以表示任意的对象是常量，这一点对任何数据类型都适用，如算术类型、类、指针等。底层const则与指针和引用等符合类型的基本类型部分有关。比较特殊的是，指针类型既可以是顶层const也可以是底层const，这一点和其他类型相比区别明显

举例说明：

const int a = 5; //在没有指针或者引用时，都是顶层const，所以不能修改c的值

int i = 4;
int *const b = &i; //不能改变b的值，这是一个顶层const

const int *c = &a; //允许改变c的值，这是一个底层const

const int &d = a;//用于声明引用的const都是底层const

简单概括一下，就是没有指针或者引用的简单类型，都是顶层const，都不允许修改。对使用指针的符合类型，那么当const限制的是指针本身的时候，就是顶层const，当const限制的是指针所指的内容就是底层const。用于声明引用的const都是底层const。

当执行对象的拷贝操作时，常量是顶层const还是底层const区别明显。其中，顶层const不受影响。执行拷贝操作并不会改变被拷贝对象的值，因此，拷入和拷出的对象是否是常量都没什么影响。举例说明：

const int a = 5;
int i = a; //i不是常量
const int j = a;//j是常量
//无论a是不是常量，i和j是不是常量，这个赋值都是正常的，因为不管a是否是常量，对i和j的赋值并不会对a产生任何影响

另一方面，底层const的限制却不能忽视。当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换。一般来说，非常量可以转换成常量，反之则不行，举例说明：

int i = 0;
const int *a = &i;
int *p = a;//错误，因为a包含底层const，而p没有。

const int j = 5;
int &r = j; //错误，普通的int&不能绑定到int常量上

其实很好理解，如果上面的int *p = a是正确的，那么便可以通过p修改p指向的内容，就相当于修改了a指向的内容，而a指向的i虽然不是常量，但是a的const在指针之前，表示a指向的内容是常量，所以不能通过a修改a指向的内容。那么int *p = a就是危险的操作，它打破了这种不能修改的情况，可以间接通过p指针修改i的值，特别是如果i是常量的情况，那么便可以通过p指针修改常量i，所以这是违反规则的。对于引用也是一个道理。就是不能通过引用或者指针获取能够修改本来不能被修改的变量的能力。