C++ const成员函数

Jason_from_China

已于 2024-09-25 14:14:35 修改

阅读量972

点赞数 7

分类专栏： C++知识点的补充文章标签： c++ 开发语言

于 2024-09-25 14:13:04 首次发布

本文链接：https://blog.csdn.net/Jason_from_China/article/details/142516393

版权

C++知识点的补充专栏收录该内容

22 篇文章 0 订阅

订阅专栏

个人主页：Jason_from_China-CSDN博客

所属栏目：C++系统性学习_Jason_from_China的博客-CSDN博客

所属栏目：C++知识点的补充_Jason_from_China的博客-CSDN博客

C++ const引用常量

使用规则

引用常量对象：可以引用一个常量对象，但必须使用常量引用（const引用）。这是因为常量引用保证了不会通过引用来修改被引用的对象。

常量引用的灵活性：常量引用不仅可以引用常量对象，也可以引用普通（非常量）对象。这是因为引用的权限可以缩小（即常量引用可以绑定到非常量对象），但不能放大（即非常量引用不能绑定到常量对象）。

引用临时对象：在某些表达式中，如 int& rb = a * 3; 或 int& rd = static_cast<int>(d);，表达式的结果可能被存储在临时对象中。这些临时对象是未命名的，由编译器创建用于存储表达式的结果。

临时对象的常性：C++标准规定，临时对象是常量，因此不能通过非常量引用来引用它们。只有常量引用可以绑定到临时对象。

权限放大问题：尝试通过非常量引用来引用临时对象会导致编译错误，因为这相当于权限放大，违反了C++的引用规则。

临时对象的定义：临时对象是编译器为了存储表达式的求值结果而创建的未命名对象。它们在表达式结束后通常会立即销毁，但通过常量引用可以延长其生命周期。

C++ const引用，权限放大问题

权限放大是问题，因为是不允许权限放大的

const会修饰的变量只能是可读的

#include<iostream>
#include<stdio.h>
int main()
{
	
	//不能进行权限放大，但是我们可以进行权限平移
	const int& a22 = a11;
	cout << "a22=" << a22 << endl << endl;
	cout << "&a11=" << &a11 << endl << "&a22=" << &a22 << endl << endl;//此时我们发现，地址依旧是一样的，因为这是一个别名的引用

	return 0;
}

C++ const引用，权限缩小

权限缩小不是问题，因为是允许权限缩小的

#include<iostream>
#include<stdio.h>
int main()
{

	//权限的缩小
	int a33 = 10;
	++a33;
	cout << "a33=" << a33 << endl;
	const int& a44 = a33;//此时权限缩小
	//++a44;//此时报错,因为权限缩小之后，内容不可修改
	cout << "&a33=" << &a33 << endl << "&a44=" << &a44 << endl << endl;

	return 0;
}

单纯的拷贝不存在权限问题

这里就是一个单纯的拷贝，没有引用，不存在权限问题

const可以给常量取别名

给常量取别名的意义

保护数据：通过使用 const 引用，可以确保函数不会意外修改传入的常量参数。
提高效率：对于大型的数据结构，使用 const 引用作为函数参数可以避免不必要的拷贝，提高程序的运行效率。
延长生命周期：对于临时对象，使用 const 引用可以延长其生命周期，使其在引用的生命周期内保持有效。
const int original = 10; // 定义一个常量

const int& ref = original; // 用const引用给常量取别名
const int& refToTemp = 100; // 正确：临时对象可以绑定到const引用
// int& nonConstRef = 100; // 错误：临时对象不能绑定到非const引用

const引用（类型转化导致产生临时变量）

在C++中，"类型转换产生临时变量" 指的是在某些表达式中，由于类型不匹配，编译器会创建一个临时对象来存储表达式的结果，以便能够进行后续的操作。这个临时对象通常是一个右值（r-value），它只能被绑定到 const 引用上。

注意（后面拷贝构造会进行讲解）：

拷贝也会产生临时对象
传值返回，表达式的结果中间都会产生临时对象

C++ const修饰变量

前言

const在星号左边修饰的是指向的内容

const在星号的右边修饰的是指针本身，但是实参

修饰指针的const不存在权限问题

只有指向内容的const才有权限问题

权限的缩小
#include<iostream>
using namespace std;
//const修饰变量
class Date
{
public:
	Date();
	//void _print(Date* const this)
	void _print() 
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date::Date()
{
	 _year = 1;
	 _month = 1;
	 _day = 1;
}


int main()
{
	Date d1;
	d1._print();
	return 0;
}
这里有一个经典的权限缩小的问题，图解：

类里面的函数的带有this指针的，但是这里的指针是不能修饰内容的，所以一般是指向修饰的指针，我们在函数调用之前这里对象是可以修改可以读写的，但是调用函数之后就产生了变化，从而产生了权限的缩小

权限的放大问题导致报错

代码

这里显示报错，解释：

这里的关键在于，这里创建对象的时候我们用const进行了修饰，也就是导致这里构造成功之后是无法进行更改的，但是我们调用printf函数的时候，这里修饰的不是内容，也就是内容还是可读可写的，所以会导致权限的放大，在编译器里面，权限的放大是不允许的，但是权限的缩小是可以的

解决办法：
#include<iostream>
using namespace std;
//const修饰变量
class Date
{
public:
	Date();
	//void _print(Date* const this)
	void _print() const
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date::Date()
{
	 _year = 1;
	 _month = 1;
	 _day = 1;
}


int main()
{
	Date d1;
	d1._print();
	
	const Date d2;
	d2._print();

	return 0;
}
此时我们发现编译器就不报错了，我们在函数后面加上const

这里加上const的意思就是，等同于在指针左边加上const，内容是不允许修改了，也就是此时变成只能读不能写了，此时就是权限的平移

这里在日期类的实现里面体现的很深入