C/C++编程：const使用总结

Bertha 。 2022-05-18 03:45 233阅读 0赞

> const约束对象的访问性质：使得对象只能读，不能写：不允许修改对象的值.

# const #

## const修饰变量 ##

C的const表示修饰只读变量，但是我们可以恶意强制操作const对象。

// C     
    const int num = 100;
    (int *)&num = 4;   //可以间接修改

c++的const修饰的变量有内存实体，但是只能是右值； C++的const变量一旦初始化，就会强制告诉编译器对这块内存的修改无效，不可能通过它去操作这块内存的值。

// c++
     const int i = 0;   //是一个右值，有内存实体
     i = 11;          //错误：向只读变量‘i’赋值

const int a{1.1}; //错误：从“double”转换到“int”需要收缩转换,请初始化成相同类型的常量

**C++必须初始化const修饰的变量，除非是extern修饰的变量**，C中如果不初始化const常量会警告，CPP中会报错

// C++
        const int i ;  // 错误：未初始化的常量‘i’ [-fpermissive]
        extern const int a;  //常量 变量 "a" 需要初始值设定项[严重性	“a” : 如果不是外部的，则必须初始化常量对象

const变量的初始值值可以是任意复杂的表达式

![2021020713035770.png][]

**C与CPP的const之间最大的区别是如果CPP中的const初始化为寄存器常量，就会像define一样优化，如果是初始化为内存变量，编译器就不会去优化**

#include <iostream>
    #include <array>
    #include <algorithm>
    void main()
    {
    	const int num{10};
    	*(int *)&num = 3;
    	std::cout << num << std::endl;  //10
    	std::cout << *(&num) << std::endl;//10
    
    	int a{ 10 };
    	const int num1{ a };
    	*(int *)&num1 = 3;
    	std::cout << num1 << std::endl;  //3
    	std::cout << *(&num1) << std::endl;//3
    	std::cin.get();
    }

原因：如果是寄存器常量初始化const变量，寄存器直接优化，使用10替换；如果是用内存变量初始化const变量，寄存器不敢优化，必须老老实实读内存。

总结

*  编译器会将const表示修饰的是一个伪常量，不可以直接或者间接修改
 *  const修饰的常量必须初始化，最好使用\{\}初始化成一样的数据类型，建议使用\{\}而不是()初始化，因为\{\}会检查收缩转换
 *  const修饰的名字如果用寄存器常量如10初始化那么它是一个常量，如果用变量初始化那么它是一个变量。也就是说，如果是用寄存器常量修饰const变量，那么编译器就会自动优化成一个常量，如果是内存变量初始化const变量，编译器就不敢随便优化了

const与别名：

![20210207150414145.png][]

关于const pstring \*ps

*  ps是一个指针，指向的类型由下一个符号决定
 *  const是对给定类型的修饰，而pstring实际上就是一个类型，表示指向char的指针，因此，const修饰的是pstring，即const pstring就是指向常量的指针

## const与迭代器 ##

STL迭代器是以指针为根据塑造处理的，所以迭代器的作用就像个T\*指针。声明迭代器  
为const就像声明指针为const指针一样\[T \*const\]。表示这个迭代器不得指向不同的东西，但是它  
所指向的东西是可以改变的。如果希望迭代器所指的东西不可以被改变。\[const T\*\]，需要const\_iterator

#include <vector>
    int main()
    {
    	std::vector<int>vec;
    	const std::vector<int>::iterator iter = vec.begin();
    	/*声明迭代器为const[迭代器本身不变]->声明指针为const：指针位置固定，迭代器位置固定。迭代器不可以指向别的东西*/
    	//iter++; error
    	*iter = 5;
    	std::vector<int>::const_iterator cIter = vec.begin();
    	/*声明迭代器所指东西为const[迭代东西不变]->声明指针所指东西为const：指针所指东西不变，迭代器所指东西不变*/
    	//*cIter = 9;  迭代所指东西
    	cIter++;  //迭代器本身
    	system("pause");
    }

# C++中const与强制转换 #

C风格的强制转换

> 为什么下面的结果会是那样，没有想明白

const int num = 5;           /*是一个右值，有内存实体*/
        const int *pnum0 = &num;    //内存初始化，因此不优化
        int *pnum1 = (int *)&num;      //C风格强制转换
        *pnum1 = 55;                   
    	cout << pnum0 << "\t"<< pnum1 << "\t"<< &(*pnum1) << endl  // 0x7ffe487a6b7c	0x7ffe487a6b7c	0x7ffe487a6b7c  --->  pnum0 = pnum1 = &(*pnum1),他们指向同一块内存
       << *pnum0  << "\t"<<  *pnum1 << "\t"<< num << endl ;  //55	55	5

![20210207140818378.png][]

const int num = 5;
        int *pnum2 = const_cast<int *>(&num);  //强制去掉const属性
        const int *pnum0 = &num;
        *pnum2 = 55;
        cout << pnum0 << "\t" << pnum2 << "\t" << &(*pnum2) << "\t" << &num << endl
            << *pnum2 << "\t" << num << endl;
        //pnum0 = pnum1 = &(*pnum1),他们指向同一块内存
        //*pnum1 = 55，num = 5

**不可能通过强制类型转换修改const的值**

为什么要这样设计：

#include <iostream>
    
    using namespace std;
    
    
    /*去银行存钱，你传入的是变量，但是存钱程序必须传入让你的钱变成常属性，以防止被人恶意修改
    可以给一个可读写内存临时限制为只读内存，可以将一个只读内存限制为只读内存const int & c
    */
    int Sele(const int & c)
    {
        //c -= 100; // ERROR
        cout << &c << endl;
    
        return c;
    }
    
    // 
    int Sele1(const int & c)
    {
        int z = const_cast<int &>(c);  //强制去掉const属性.推测：重新开辟一段内存，将c的数据复制到新内存，新内存没有const属性，可以修改。但是原来的内存仍是const
        z += 1;  
        cout << &z << endl;
        return z;
    }
    int  main()
    {
        //强引用
        const int num1 = 100;
        int num2 = 100;
        cout << "const int \t"<< &num1  << "\t" << Sele1(num1) << "\t" << num1 << endl;
        cout << "      int \t"<<  &num2 << "\t" << Sele1(num2)  << "\t" <<num2 << endl; // //num2和c的地址相同，引用操作的是同一块内存，只是在作为传参时给这块内存加入一个只可以读的权限，不让被人去修改这块内存
    
    }

总结：C与CPP的const之间最大的区别是如果CPP中的const初始化为寄存器常量，就会像define一样优化，如果是初始化为内存变量，编译器就不会去优化

# const的引用 #

可以把引用绑定到const对象上，这个叫做对常量的引用

**指向常量的引用仅仅要求不能通过该引用改变对象的值，但是没有规定那个对象的值不能通过其他途径改变**

![20210207131750787.png][]

![20210207131757787.png][]

![20210207131927240.png][]

![20210207132244479.png][]

# const与指针 #

**指向常量的指针仅仅要求不能通过该指针改变对象的值，但是没有规定那个对象的值不能通过其他途径改变**

![20210207133024220.png][]

![20210207133031287.png][]

指针是对象而引用不是，因此允许把指针本身定义为常量。**常量指针必须初始化，而且一旦初始化完成，则它就不能改变它的指向**

![20210207133603879.png][]

![20210207134001755.png][]

阅读变量时要从右往左读，比如 int \*const curErr：

*  离curErr最近的是const，表示curErr是一个常量对象，表示它的值一旦决定了就不能在改变。对象的类型由声明符的其他部分决定
 *  声明符的下一个符号是\*，表示curErr是一个常量指针对象。它的值应该是一个地址，这个地址能够存放什么内容由下一个符号决定
 *  而下一个符号是int，表示只能指向一个int内存

const int \*p0：

*  离p0最近的是\*，表示它是一个指针，它的值应该是一个地址，这个地址能够存放什么内容由下一个符号决定
 *  而下一个符号是int，表示只能指向一个int内存
 *  在下一个符号是const，表示我们不能通过p0去改变它指向的变量的值

**一个准则：非常量可以转换为常量，反之不行**

![20210207134731384.png][]

![20210207134817117.png][]

![20210207134832177.png][]

![20210207135118658.png][]

#include <iostream>
    #include <array>
    #include <algorithm>
    void main()
    {
    	const int a{ 1 };  //会优化
    	const int b{ 4 };
    	int c{ 6 };
    	const int *p{ &a };  //p是变量，指向一个常量
    						 //*p = 12;   //error：*p是一个常量
    	p = &b;   //p是一个变量，可以改变指向
    	p = &c;
    	c = 11;    //c仍然是一个整形变量
    	std::cout << c << std::endl;  //11
    								  // *p = 12;   //error：*p是一个常量
    	std::cin.get();
    }
    
    
    
    #include <iostream>
    #include <array>
    #include <algorithm>
    void main12()
    {
        const int a{ 1 };  //会优化
        const int b{ 4 };
        int c{ 6 };
        int d{ 0 };
        //int * const p{ &a };  //p是指针常量，不可以改变指向，而且是指向一个int类型的变量
        int * const p{ &c };
        //p = &d;
        *p = 22;  //改变c
        std::cout << c << std::endl;  //22
        c = 11;
        std::cout << c  << std::endl; //11
        std::cin.get();
    }

# cosntexpr与常量表达式 #

常量表达式是指值不会改变并且在编译过程就能得到计算结果的表达式。比如：字面值

一个对象（或者表达式）是不是常量表达式由它的数据类型和初始值共同决定：

*  虽然staff\_size的初始值是个字面量常量，但是由于它的数据类型只是一个普通int而不是const int，所以它不是常量表达式
 *  虽然sz本身是一个常量，但是它的具体值直到运行时才能获取到，所以它也不是常量表达式

![20210207142505223.png][]

# ![20210207142526547.png][] #

我们基本上不可能分配出一个初始值是不是常量表达式，因此C++11中引入了**constexpr**类型以让编译器来验证变量是不是一个常量表达式。

声明为constexpr的变量一定是一个常量，而且必须由常量表达式初始化：

![20210207142851617.png][]

常量表达式的值需要在编译时就得到计算，因此对声明constexpr时用到的类型必须有所限制。因为这些类型一般比较简单，值也容易得到，就将它们称为 字面量

*  算术类型、引用、指针是字面值类型
    
     *  一个constexpr指针的初始值必须是nullptr或者0，或者是储存于某个固定地址中的对象
     *  函数体内定义的变量一般来说并非存放在固定地支中，因此constexpr不能指向这样的变量
     *  定义于所有函数体之外的对象其地址固定不变，能用来初始化constexpr指针
     *  允许函数定义一类有效范围超出函数本身的变量，这类变量和定义在函数体之外的变量一样有固定地址，因此，它们能用来初始化constexpr指针和constexpr引用
     *  在constexpr声明中如果定义了一个指针，constexpr符号只对指针有效，与指针所指的对象无关

![20210207143758689.png][]

*  自定义类、IO库、string类想不是字面值类型，因此这些值也不能被定义成constexpr

# const的作用域 #

**const默认只在本文件内部有效，它的作用域是文件作用域，除非使用extern扩展它的作用域**

*  默认情况下，全部变量的链接性是外部的，但是const全局变量的链接性是内部的。也就是说，在C++看来，全局const就像使用了static一样

1 第一个验证：const的作用域是文件作用域

test.cpp

const int a = 4;

main.cpp

#include <iostream>
    using namespace std;
    const int a = 3;
    void main()
    {
    	cout << a << endl;  //3,const的作用域是文件作用域
    	cin.get();
    }

2 第二个验证：extern const

main.cpp

#include <iostream>
    
    using namespace std;
    extern const int a{3};  //声明+初始化 = 定义，可以在其他文件找不到，声明其他文件可以使用a
    
    void main()
    {
    	cout << a << endl;  //3,const的作用域是文件作用域
    	cin.get();
    }

3 第三个验证：如果要使用const 变量，可以和extern结合

test.cpp

#include <iostream>
    extern const int a ;
    void test()
    {
    	std::cout << a << std::endl;  //必须先在本文件内声明为外部变量或者定义
    
    }

main.cpp

#include <iostream>
    #include "head.h"
    
    extern const int a{3};  //声明+初始化 = 定义，可以在其他文件找不到，声明其他文件可以使用a
    
    void main()
    {
    	std::cout << a << std::endl;  //3,const的作用域是文件作用域
    	test();      
    	std::cin.get();
    }

#  #

[2021020713035770.png]: /images/20220518/5fcbd8e307d14750bd7008b6db72e35f.png
[20210207150414145.png]: /images/20220518/7d1d591fa0524b6aa638b5d9ec7700db.png
[20210207140818378.png]: /images/20220518/f18c2b032adf4442a256fdd14094816d.png
[20210207131750787.png]: /images/20220518/ff16bb2c8d9c4f359dfc701a14094086.png
[20210207131757787.png]: /images/20220518/6566bb076cb94847bb80f60e4daab792.png
[20210207131927240.png]: /images/20220518/6e8a3d35e0f14f7dae303f4b6ca57db7.png
[20210207132244479.png]: /images/20220518/04c0727420a543c98fa6c5ca790e0fdb.png
[20210207133024220.png]: /images/20220518/e7b43ac2c2b64d8582f3776e0f8fe863.png
[20210207133031287.png]: /images/20220518/1d9d79d612c14be49f376062855fe870.png
[20210207133603879.png]: /images/20220518/25886a2d91114fcdbf9040caf09df08d.png
[20210207134001755.png]: /images/20220518/6ce92803b32c47e69dc07c0c71efbb2e.png
[20210207134731384.png]: /images/20220518/b4aa77d317734931ab777dc156a19ccf.png
[20210207134817117.png]: /images/20220518/d7482ce087784291b8e07f8db0a14a6b.png
[20210207134832177.png]: /images/20220518/a5a1e5860cea4173bad2efa6a5681de3.png
[20210207135118658.png]: /images/20220518/45792d9ce765473f9d5a5aab3e0e3d27.png
[20210207142505223.png]: /images/20220518/8fcd9e8b2fc340ab80dbe9a8b4bc13b2.png
[20210207142526547.png]: /images/20220518/17f10092db6e4822ac513d34b740ad55.png
[20210207142851617.png]: /images/20220518/310aca00926140a2ae207463139c9682.png
[20210207143758689.png]: /images/20220518/483b79fdf0594385b4c7058dedfee7c8.png