const关键字用法

wangwen18

已于 2022-04-20 18:05:11 修改

阅读量1.4k

点赞数 2

分类专栏： C++ 文章标签： c++

于 2022-04-19 16:31:37 首次发布

本文链接：https://blog.csdn.net/wangwen18/article/details/124276664

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、常对象

1.先定义一个类

class Time
{
public:
	Time(int,int,int);   	//构造函数
	void set_time();
	void show_time();
private:
	int hour;
	int minute;
	int sec;
};

Time::Time(int h,int m,int s)
{
	hour = h;
	minute = m;
	sec = s;
}

void Time::set_time()
{
	cin >> hour;
	cin >> minute;
	cin >> sec;
}

void Time::show_time()
{
	cout <<hour<<":"<<minute<<":"<<sec<<endl;
}

2.希望保证对象的数据成员不被改变，可以将这个对象声明为常对象，格式：

//类名 const 对象名[(实参列表)]
Time const t1(12,34,46);

也可以把 const 写在最左边

//const 类名 对象名[(实参列表)]
const Time t1(12,34,46);

1）在定义常对象时，常对象必须要有初始值。
2）如果一个对象被定义为常对象，则不能调用该对象的非 const 型的成员函数（除了系统自动调用的隐式构造函数、析构函数）
记忆：因为调用对象的非 const 型成员函数有可能改变对象里面的数据，而这是不被允许的（即使函数实际没有改变数据）。
例如以下使用非法：

const Time t1(10,15,36);  //定义常对象
t1.show_time();			  //调用非 const 成员函数，非法

3）如果成员函数声明为 const ，就可以调用：

void show_time() const; //注意 const 在函数名和括号之后

这表示 show_time 是一个const 型函数，即常成员函数（常成员函数可以访问常对象中的数据成员，但是不允许修改常对象中数据成员的值）
4）如果常对象中的某个数据成员的值的确需要修改，加 mutable
比如想修改成员变量 hour 的值：

mutable int hour;

这样就可以用声明为 const 的成员函数来修改 hour 的值。

二、常对象成员

可以将对象的成员声明为 const ，包括常数据成员和常成员函数。

1.常数据成员

用关键字 const 来声明常数据成员，其作用与用法跟一般常变量相似。
只能通过构造函数的参数初始化表对常数据成员进行初始化。
例如：

class Time
{
public:
	Time(int,int,int);   	//构造函数
	void set_time();
	void show_time();
private:
	const int hour;
	int minute;
	int sec;
};

只能通过构造函数的初始化列表对 hour 初始化

Time::Time(int h,int m,int s):hour(h),minute(m),sec(s)
{
}

2.常成员函数

常成员函数只能引用本类中的数据成员，而不能修改它们。
常成员函数可以引用 const数据成员，也可以引用非const数据成员。
//注意 const 在函数名和括号之后

void show_time() const; //注意 const 在函数名和括号之后

const是函数类型的一部分，在声明函数和定义函数时都要有 const关键字。
用法：
（1）如果在一个类中，有些数据成员的值允许改变，另一些数据成员的值不允许改变，则可以将一部分数据成员声明为const，以保证其值不被改变，可以用非const的成员函数引用这些数据成员的值，并修改非const数据成员的值。
（2）如果要求所有的数据成员的值都不允许改变，则可以将所有的数据成员声明为const，或将对象声明为const常对象，然后用const成员函数引用数据成员，这样起到双保险的作用，切实保证数据成员不被修改。
（3）如果已定义了一个常对象，只能调用其中的const成员函数，而不能调用非const成员函数（不论这些函数是否会修改对象中的数据）。这是为了保证数据的安全。如果需要访问对象中的数据成员，可将常对象中所有成员函数都声明为const成员函数，但应确保在函数中不修改对象中的数据成员。

不要误认为常对象中的成员函数都是常成员函数。常对象只保证其数据成员是常数据成员。如果在常对象中的成员函数未加const声明，编译系统把它作为非const成员函数处理。

三、指向对象的常指针

将指针变量声明为const型，这样指针值始终保持为其初值，不能改变。

Time t1(10,12,15);
Time t2(10,12,15);
Time * const ptr;  //const 在指针变量前面，规定 ptr 的值是常值
ptr = &t1;		   // ptr指向t1,此后不能再改变指向
ptr = &t2;		   // 错误，ptr不能再改变指向

定义指向对象的常指针格式：
类名 * const 指针变量名
也可以在定义指针变量时直接初始化：

Time * const ptr = &t1;  //定义指针变量时直接初始化

四、指向常对象的指针变量

为便于理解，先了解指向常变量的指针变量。

1.指向常变量的指针变量

1）定义一个指向常变量的指针变量 ptr

const char *ptr;

注意：const在最左边，它与类型名char紧连

2）如果一个变量已被声明为常变量，只能用指向常变量的指针变量指向它，而不能用普通的指针变量指向它。
例如：

const char c[] = "boy";
const char *p1 = c;    //合法
char *p2 = c;          //非法

记忆：用指向非const变量的指针指向常变量后，正常是可以通过这个指针改变变量的值的，而变量是常变量，不允许改变，矛盾。

3）指向常变量的指针除了可以指向常变量，还可以指向普通变量，但是不能通过此指针改变该变量的值。

int a = 3;        //定义了一个普通变量（非常变量）
const int *p1;    //定义了一个指向常变量的指针变量 p1
p1 = &a;          //合法
*p1 = 5;          //非法（不能通过 p1 改变变量 a 的值）
a = 5;            //合法

记忆：指向常变量的指针，指向普通变量后，这个指针也不会改变普通变量的值，不矛盾；

4）如果函数的形参是指向非 const 型变量的指针，例如：

void fun(int *ptr) //函数的形参指向非 const 型变量的指针
{
    qDebug("%d",*ptr);
}

实参只能用指向非 const 变量的指针

int b = 88;
int *p = &b;   //指向非 const 变量的指针
fun(p);

记忆技巧：
①函数的形参是指向非 const 型变量的指针，表示函数里面可以通过这个指针改变这个变量的值。
②实参如果通过一个指针代入了一个变量，那么这个变量应该也允许改变。
在这里插入图片描述
运行结果：

③实参如果通过一个指针代入了常变量（使用指向常变量），那函数里面通过指针修改这个变量就非法了（不论函数实际有没有修改它），所以就出错了。

理解：
形参和实参指向同一变量。形参指向非const变量（变量值可通过指针改变），而实参指向const变量（变量值不允许通过指针改变），矛盾了。
因此C++要求实参用非const变量的地址（或指向非const变量的指针）。

5）如果函数的形参是指向 const 型变量的指针，表示我函数里面绝对不会改变这个变量的值，这时候实参不论是不是const变量都可以
在这里插入图片描述

2.指向常对象的指针变量

指向常对象的指针变量用法跟上面指向常变量一样。
1）如果一个变量已被声明为常对象，只能用指向常对象的指针变量指向它，而不能用普通的指针变量指向它。
记忆：用指向非const对象的指针指向常对象后，正常是可以通过这个指针改变对象的值的，而对象是常对象，不允许改变，矛盾。
2) 如果定义了一个指向常对象的指针变量，并使它指向一个非 const 的对象，则其指向的对象是不能通过指针来改变的。
记忆：指向常对象的指针，指向普通对象后，这个指针也不会改变普通对象的值，不矛盾；

Time t1(10,12,15);
const Time *p = &t1;  // 定义一个指向常对象的指针，指向了非const对象
t1.hour = 18;         //合法，t1不是常对象
(*p).hour = 18;       //不合法，p是指向常对象的指针

如果希望在任何情况下 t1 的值都不能改变，则应把它定义为 const型，如：

const Time t1(10,12,15);

指向常对象的指针最常用于函数的形参，目的是在保护形参指针所指向的对象，使它在函数执行过程中不被修改。如：

int main()
{
	void fun(const Time *p); //形参是指向常对象的指针变量
	Time t1(10,13,56); 		 //定义Time类对象t1，它不是常对象
	fun(&t1);  				 //实参是对象t1的地址
	return 0;
}

void fun(const Time *p)
{
	p->hour = 18;        //非法，p是指向常对象的指针
	cout<<p->hour<<endl;
}

4）如果定义了一个指向常对象的指针变量，是不能通过它改变所指向的对象的值，但是指针变量本身的值是可以改变的。如：

const Time *p = &t1;  //定义指向常对象的指针变量p,并指向对象t1
p->hour = 10; 		  //非法
p = &t2;			  //合法

五、对象的常引用

#include <iostream>
using namespace std;

class Time
{
public:
	Time(int,int,int);   	//构造函数
	int hour;
	int minute;
	int sec;
};

Time::Time(int h,int m,int s)
{
	hour = h;
	minute = m;
	sec = s;
}

void fun(Time &t)   //形参 t 是 Time 类对象的引用
{
	t.hour = 18;
}

int main()
{
	Time t1(10,13,56); 		//t1是Time 类对象
	fun(t1);           
	cout<<t1.hour<<endl;	//输出 t1.hour的值为18
	return 0;
}