【C++】：类和对象（中）：const成员 || 取地址及const取地址操作符重载

news2025/1/11 5:55:26

在这里插入图片描述

📪1.const成员

📪将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改
在这里插入图片描述
🎈首先我们来想一想为什么在C++中我们的输出流能自动识别类型呢？
🎈这里给大家分享一个文档以及我给大家查到的知识
在这里插入图片描述
🎈点击查看官方C++库
在这里插入图片描述
🎈C++委员会已经帮我们写好的C++库 我们只需要写很短小的一截就可以自动识别类型 这是因为函数重载 类型匹配 函数名修饰规则的原因
所以我们标准的cout重载应该按照以下的语法规则书写

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

📟输入的语法规则则为

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

📮见下图能否帮助你理解一下
在这里插入图片描述
在这里插入图片描述
🎓下面给大家总结一下
🎓运算符重载
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似
函数名字为：关键字operator后面接需要重载的运算符符号
函数原型：返回值类型 operator操作符(参数列表)
🎓注意：
不能通过连接其他符号来创建新的操作符：比如operator
重载操作符必须有一个类类型参数
用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现
🎓*注意：.不会涉及 在后面的笔试题中可能会出现 在实际的工作中基本不会遇见

🔫2.取地址及const取地址操作运算符重载

🎾下面我们正式进入今天的主题
来看下面两段代码

//	const对象和非const对象都可以调用const成员函数
//	const Date d1(2023, 10, 31);
//	d1.Print();
//
//	Date d2(2023, 1, 1);
//	d2.Print();

在这里插入图片描述
📢首先要记住一点的就是我们在前面已经讲过了就是权限可以平移和缩小但是不能放大
🔫d1里面传的本质是d1的地址也就是const Date*
而函数调用的参数里面却又是Date* this 所以这里是权限的放大 我们需要添加一个const 那么问题又来了 const加到哪里合适呢？看上面图片和代码
📲只要是不修改成员的日期类对象都可以加上const 这样让我们的const和非const成员都可以传过来 看下面代码

#include "Date.h"

Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;

	if (_year < 1 ||
		_month < 1 || _month > 12 ||
		_day < 1 || _day > GetMonthDay(_year, _month))
	{
		//assert(false);
		Print();
		cout << "日期非法" << endl;
	}
}

void Date::Print() const
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

bool Date::operator==(const Date& y)  const
{
	return _year == y._year
		&& _month == y._month
		&& _day == y._day;
}

// d1 != d2
bool Date::operator!=(const Date& y) const
{
	return !(*this == y);
}

bool Date::operator>(const Date& y) const
{
	if (_year > y._year)
	{
		return true;
	}
	else if (_year == y._year && _month > y._month)
	{
		return true;
	}
	else if (_year == y._year && _month == y._month && _day > y._day)
	{
		return true;
	}

	return false;
}

bool Date::operator>=(const Date& y) const
{
	return *this > y || *this == y;
}

bool Date::operator<(const Date& y) const
{
	return !(*this >= y);
}

bool Date::operator<=(const Date& y)  const
{
	return !(*this > y);
}

int Date::GetMonthDay(int year, int month)
{
	assert(year >= 1 && month >= 1 && month <= 12);

	int monthArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30,31 };

	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
		return 29;

	return monthArray[month];
}

// d1 += 100
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= (-day);
	}

	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);

		++_month;

		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator+(int day) const
{
	Date tmp(*this);
	tmp += day;

	return tmp;
}
// 
// d1 += 100
//Date& Date::operator+=(int day)
//{
//	//Date d = *this + day;
//	//*this = d;
//
//	*this = *this + day;
//	return *this;
//}
//
//Date Date::operator+(int day)
//{
//	Date tmp(*this);
//
//	tmp._day += day;
//	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
//	{
//		tmp._day -= GetMonthDay(tmp._year, tmp._month);
//
//		++tmp._month;
//
//		if (tmp._month == 13)
//		{
//			tmp._year++;
//			tmp._month = 1;
//		}
//	}
//
//	return tmp;
//}

Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += (-day);
	}

	_day -= day;
	while (_day <= 0)
	{
		--_month;
		if (_month == 0)
		{
			--_year;
			_month = 12;
		}

		_day += GetMonthDay(_year, _month);
	}

	return *this;
}

Date Date::operator-(int day) const
{
	Date tmp(*this);
	tmp -= day;

	return tmp;
}

// ++d1
Date& Date::operator++()
{
	*this += 1;
	return *this;
}

// d1++
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}


Date& Date::operator--()
{
	*this -= 1;
	return *this;
}

Date Date::operator--(int)
{
	Date tmp(*this);
	*this -= 1;

	return tmp;
}

// d1 - d2
int Date::operator-(const Date& d) const
{
	// 假设左大右小
	int flag = 1;
	Date max = *this;
	Date min = d;

	// 假设错了，左小右大
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}

	return n * flag;
}

//void Date::operator<<(ostream& out)
//{
//	out << _year << "年" << _month << "月" << _day << "日" << endl;
//}

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return out;
}

istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;

	return in;
}

🚿思考下面问题
📲1. const对象可以调用非const成员函数吗？
📲2. 非const对象可以调用const成员函数吗？
📲解析：能定义成const的成员函数都应该定义成为const 这样对const对象和非const成员来说都可以调用 要修改成员变量的成员函数不能定义成const
📲上述问题归根结底还是我们的权限的放大缩小和平移的问题

//class A
//{
//public:
//    A(int a)
//        :_a(a)
//    {
//        cout << "A(int a = 0)" << endl;
//    }
//private:
//    int _a;
//};
//
//namespace bit
//{
//    class Date
//    {
//    public:
//        //Date(int year, int month, int day)
//        //{
//        //    // 函数体内初始化
//        //    _year = year;
//        //    _month = month;
//        //    _day = day;
//
//        //    //_ref = year;
//        //    //_n = 1;
//        //}
//
//        //Date(int year, int month, int day)
//        //    :_year(year)
//        //    ,_month(month)
//        //    ,_day(day)
//        //    ,_ref(year)
//        //    ,_n(1)
//        //{
//        //    // 初始化列表
//        //    // 
//        //}
//
//        Date(int year, int month, int day)
//           :_year(2)
//           ,_ref(year)
//           ,_n(1)
//           ,_aa(10)
//        {
//            // 剩下3个成员没有在初始化列表显示写出来定义
//            // 但是他也会定义，只是内置类型默认给的随机值
//            // 如果是自定义类型成员会去调用它的默认构造函数
//            
//            // 函数体内初始化
//            _year = year;
//            _month = month;
//            _day = day;
//        }
//
//    private:
//        // 声明
//        int _year = 1; // 缺省值
//        int _month = 1;
//        int _day;
//
//        A _aa;        // 定义类型成员(且该类没有默认构造函数时)
//
//        int& _ref;	  // 引用 ： 必须在定义的时候初始化
//        const int _n; // const ： 必须在定义的时候初始化
//    };
//}

// 初始化列表解决的问题：
// 1、必须在定义的地方显示初始化  引用  const   没有默认构造自定义成员
// 2、有些自定义成员想要显示初始化，自己控制
// 尽量使用初始化列表初始化
// 构造函数能不能只要初始化列表，不要函数体初始化
// 不能，因为有些初始化或者检查的工作，初始化列表也不能全部搞定
// 80-100%初始化列表搞定，还有需要用函数体，他们可以混着用
class Stack
{
public:
    Stack(int n = 2)
        :_a((int*)malloc(sizeof(int)*n))
        ,_top(0)
        ,_capacity(n)
    {
        //...
        //cout << "Stack(int n = 2)" << endl;
        if (_a == nullptr)
        {
            perror("malloc fail");
            exit(-1);
        }

        memset(_a, 0, sizeof(int) * n);
    }

    //...

    int* _a;
    int _top;
    int _capacity;
};

📲上述代码给大家写了一下初始化列表和函数体的运用规则 对于const成员和引用成员必须在初始化列表初始化 不能再函数体内部初始化 初始化列表也可以运用函数 比如malloc 然后在函数体内判断是否为NULL 在进行memset操作
📲来看下面的一道面试题

class A
{
public:
    A(int a)
        :_a1(a)
        , _a2(_a1)
    {}

    void Print() {
        cout << _a1 << " " << _a2 << endl;
    }
private:
    int _a2;
    int _a1;
};

int main() 
{
    A aa(1);
    aa.Print();
}

在这里插入图片描述
🎒根据声明的先后顺序 因此我们这里的_a1=1 _a2是随机值
🎒下篇给大家讲解类和对象下篇 到那是我们就正式结束了我们的类和对象 我们就要正式进入内存管理和模板以及STL的学习了

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1170828.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

421. 数组中两个数的最大异或值 （中等，位运算）

421. 数组中两个数的最大异或值 （中等，位运算）

题目越短越难啊 关键在于要明白如果我们已经知道有一些组合进行异或运算能得到最高位为1的结果&#xff0c;那么最终答案必定在这些组合之中其次异或运算有个性质&#xff0c;ab XOR c 等价于 ba XOR c&#xff0c;因此对于第 k 位能否取到 1 的情况&#xff0c;我们只需要用 …
阅读更多...
349.两个数组的交集+350.两个数组的交集II（set/multiset）

349.两个数组的交集+350.两个数组的交集II（set/multiset）

目录 一、349.两个数组的交集 二、350.两个数组的交集II 一、349.两个数组的交集 349. 两个数组的交集 - 力扣&#xff08;LeetCode&#xff09; class Solution { public:vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {//…
阅读更多...
Redis中Hash类型的命令

Redis中Hash类型的命令

目录 哈希类型的命令 hset hget hexists hdel hkeys hvals hgetall hmget hlen hsetnx hincrby hincrbyfloat 内部编码 Hash类型的应用场景 作为缓存 哈希类型和关系型数据库的两点不同之处 缓存方式对比 Redis自身已经是键值对的结构了,Redis自身的键值对就…
阅读更多...
【论文笔记】Point Cloud Forecasting as a Proxy for 4D Occupancy Forecasting

【论文笔记】Point Cloud Forecasting as a Proxy for 4D Occupancy Forecasting

原文链接&#xff1a;https://arxiv.org/abs/2302.13130 1. 引言 运动规划需要预测其余物体的运动&#xff0c;但相应的感知模块如建图、目标检测、跟踪和轨迹预测通常都需要大量人力标注HD地图、语义标签、边界框或物体的轨迹&#xff0c;难以扩展到大型无标签数据集上。3D点…
阅读更多...
Linux文本编辑器vim使用和配置详解

Linux文本编辑器vim使用和配置详解

vim介绍 ​ vim是Linux的一款文本编辑器&#xff0c;可以用来编辑代码&#xff0c;而且支持语法高亮&#xff0c;还可以进行一系列配置使vim更多样化。也可以运行于windows&#xff0c;mac os上。 ​ vim有多种模式&#xff0c;但目前我们只介绍绝大多数场景用的到的模式&…
阅读更多...
CCF CSP认证 历年题目自练Day43

CCF CSP认证 历年题目自练Day43

题目一 试题编号&#xff1a; 201604-3 试题名称&#xff1a; 路径解析 时间限制&#xff1a; 1.0s 内存限制&#xff1a; 256.0MB 问题描述&#xff1a; 问题描述 　　在操作系统中&#xff0c;数据通常以文件的形式存储在文件系统中。文件系统一般采用层次化的组织形式&…
阅读更多...
NLP之Bert多分类实现案例(数据获取与处理)

NLP之Bert多分类实现案例(数据获取与处理)

文章目录 1. 代码解读1.1 代码展示1.2 流程介绍1.3 debug的方式逐行介绍 3. 知识点 1. 代码解读 1.1 代码展示 import json import numpy as np from tqdm import tqdmbert_model "bert-base-chinese"from transformers import AutoTokenizertokenizer AutoToken…
阅读更多...
深入解析Spring Boot自动配置原理：让你的应用无痛集成

深入解析Spring Boot自动配置原理：让你的应用无痛集成

1.前言 1.1springboot的优势 Spring Boot是一个用于构建独立、生产级的Spring应用程序的开发框架&#xff0c;它在简化配置、提高开发效率、增强功能丰富性等方面具有以下优势&#xff1a; 简化配置&#xff1a;Spring Boot采用了约定优于配置的原则&#xff0c;通过自动配置和…
阅读更多...
Java基于springboot开发的景点旅游项目

Java基于springboot开发的景点旅游项目

演示视频 https://www.bilibili.com/video/BV1cj411Y7UK/?share_sourcecopy_web&vd_source11344bb73ef9b33550b8202d07ae139b 主要功能&#xff1a;用户可浏览搜索旅游景点&#xff08;分为收费和免费景点&#xff09;&#xff0c;购票&#xff08;支持多规格套餐购票&am…
阅读更多...
Unity3D实现页面的滑动切换功能

Unity3D实现页面的滑动切换功能

效果展示 Unity3D实现页面的滑动切换 效果 文章目录 前言一、先上代码二、创建UI1.创建Scroll View如下图&#xff0c;并挂载该脚本&#xff1a;2.Content下创建几个Itme 总结 前言 好记性不如烂笔头&#xff01; 一、先上代码 /*******************************************…
阅读更多...
堆排序--C++实现

堆排序--C++实现

1. 简介 堆排序利用的是堆序性&#xff0c;最小堆进行从大到小的排序。 先建初堆&#xff0c;保证堆序性。将堆顶元素与最后一个元素交换&#xff0c; 就将当前堆中的最大(小)的元素放到了最后后。堆大小递减&#xff0c;再重新调整堆选出第二大&#xff0c;重复上述过程。 2…
阅读更多...
python推导式特殊用法

python推导式特殊用法

嗨喽~大家好呀&#xff0c;这里是魔王呐 ❤ ~! python更多源码/资料/解答/教程等 点击此处跳转文末名片免费获取 字典推导式 >>> dic {x: x**2 for x in (2, 4, 6)} >>> dic {2: 4, 4: 16, 6: 36} >>> type(dic) <class dict>集合推导式 …
阅读更多...
VSCode 的 C/C++ 开发环境的傻瓜级自动部署程序

VSCode 的 C/C++ 开发环境的傻瓜级自动部署程序

软件介绍 VSCode 是一款优秀的编辑器&#xff0c;可以通过各种插件&#xff0c;将其配置成 C/C 开发环境。只是对于初学者而言&#xff0c;配置步骤有点繁琐。 软件 VSCode-Setup(MinGW) 提供了自动下载安装 VSCode 并配置成 C/C 开发环境的功能。无需担心该软件会对系统有额…
阅读更多...
JavaWeb | JavaWeb开发环境相关知识点

JavaWeb | JavaWeb开发环境相关知识点

JavaWeb开发环境相关知识点: 1.C/S结构、B/S结构2.浏览器与服务器的交互模式3.Tomcat安装目录中&#xff0c;比较重要的文件夹/文件4.怎么修改Tomcat端口&#xff1f;5.URL /url / 统一资源定位符 1.C/S结构、B/S结构 网络应用程序中&#xff0c;有 两种基本结构&#xff1a; C…
阅读更多...
java.io.FileNotFoundException: D:\桌面\file3 (拒绝访问。)

java.io.FileNotFoundException: D:\桌面\file3 (拒绝访问。)

java.io.FileNotFoundException: D:\桌面\file3 拒绝访问。 问题描述一、问题原因及其解决办法 问题描述 今天笔者使用FileInputStream输入流的时候&#xff0c;向里面添加了&#xff08;new File(“D://桌面//file3”)的File文件参数&#xff09;&#xff0c;最后不管怎样运行…
阅读更多...
广州华锐互动：数字孪生可视化制作软件有哪些亮点？

广州华锐互动：数字孪生可视化制作软件有哪些亮点？

由广州华锐互动开发的数字孪生可视化制作软件在当今的数字孪生领域中扮演着重要角色&#xff0c;它突破了许多传统数字孪生可视化制作软件的限制。以下是几个方面的突破&#xff1a; 无限自由度&#xff1a;传统的3D建模工具通常有限制编辑器的自由度&#xff0c;使用户难以进行…
阅读更多...
KEDA：基于事件驱动扩展K8S应用的深度实践

KEDA：基于事件驱动扩展K8S应用的深度实践

新钛云服已累计为您分享773篇技术干货 为什么我们要自动扩展应用程序&#xff1f; 作为 SRE&#xff0c;需要保证应用弹性和高可用性。因此&#xff0c;自动缩放是我们需要的必须功能。通过自动缩放&#xff0c;我们能确保工作负载能够高效的地处理业务流量。 在本文中&#xf…
阅读更多...
[vmware]vmware虚拟机压缩空间清理空间

[vmware]vmware虚拟机压缩空间清理空间

vmware中的ubuntu使用如果拷贝文件进去在删除&#xff0c;vmare镜像文件并不会减少日积月累会不断是的真实物理磁盘空间大幅度减少&#xff0c;比如我以前windows操作系统本来只有30GB最后居然占道硬盘200GB&#xff0c;清理方法有2种。 第一种&#xff1a;vmware界面操作 第二…
阅读更多...
Dubbo篇---第二篇

Dubbo篇---第二篇

系列文章目录 文章目录 系列文章目录一、注册中心挂了，consumer 还能不能调用 provider？二、怎么实现动态感知服务下线的呢？三、Dubbo 负载均衡策略？一、注册中心挂了，consumer 还能不能调用 provider？ 可以。因为刚开始初始化的时候，consumer 会将需要的所有提供者的地…
阅读更多...
多目标跟踪算法 实时检测 - opencv 深度学习 机器视觉 计算机竞赛

多目标跟踪算法 实时检测 - opencv 深度学习 机器视觉 计算机竞赛

文章目录 0 前言2 先上成果3 多目标跟踪的两种方法3.1 方法13.2 方法2 4 Tracking By Detecting的跟踪过程4.1 存在的问题4.2 基于轨迹预测的跟踪方式 5 训练代码6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习多目标跟踪 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023