C++知识--const关键字

一、const关键字的基本特点

1.1 const修饰的变量不能被改变

const int a=10;
a=20;//错误

1.2 因为const修饰的变量不能被改变，因此必须被初始化

int a=10;
const int b=a;  //正确
const int c=10; //正确

1.3 const修饰的变量可以赋值给其他值

const int a=10;
int b=a;//正确const int a=10;
int b=a;//正确

1.4 有常量引用

int a=10;
const int &b=a;

todo：引用和指针的区别；常量引用和普通引用的区别；

二、在其他文件中使用const变量（extern关键字）

const变量默认在当前文件使用，使用extern使得const常量在文件中共享；

当其他文件使用const常量时，如果出现同名，则其他文件中的局部变量会覆盖const变量；

//test.h
#include <iostream>

using namespace std;
extern const int  constnum = 10;
void func()
{
	cout << "test.cpp:" << constnum << endl;
}

//code.cpp
#include <iostream>
#include "test.h"
using namespace std;

extern const int  constnum;
int main()
{
   
    func();
    std::cout << "code.cpp:未定义同名变量前 " << constnum << endl;
    const int  constnum = 20;
    std::cout <<"code.cpp:定义同名变量后 "<< constnum << endl;
}

输出结果

 extern关键字

基本作用

extern置于变量或者函数前，用于标识变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找。extern可以进行链接指定。

三、const和引用

3.1 基本用法

将引用和const对象绑定，就像绑定到其他对象上一样，我们称之为“对常量的引用”；

和普通的引用不同，不能对常量的引用进行修改；

不能使用普通引用指向const常量；

const int ci = 1024;

const int &r1 = ci; //正确，引用到常量上
r1 = 42;            //错误，不能对常量的引用进行修改
int &r2 = ci;       //错误，不能让一个非常量引用指向一个常量对象
                    //因为引用可以通过改变自身值而改变所引用的值，
                    //所以为了防止引用改变值，禁止使用普通引用引向const常量

3.2 初始化和对const的引用

引用的类型必须和其引用的对象类型一致，但是有两个例外：

1、初始化常量引用时允许任意表达式作为初始值，只要该表达式的结果可以转成引用的类型即可

//代码段1
double dval = 3.14;
const int &ri = dval;//正确

/*
上面的代码会生成一个int类型的临时变量，然后将临时变量赋值给ri，因此上述代码可以扩展为：
    double dval = 3.14;
    const int temp = dval; //临时变量
    const int &ri = temp ;
*/

2、允许为一个常量引用绑定非常量的对象、字面值、甚至是个一般表达式

//代码段2
int i = 42;
const int &r1 = i;     //正确，允许将const int&绑定到一个普通对象上
const int &r2 = 42;    //正确
const int &r3 = r1 * 2;//正确
int &r4 = r1 * 2;      //错误

四、常量和指针

const可以用来修饰指针；

• 常量只能由常量指针来指向，不能由非常量指针来指向

const double pi = 3.14;

double *ptr = π       //错误。ptr是非常量的
const double *cptr = π//正确

• 可以使用常量指针指向一个非常量的对象

double dval = 3.14;
const double *cptr = &dval; //正确

• 不能通过常量指针修改指向对象的值

const double dval = 3.14;
const double *cptr = &dval; //正确
*cptr = 6.28;  //错误

double dval2 = 3.14;
const double *cptr2 = &dval; //正确
*cptr2 = 6.28;  //错误

五、常量指针、指针常量、常量指针常量（重点）

常量和指针的读法：按照中文习惯从左向右一次读即可；

• 常量指针（指向常量的指针）。指向可以变，但是不能通过该指针改变所指向的值；
  • 这种类型的const也被称为“底层const”：表示指针所指向的值是个常量；
• 指针常量（指针的常量）。指向不可以变，但是可以通过该指针改变所指向的值；
  • 这种类型的const也被称为“顶层const”：表示指针本身是个常量；
• 常量指针常量：不可以修改指向，也不可以修改所指向的值

const int* pa;       //常量指针
int const* pb;       //常量指针

int * const pc;      //指针常量

int const* const pd;//常量指针常量

如何通过const的位置判断const对什么起作用：

• const对左边的类型起作用：当const左边没有东西时，才对右边的起作用：因此有如下规则
  • 常量指针时，const左边为int或const左边无内容右边有int，incident只对int（值）生效，所以为常量指针；
  • 指针常量时，const左边有*（表示指针），所以为指针常量；
  • 常量指针常量，有两个const，对int（值）、*（指针）都生效，因此为常量指针常量；
• 上面的规则简化为
  • const出现在*的左边，表示所指之物为常量；
  • const出现在*的右边，表示指针本身是个常量；

初始化和使用

常量指针

表示所指对象是个常量，因此有下面的规则

• 常量指针可以指向常量或者非常量；
• 但是不能通过常量指针修改所指向的值；

int a = 1;
const int b = 2;

const int *pa = &a; //正确，可以指向非常量
pa = &b;            //正确，指向可以改变

*pa = 1;            //不能通过常量指针修改所指对象的值

指针常量

表示指针是个常量，因此有下面的规则

• 只能指向非常量，不能指向常量；
• 不能改变指针常量的指向，因为指针本身是个常量；
• 可以通过指针改变所指向的值

int a = 1;
const int b = 2;
int c = 3;

int* const pa = &a; //正确，a是非常量
int* const pb = &b; //错误，b是常量

*pa = 10; //正确，可以修改指向对象的值
pa = &c;  //错误，不能修改pa的指向（因为指针自身是个常量）

常量指针常量

• 可以使用常量、非常量赋初值；
• 不能改变值、不能改变指向；

int a = 1;
const int b = 2;

const int *const p1 = &a; //正确
const int *const p2 = &b; //正确

*p1 = 2; //错误
p1 = &b; //错误

todo:const_cast关键字