前言

const c语言和c++中的区别

以下程序可说明，c中const为常变量，c++中为常量，在用到const定义的值是将被初始值进行替换。

#include "stdio.h"


int main()//这个是cpp文件
{
	const int a = 10;
	int *p =(int *) &a;
	*p = 30;
	printf("%d %d  %d\n", a, *p, *(&a));//在C中 是30 30 30；在C++中 是10 30 10

}

我们把上面的程序改变一下，那么c++中打印的和c中打印的是相同的，因为这里的a变成了常变量，不再是常量。

#include "stdio.h"


int main()//这个是cpp文件
{
	int b = 20;
	const int a = b;
	int *p =(int *) &a;
	*p = 30;
	printf("%d %d  %d\n", a, *p, *(&a));//在C中 是30 30 30；在C++中 是30 30 30

}

以下介绍是c++中的const

const 是 constant 的缩写，本意是不变的，不易改变的意思。在 C++ 中是用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。const的用法很灵活，使用const可提高程序的健壮性，const修饰的量，称为常量，它和普通变量有什么区别呢？主要包括两点:1.编译方式不同。2.不能作为左值。

1.修饰普通类型变量

const修饰普通类型的变量，有以下两种形式，这两种形式本质上是相同的。const修饰的类型是Type的变量的不可变的，const 变量必须被初始化。

1.Type const VarName = value;
2.const Type VarName = value;

例子1，a 被定义为一个常量，并且可以将 a 赋值给 b，但是不能给 a 再次赋值。对一个常量赋值是违法的事情，因为 a 被编译器认为是一个常量，其值不允许修改。

const int  a = 7; 
int  b = a; // 正确
a = 8;       // 错误，不能改变

例子2，对于 const 变量 a，我们取变量的地址并转换赋值给 指向 int 的指针，然后利用 *p = 8; 重新对变量 a 地址内的值赋值，然后输出查看 a 的值。从下面的调试窗口看到 a 的值被改变为 8，但是输出的结果仍然是 7。这是因为在用到a的地方，编译器会直接替换成初始值。

#include<iostream>
 
using namespace std;
 
int main(void)
{
    const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;   // 打印结果为7
    system("pause");
    return 0;
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2JFy6CS2-1625192952103)(./doc/img/image-20210630224334359.png)]

如果我们想到改变以上a的值，可使用Volatile关键字，例如：

#include<iostream>
 
using namespace std;
 
int main(void)
{
    volatile const int  a = 7;
    int  *p = (int*)&a;
    *p = 8;
    cout<<a;  // 打印结果为8
    system("pause");
    return 0;
}

还可以在const的前面加extend表示将const改为外部连接，作用是扩大到全局，编译时会分配内存,并且可以不进行初始化,仅仅作为声明,编译器认为在程序其他地方进行了定义。

extend const int VarName = value;

2.修饰指针变量

const修饰的量常见出现的错误:

1. 常量不能作为左值，因为此可直接修改常量的值。
2. 不能把常量的地址泄露给一个普通的指针或者普通的引用变量，因为可以间接修改常量的值。

#include "stdio.h"

int main()
{
	const int a = 10;
	a = 20;   // 错误
	int *p = &a;  // 错误   int* <= const int *

}

const和一级指针的结合

说明：c++语言规范，const修饰的是离它最近的类型。

可有四种组合形式：

1. const int *p = 8; const 修饰指针指向的内容，则内容为不可变量。
2. int const * p; 离const最近的有* 和int，其中*不能作为类型，所以离const最近的类型为int，因此它和第一种相同。
3. const 修饰指针，则指针为不可变量。int * const p ;
4. const 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。 const int * const p

对于第一种和第二种：指针指向的内容 8 不可改变。

const int *p = 8;
*p = 9; // 错误

对于第三种：const 指针 p 其指向的内存地址不能够被改变，但其内容可以改变。

int a = 8;
int* const p = &a;
*p = 9; // 正确
int  b = 7;
p = &b; // 错误

对于第四种：const 指向的内容和指向的内存地址都已固定，不可改变 。

int a = 8;
const int * const  p = &a;

const 和二级指针的结合

可有三种结合的方式：

1. const int ** q **q不能被赋值
2. int * const * q *q不能被赋值
3. int ** const q q不能被赋值

3.类型转换

const和指针的类型转换

不能把常量的地址泄露给一个普通的指针或者普通的引用变量。

const 如果右边没有指针*的话，const是不参与类型的，如下代码，

	int *p1 = nullptr;
	int * const p2 = nullptr;
	cout << typeid(p1).name << endl;   // int *
	cout << typeid(p1).name << endl;   // int * 这里不要认为是int * const

4.引用

引用和指针的区别？

• 引用是一种更安全的指针
• 引用是必须初始化的，指针可以不初始化
• 引用只有一级，指针有一级及多级
• 定义一个引用变量和定义一个指针变量，其汇编指令是相同的，通过引用修改所引用内存的值，和通过指针解引用修改指针指向内存的值，其底层是相同的。

	int array[5] = { };
	int (&p) [5] = array;
	int * q = array;

	cout << sizeof(array) << endl;  // 20  
	cout << sizeof(p) << endl;      // 20
	cout << sizeof(q) << endl;      //4

左值引用和右值引用

**左值：**其有内存，有名字，值可以修改的，例如 int a = 10;

**右值：**没内存，没名字。如：20，不能20=10；

c++11 右值引用: int && c = 20; 专门用来引用右值类型，指令上，可以自动产生临时量。

一个右值引用变量，本身是一个左值，因为其有命名，有内存，如下可以看出：

	int && c = 20;
	int &b = c;

右值引用是需要引用一个右值的，不能引用一个左值

	int a = 20;
	int && e = a;  // 错误
	int && e = 20;  //正确

3.函数中使用

const在函数参数中的使用可分为三种情况：

1.值传递时，const修饰，一般这种情况不需要const修饰，因为函数会自动产生临时变量复制实参值

#include<iostream>
 
using namespace std;
 
void Cpf(const int a)
{
    cout<<a;
    // ++a;  是错误的，a 不能被改变
}
 
int main(void)
 
{
    Cpf(8);
    system("pause");
    return 0;
}

2.当 const 参数为指针时，可以防止指针被意外篡改。

#include<iostream>
 
using namespace std;
 
void Cpf(int *const a)
{
    cout<<*a<<" ";
    *a = 9;
}
 
int main(void)
{
    int a = 8;
    Cpf(&a);
    cout<<a; // a 为 9
    system("pause");
    return 0;
}

3.自定义类型的参数传递，需要临时对象复制参数，对于临时对象的构造，需要调用构造函数，比较浪费时间，因此我们采取 const 外加引用传递的方法。并且对于一般的 int、double 等内置类型，我们不采用引用的传递方式。(why)

#include<iostream>
 
using namespace std;
 
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
 
private:
    int _cm;
};
 
 
 
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
 
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

对于 const 修饰函数的返回值

1.const 修饰内置类型的返回值，修饰与不修饰返回值作用一样。

#include<iostream>
 
using namespace std;
 
const int Cmf()
{
    return 1;
}
 
int Cpf()
{
    return 0;
}
 
int main(void)
{
    int _m = Cmf();
    int _n = Cpf();
 
    cout<<_m<<" "<<_n;
    system("pause");
    return 0;
}

2.const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改。

3.const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。 todo例子

4.修饰类成员函数

const 修饰类成员函数，其目的是防止成员函数修改被调用对象的值，如果我们不想修改一个调用对象的值，所有的成员函数都应当声明为 const 成员函数。

**注意：**const 关键字不能与 static 关键字同时使用，因为 static 关键字修饰静态成员函数，静态成员函数不含有 this 指针，即不能实例化，const 成员函数必须具体到某一实例。

下面的 get_cm()const; 函数用到了 const 成员函数：

#include<iostream>
 
using namespace std;
 
class Test
{
public:
    Test(){}
    Test(int _m):_cm(_m){}
    int get_cm()const
    {
       return _cm;
    }
 
private:
    int _cm;
};
 
 
 
void Cmf(const Test& _tt)
{
    cout<<_tt.get_cm();
}
 
int main(void)
{
    Test t(8);
    Cmf(t);
    system("pause");
    return 0;
}

如果 get_cm() 去掉 const 修饰，则 Cmf 传递的 const _tt 即使没有改变对象的值，编译器也认为函数会改变对象的值，所以我们尽量按照要求将所有的不需要改变对象内容的函数都作为 const 成员函数。

如果有个成员函数想修改对象中的某一个成员怎么办？这时我们可以使用 mutable 关键字修饰这个成员，mutable 的意思也是易变的，容易改变的意思，被 mutable 关键字修饰的成员可以处于不断变化中，如下面的例子。

#include<iostream>
using namespace std;
class Test
{
public:
    Test(int _m,int _t):_cm(_m),_ct(_t){}
    void Kf()const
    {
        ++_cm; // 错误
        ++_ct; // 正确
    }
private:
    int _cm;
    mutable int _ct;
};
 
int main(void)
{
    Test t(8,7);
    return 0;
}

这里我们在 Kf()const 中通过 ++_ct; 修改 _ct 的值，但是通过 ++_cm 修改 _cm 则会报错。因为 ++_cm 没有用 mutable 修饰。

欢迎关注我的公众号“刘望”，原创技术文章第一时间推送。