const关键字的作用及应用场景
文章目录
- 一、常量
- 二、const修饰指针
- (1)const修饰指针——常量指针
- (2)const修饰常量——指针常量:
- (3)const即修饰指针又修饰常量:
- (4)const修饰指针总结
- 三、const修饰结构体
- 四、常量引用
- 五、const修饰成员函数
- (1)常函数
- (2)常对象
一、常量
C++定义常量有两种方式
1. #define 宏常量:#define 常量名 常量值
- 通常在文件上方定义,表示一个常量
- 宏常量不可以修改
- 如:
//1、宏常量
#define MAX 999
int main() {
return 0;
}
2. const修饰的变量: const 数据类型 常量名 = 常量值
- 通常在变量定义前加关键字const,修饰该变量为常量,不可修改
- 常量不可以修改,const限定为只读状态,防止修改操作
- 如:
int main() {
//1、const修饰变量
const int month = 12;
cout << "一年里总共有 " << month << " 个月份" << endl;
return 0;
}
二、const修饰指针
const修饰指针有三种情况:
1. const修饰指针——常量指针( const int *p = &a
)
2. const修饰常量——指针常量( int * const p = &a
)
3. const即修饰指针,又修饰常量(const int * const p = &a
)
(1)const修饰指针——常量指针
常量指针:指针的指向可以修改,但是指针指向的值不可以修改.
(2)const修饰常量——指针常量:
指针常量:指针的指向不可以修改,但是指针指向的值可以修改.
(3)const即修饰指针又修饰常量:
特点:指针的指向不可以修改,指针指向的值也不可以修改.
(4)const修饰指针总结
三、const修饰结构体
作用:用const来防止修改操作
#include <iostream>
#include<string>
using namespace std;
//结构体定义
struct Person
{
string name; //姓名
int age; //年龄
};
//将函数中的形参修改为指针,可以减少内存空间的使用,即不会复制新的副本出来占用空间
void printPerson(const Person *person) //加const防止函数体中的修改操作
{
//stu->age = 100; //操作失败,因为加了const修饰
cout << "姓名:" << person->name << " 年龄:" << person->age << endl;
}
int main() {
Person per = { "张三",18 };
printPerson(&per);
return 0;
}
四、常量引用
作用:常量引用主要用来修饰形参,防止形参改变实参
int & ref = 10 //错误,引用本身需要一个合法的内存空间,10是一个常量
const int & ref = 10// 正确,加上const之后,编译器将代码修改为 int temp = 10; const int & ref = temp;
ref = 30; //错误,此时的ref已经是常量,变为只读状态,所以不可以修改
#include <iostream>
#include<string>
using namespace std;
//打印数据函数
void showValue(const int &val) {
//val = 100; //错误,val现在为只读状态
cout << "val=" <<val << endl;
}
int main() {
//函数中利用常量引用防止误操作修改实参
int a = 10;
showValue(a);
return 0;
}
总结:实际上和const修饰结构体一样,当需要打印数据时,并且当数据量太大,不想复制一份数据到内存空间时,就传一个地址或者引用,此时形参改变,实参也会跟着改变,所以此时需要防止实参被修改!
五、const修饰成员函数
(1)常函数
- 成员函数后加const后我们称为这个函数为常函数
- 常函数内不可以修改成员属性
- 成员属性声明时加关键字mutable后,在常函数中依然可以修改
#include <iostream>
#include<string>
using namespace std;
class Person {
public:
//1、this指针的本质是一个指针常量(Type* const pointer;),指针的指向不可修改,但是指针指向的值可以修改
//2、如果想让指针指向的值也不可以修改,需要声明常函数,即在成员函数后面加上const
void ShowPerson() const
{
m_A = 100; // 错误,函数加上了const,属性不可以修改
/*
1、m_A = 100 的本质是 this->m_A = 100,this指针指向的对象的数据是可以修改的
2、this指针的本质是指针常量,this指针的指向不可以修改,即this = NULL; 错误
3、此处的this指针的本质是指针常量:Person * const this;
*/
/*
1、在成员函数后面加const,修饰的是this指针,让this指针指向的值也不可以修改
2、const Person * const this;指针的指向,以及指针指向的值都不可以修改
*/
this->m_B = 100; //正确,因为加上了mutable关键字
}
public:
int m_A;
mutable int m_B; //加上mutable关键字之后成为特殊变量,即使在常函数中,也可以修改这个值
};
void test01()
{
Person person;
person.ShowPerson();
}
int main()
{
test01();
return 0;
}
(2)常对象
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数,普通对象既可以调用普通成员函数,也可以调用常函数
#include <iostream>
#include<string>
using namespace std;
class Person {
public:
void ShowPerson() const
{
//m_A = 100; // 错误,函数加上了const,属性不可以修改
this->m_B = 100; //正确,因为加上了mutable关键字
}
void func()
{
}
public:
int m_A;
mutable int m_B; //加上mutable关键字之后成为特殊变量,即使在常函数中,也可以修改这个值
};
void test02()
{
const Person p={1,2}; //在对象前加const,变为常对象
//p.m_A = 100; // 错误,常对象不允许修改成员属性
p.m_B=100; // 正确,m_B是特殊值,在常对象下也可以修改
//常对象只能调用常函数
p.ShowPerson(); //正确
p.func(); //错误,因为普通成员函数可以修改成员属性,而常对象的本质是不允许修改成员属性
}
int main()
{
test02();
return 0;
}
小小_飞侠: 不亏是大佬
clmm_: 大佬,只看你的文章把并查集学透了,十分感谢!!!
snh畔: 一看就懂,厉害
LD1219123: 博人不服
while_black: 太厉害了,顶不住啊