初识C++ · 类和对象(中)(2)

前言:上篇文章已经介绍了6个默认成员函数中的3个函数,分别是构造函数,析构函数,拷贝构造函数,本文介绍的是后三个,赋值运算符重载const成员函数取地址操纵符重载


目录​​​​​​​

1 赋值运算符重载

1.1运算符重载

1.2 赋值重载

2 实现日期类


1 赋值运算符重载

1.1运算符重载

在学习赋值运算符重载之前,我们先来介绍一下运算符重载:
C++为了增加代码的可读性,引用了运算符重载的概念,运算符重载其实就是一个特殊一点点的函数,返回值,参数,返回类型都是有的,那么运算符重载后的函数名是什么呢?

运算符重载的关键字是operator,函数名就是operator加后面的运算符,比如:

bool operator==(Date d1,Date d2);

operator==就是函数名,参数是两个日期类,返回值是true false,返回类型是bool。

其中,返回值,返回类型等都是根据实际情况操作的,比如日期减日期,返回类型是int,因为返回值是相差的天数,比如日期减天数,返回值就是日期类,因为返回值就是日期,所以实际的返回值返回类型参数等都是看实际情况的,没有固定的说法。

当我们比较一个数是否相等时候,我们直接:

int a = 0;
int b = 1;
bool ret = a == b;

直接利用运算符比较就行,但是对于日期类的我们不能这样干,因为直接比较的都是内置类型,在C++中可以直接进行比较的就是内置类型,但是自定义类型不可以直接比较,这个时候就需要用到运算符重载了,用法如:

bool operator==(Date d1, Date d2)
{return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

这是函数的定法方法,那么定义的时候我们需要注意operator的使用:
1 不能通过连接其他符号来创建新的操作符:比如operator@

2 重载操作符必须有一个类类型参数

3 用于内置类型的运算符,其含义不能改变

4 作为类成员函数重载时,其形参看起来比操作数数目少1

5  .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现

我们不能使用C++里面没有的符号来创建新的符号,因为没有实际意义,编译器也走不过去。

内置类型的比较我们可以直接调用运算符,编译器调用指令来执行代码,重载的操作符是用于自定义类型的,参数没有类是不行的,比如int operator-(int a,int b),两个内置类型重载完全没有意义,所以重载的操作符的参数一定要有个类。

其实严格意义上来说,重载操作符可以改变原来的含义,比如重载一个+,实现的时候实现的是减法,有问题吗?没有多大问题,可能是用来整蛊代码呢?但是实际写代码的时候还是不要改变的好,不然要挨打咯。

当重载函数作为成员函数的时候,因为成员函数都有个默认的成员函数指针,所以形参看起来比操作数少一个。

sizeof ?: . ::这几个操作符好说,不能重载,不常见的是.*,这个是成员函数指针,我们简单看一下函数指针的用法:

void Func()
{cout << "Func" << endl;
}
int main()
{void(*pf)() = Func;(*pf)();return 0;
}

其中函数指针类型是void()(),这里简单复习一下即可,因为函数名就是地址,所以函数指针取地址的时候是没有加&的,那么成员函数指针:

class Ob
{
public:void Func(){cout << "hahaha" << endl;}
};
int main()
{Ob o1;void(Ob:: *pf)() = &Ob::Func;(o1.*pf)();return 0;
}

成员函数指针和普通函数指针的差别就在于规定了成员函数指针取地址的时候必须加&,调用的方法如上,这个运算符也是不能被重载的。

operator介绍完了后,调用运算符重载函数分为显式调用和转换调用

int main()
{Date d1(2020, 1, 17);Date d2(2024, 2, 24);operator==(d1,d2);d1 == d2;return 0;
}

显式调用也就是把函数名全部写出来,当然比较麻烦,一般比较喜欢的就是转化调用了,直接d1==d2就可以了,称为转换调用的原因是因为编译器在汇编层面执行代码的时候也是调用的那个函数,即最后都是转换为了operator==(d1,d2)。

最后都是call重载函数。

那么是否现在意味着我们可以随意调用重载函数呢?

答案是不行的,因为全局重载函数要访问的话,类的成员变量一定要是公有的,不然就会报错:
C++提供了三个解决方法:

1 提供这些成员的get和set

2 使用友元

3 重载成成员函数

这里着重介绍的是重载成成员函数,友元后面介绍,get set其实java特别喜欢,大概使用如下:

int Getyear()
{return _year;
}
bool operator==(Date d1, Date d2)
{return d1.Getyear() == d2.Getyear();
}

了解一下,主要还是重载成成员函数。

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

重载之后,注意参数数目的改变。这里的显式调用就是d1.operator(d2)了。


1.2 赋值重载

Date operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}
int main()
{Date d1(2020, 1, 17);Date d2(2024, 2, 24);Date d3 = d1;Date d4(1,1,1);d4 = d1;return 0;
}

我们先来看这样一段代码,d3 = d1,是拷贝还是赋值?d4 = d1是拷贝还是赋值?

答案比较明确,d3 = d1是拷贝构造,d4 = d1是赋值,那么为什么d4 = d1不是拷贝呢?拷贝是拷贝构造,也就是在初始化的时候完成的,d4已经初始化完成了,再调用就是赋值了。

那么再来一个问题:

int main()
{int i = 1, j = 2, m = 3;i = j = m;cout << i << endl;return 0;
}

请问赋值的顺序是什么样的?
这里的规定是先执行j =m,返回的是j,再执行i = j,最后赋值完成,也就是说连续赋值需要表达式有一个返回值,比如j = m的返回值就是j,那么执行重载后的连续赋值,就需要函数要有返回值:

那么j = m返回的是j,所以d2 = d3返回的应该是d2,函数的this指针指向的就是d2,也就是说我们要返回d2,但是d2在函数里面不是显式的,是隐式的,所以这个时候this指针就起作用了:
return *this就行。

Date operator=(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;return *this;
}

连续赋值的问题就结束了,那么引入一个新代码:

Date Func()
{Date d;return d;
}
int main()
{Func();return 0;
}

对构造函数和析构函数加一点打印,方便观察。

	Date(const Date& d)//拷贝构造函数{cout << "const Date& d" << endl;_year = d._year;_month = d._month;_day = d._day;}~Date()//析构函数{cout << "~Date" << endl;_year = _month = _day = 0;}

首先第一个问题,Func函数会调用几次拷贝构造函数和几次析构函数?

调用了一次拷贝构造函数和两次析构函数,可能会问了,明明没有拷贝拷贝复制的代码,怎么会有拷贝函数的调用呢?
这是因为临时变量的存在,创建好Date d之后,因为返回值是日期类,但是d在Func函数调用了之后会析构,因为生命周期已经结束了,那么返回的就是d拷贝给了一个临时变量,调用了拷贝构造函数,注意,这里是先调用的拷贝构造,再是发生了析构,最后就是主函数里面的d发生了析构。

那么,为了效率,可不可以减少拷贝构造函数的调用呢?析构函数是没有办法的,创建了生命周期一到就会销毁,但是我们可以想办法控制拷贝构造的调用。

Date& Func()
{Date d(2020,4,17);return d;
}
int main()
{const Date& d = Func();return 0;
}

如果返回值是日期类,并且用引用来接收的话,那就是一定要用const接收的,因为返回的日期类实际上是临时变量,临时变量具有常性,如果不用const接收就会导致权限的放大,编译器会报错的,使用引用是可以减少拷贝构造函数的调用的

这里观察的话Vs2022是看不出来的,2019可以看出来,因为2022的优化有点严重了,所以这里推荐用Vs2019学习。

使用引用返回就没有调用拷贝构造了,只有一次析构的原因是因为引用就是多个名指向一个空间,这里只创建了一个日期类,所以只用析构一次。

但是啊,这里引用返回又是一个很恐怖的事情,为什么呢?

这段代码的本意是:创建一个日期类d,再用一个日期类的引用来接受这个日期类的值。

但是经过了析构函数了之后,原本想的是值应该是2020.4.17,但是因为d析构了,所以主函数的d的值也会变成析构之后的值,但是这还不是最恐怖的,最恐怖的是野引用

Date& Func()
{Date d(2020,4,17);cout << &d << endl;return d;
}
int main()
{const Date& d = Func();cout << &d << endl;return 0;
}

首先两个d指向的空间确实是一样的,我们可以用这段代码观察。

但是随着Func函数的调用完成,也就是说Func函数创建的函数栈帧会被操作系统回收了,但是主函数的d仍然指向的是Func函数中d的那块空间,这就是一个野引用,因为栈帧是从上往下开辟的,如果我们再创建一个函数用来覆盖原来的函数:

Date& Func()
{Date d(2020,4,17);return d;
}int F()
{int a = 1;int b = 2;int c = 3;return a + b + c;
}int main()
{const Date& d = Func();F();return 0;
}

那么在Func函数调用完成了之后,Func的函数栈帧被回收,然后就是给F函数创建函数栈帧,因为栈帧是从上往下创建的,F函数的函数栈帧就会覆盖原来Func函数的栈帧,别忘记了此时主函数的d还是指向的那块空间,伴随着函数栈帧的创建,指向的那块空间会给上随机值,那么d就会变成:

d就会变成随机值,d的值可谓是大起大落,从期待的2020.4.17变成了1.1.1再变成了随机值,所以引用的使用也是有风险的,这里总结一下:

如果返回的是临时变量或者是局部变量,会被析构,那么就用传值返回,如果不会被析构函数析构的,那么就用传引用返回,可以减少拷贝构造函数使用次数,主要看的就是生命周期。

如下这种情况:

Date& Func()
{static Date d(2020,4,17);return d;
}
int main()
{const Date& d = Func();d.Print();return 0;
}
	void Print() const

如果创建的成员是静态的,出了函数不会被析构函数销毁,就用了传引用,这个打印的时候注意一下,后面介绍。

传值传引用大概就结束了,下面来看这段综合的代码:

class Date
{
public:Date(int year = 1900, int month = 1, int day = 1){_year = year;_month = month;_day = day;}Date(const Date& d){cout << "Date(const Date& d)" << endl;_year = d._year;_month = d._month;_day = d._day;}Date operator=(const Date& d){if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}~Date(){cout << "~Date()" << endl;_year = -1;_month = -1;_day = -1;}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2024, 4, 14);Date d2(d1);Date d3 = d1;Date d4(2024, 5, 1);d1 = d4;d1 = d2 = d4;d1 = d1;return 0;
}

首先我们先采用传值调用看一遍,引入了一个自己传自己的例子,d1 = d1,严谨一点在重载=这里修改了一下,因为自己等于自己的话赋值没有必要,所以加个判断,直接返回就好了。

这里还有个小细节,前面说生命周期的问题,不免会有人谈论栈的问题,会说只要不在栈上就可以使用引用返回,但是这种想法是错误的,因为这种的默认思维是开辟的元素的栈就是函数的栈帧,但当我们看operator=函数的时候,返回是*this,请问*this在哪个的函数栈帧上?在主函数的函数栈帧上,这里也是栈,但是栈不同,我们可以返回值也可以返回引用,因为这个栈帧是主函数的,随程序的结束才会销毁,所以传值传引用看的是什么?是生命周期

传值调用:
Date d2(d1)一次拷贝构造,Date d3 = d1一次拷贝构造,d1 = d4一次拷贝构造,d2 = d4一次拷贝构造返回d1,d1 = d2一次拷贝构造返回d1,d1 = d1一次拷贝构造返回d1,共6次拷贝构造:

传引用调用:
Date d2(d1)一次拷贝构造,Date d3 = d1一次拷贝构造,后面调用重载函数的返回的都是引用,所以不会调用拷贝构造函数,共两次拷贝构造函数。

最后,赋值运算符重载是默认成员函数,即便用户自己不写,系统也会默认生成,默认生成的赋值运算符重载和拷贝构造函数的行为是一致的,以值的形式进行拷贝,对于日期类,MyQueue类来说默认生成的赋值重载就够用了,但是对于Stack类来说,需要进行深拷贝的类来说就需要用户自己显式定义赋值运算符重载:
读者可以自行注释掉operator=函数,系统也不会报错,因为调用了默认生成的赋值重载,行为就是拷贝构造函数,但是不是拷贝构造函数和赋值重载存在一个就行,存在即合理。

还有就是,赋值重载不能重载成全员函数,因为参数有个一定要是this指针,所以,只能重载成成员函数,这是赋值重载,结束!


2 实现日期类

了解完赋值重载后,我们现在就实现一个真正的日期类:

#pragma once
#include <iostream>
using namespace std;
class Date
{
public:Date(int year = 1, int month = 1, int day = 1);void Print();bool operator>(const Date& d);bool operator>=(const Date& d);bool operator<(const Date& d);bool operator<=(const Date& d);bool operator==(const Date& d);bool operator!=(const Date& d);~Date();
private:int _year;int _month;int _day;
};

暂时先实现这几个简单的,因为是日期类的,所以拷贝构造函数和赋值重载不用显式定义,编译器生成的默认的就够用了,当然析构函数也是,这里看自己习惯咯,实现这些,其实实现一个就行了:

Date::Date(int year, int month, int day)
{_year = year;_month = month;_day = day;
}
void Date::Print()
{cout << _year << '-' << _month << '-' << _day << endl;
}
Date::~Date()
{_year = _month = _day = -1;
}

构造 打印 析构这三个函数就是信手拈来,都快写烂了的,这里有个需要注意的,缺省值是在声明的时候给的,在定义的时候又给缺省值就会重定义,编译器报错,在定义和声明的时候分离要注意这个点。

接着就是比较大小的函数:


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

逻辑十分简单,就不过多介绍了。

接着就是其他函数:

bool Date::operator==(const Date& d)
{return  _year == d._year && _month == d._month && _day == d._day;
}
bool Date::operator<(const Date& d)
{return !(Date::operator>=(d));
}
bool Date::operator>=(const Date& d)
{return Date::operator>(d)|| Date::operator==(d);
}
bool Date::operator<=(const Date& d)
{return !(Date::operator>(d));
}
bool Date::operator!=(const Date& d)
{return !(Date::operator==(d));
}

写了一个函数,其他函数可以说是迎刃而解,比如我写了大于函数,大于等于函数就是大于的同时还满足等于就行,就很简单,无非就是反面正面,当然这段代码并不简洁,简洁一点就使用this指针:

bool Date::operator==(const Date& d)
{return  _year == d._year&& _month == d._month&& _day == d._day;
}
bool Date::operator>=(const Date& d)
{return *this > d|| *this==d;
}
bool Date::operator<(const Date& d)
{return !(*this >=d);
}
bool Date::operator<=(const Date& d)
{return !(*this >d);
}
bool Date::operator!=(const Date& d)
{return !(*this ==d);
}
Date::~Date()
{_year = _month = _day = -1;
}

用this指针代替之后就会整洁很多了。

然后再来其他函数:

//+ -函数实现
Date& operator+=(int day);
Date& operator-=(int day);
int GetMonthDay(int year,int month){assert(month > 0 && month < 13);int yearArr[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 yearArr[2] + 1;}return yearArr[year];}

这里的话在头文件里面定义的日期类里面插入一个函数,它在+ -函数一定是会经常调用的,所以直接定义在类里面使它称为内联函数,直接定义在类里面的就是内联函数,声明和定义不分离,因为链接的时候符号表里面是没有这个函数的名字的。

日期加天数实现的逻辑也很简单,就是天数满了加月,月满了加年而已:

Date& Date::operator+=(int day)
{_day += day;while (_day < GetMonthDay(_year,_month)){_day -= GetMonthDay(_year, _month);_month++;if (13 == _month){_year++;_month = 1;}}return *this;
}

逻辑很简单,-=同理。

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;
}

这里-=要注意几个点,+=加的是本月的天数,-=加的是上月的天数,所以_day += GetMonthDay(_year,_month)的位置就应该放在判断完之后的位置,当然,有的时候整蛊一下别人,传个负数什么的,那就是反过来相加的事而已,返回去调用一下就可以了。

//+ -实现	
Date operator+(int day);
Date operator-(int day);

这里可以注意到的是这两个函数返回值是值,而不是引用,上面的函数就是引用,因为生命周期。

我们写代码的时候要灵活应用我们已经写过的函数,我们已经写了+=,复用一下就行了,它们唯一的区别就是改不改变已经创建好的日期类的变量。

Date Date::operator+(int day)
{Date tem = *this;tem += day;return tem;
}
Date Date::operator-(int day)
{Date tem = *this;tem -= day;return tem;
}

现在问题来了,是先实现+=,实现+的时候复用+=好呢还是反过来呢?

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 (13 == tmp._month){tmp._year++;tmp._month = 1;}}return tmp;
}
Date& Date::operator+=(int day)
{*this = *this + day;return *this;
}

对比+=的代码,可以发现上面的代码的简洁度不是很高,而且开始和返回的时候都多了两个拷贝构造,效率降了一点,所以建议+复用+=的代码这种写法。

    //前置++ 后置++Date& operator++();//前置++Date operator++(int);//后置++
	//前置-- 后置--Date& operator++();//前置--Date operator++(int);//后置--

前置和后置的区别不用多说了,问题出在我们如何区分前置和后置,本贾尼博士在这里做出的改动是加了一个无用的int参数,有int参数的就是后置操作符,因为没有用,所以我们直接给一个int就行了,实现的话因为前置使用的是操作之前的,所以返回this指针,那么返回引用就会减少拷贝:

//前置++ 后置++
Date Date::operator++(int)//后置++
{Date tem = *this;*this += 1;return tem;
}
Date& Date::operator++()//前置++
{*this += 1;return *this;
}
//前置-- 后置--
Date& Date::operator--()//前置--
{*this -= 1;return *this;
}
Date Date::operator--(int)//后置--
{Date tem = *this;*this -= 1;return tem;
}

最后实现一个日期-日期,就得到了一个基本的日期类,但是怎么实现日期-日期呢?因为每个月的天数都不同,所以相对来说有点麻烦,这里用一个比较巧妙的思路:
刚才写了后置前置++,复用呗,比如一个数加到一个数,只要不等于,一直++就可以了,谁大谁小就交给假设法:

	int operator-(const Date& d);//日期相减
int Date::operator-(const Date& d)//日期相减 
{Date max = *this;Date min = d;int flag = 1, num = 0;if (*this < d){max = d;min = *this;flag = -1;}while (max != min){min++;num++;}return num * flag;
}

一个完整的日期类就写好了。


感谢阅读!

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

如若内容造成侵权/违法违规/事实不符,请联系瞎胡闹网进行投诉反馈,一经查实,立即删除!

相关文章

页面加载事件

2.1窗口加载事件 1.window.οnlοadfuction(){} 或者 window.addEventListerner(‘load’,function(){}) doucument.addEventListner(DOMContentLoaded,fuction(){})这个反应更快些

2024商业地产五一劳动节健康大会朋克养生市集活动策划方案

2024商业地产五一劳动节健康大会朋克养生市集&#xff08;带薪健康 快乐打工主题&#xff09;活动策划方案 活动策划信息&#xff1a; 方案页码&#xff1a;53页 文件格式&#xff1a;PPT 方案简介&#xff1a; 打工不养生 赚钱养医生 期待已久的五一假期&#xff0c; …

【UE 材质】表面湿润效果

效果 步骤 1. 创建一个材质函数&#xff0c;这里命名为“MF_Weather_Wetness”&#xff0c;打开材质函数添加如下节点 其中输入的默认值分别为&#xff1a; 其中&#xff0c;“Desaturation”节点用于控制饱和度&#xff0c;我们通过给“Fraction”引脚输入一个负值来增加饱和…

​漏电继电器JHOK-ZBLφ150mm 0.03-3A 0.2-2S导轨安装JOSEF约瑟

系列型号&#xff1a; JHOK-ZBL多档切换式漏电&#xff08;剩余&#xff09;继电器&#xff08;导轨&#xff09; JHOK-ZBL1多档切换式漏电&#xff08;剩余&#xff09;继电器 JHOK-ZBL2多档切换式漏电&#xff08;剩余&#xff09;继电器 JHOK-ZBM多档切换式漏电&#xff08;…

[lesson49]多态的概念和意义

多态的概念和意义 函数重写回顾 父类中被重写的函数依然会继承给子类 子类中重写的函数将覆盖父类中的函数 通过作用域分辨符(::)访问父类中的同名成员 多态的概念和意义 面向对象中期望的行为 根据实际的对象类型判断如何调用重写函数父类指针(引用)指向 父类对象则调用…

早些年间学Erupt

Erupt部署 创建一个SpringBoot项目(此处为2.7.10) 目录结构 demo -- 项目名称 ├── src└── main├── java -- 代码文件目录└── com.example.demo -- 包名└── DemoApplication -- 入口类└── resources -- 资源文件目录└── application.properties -- 配置…

”温江公平红烧兔“ 大声安利小众美食

”温江公平红烧兔“ 昨天正好送客户回温江&#xff08;送了一筐樱桃&#xff0c;希望不太酸&#xff09;&#xff0c; 师傅跟我说&#xff0c;有好吃的兔子&#xff0c;先不急吃午饭。 本来天气晒 晕车&#xff0c;我想着肯定没胃口。 结果第一份凉粉上来&#xff0c;越吃胃…

UE4网络图片加载库(带内存缓存和磁盘缓存)

UE4网络图片加载库,带内存缓存和磁盘缓存,支持自定义缓存大小,支持蓝图和C++代码调用 1、调用示例 2、对外暴露函数 3、源代码-网络模块 KeImageNet.h // Fill out your copyright notice in the Description page of Project Settings.#pragma once#include "CoreM…

Linux:Win10平台上,用VMware安装Centos7.x及系统初始化关键的相关配置(分步骤操作,详细,一篇足以)

VMware安装Centos7.x镜像的详细步骤&#xff1a;VMWare安装Centos系统&#xff08;无桌面模式&#xff09; 我这里是为了安装Hadoop集群&#xff0c;所以&#xff0c;以下这些步骤是必须进行的 如果你是学习Linux&#xff0c;可以跳过非必须的那些配置项 我安装的版本是&…

Docker 基本认识

一 国内&#xff1a; 中国电信天翼云 提供包括云主机在内的全方位云计算服务&#xff0c;侧重于安全合规和企业级服务。 利用电信的网络优势&#xff0c;提供稳定可靠的基础设施服务。 中国联通沃云 提供包括云主机在内的多项云计算服务&#xff0c;适合不同行业和场景。 …

第五章关于路由过滤和路由策略实验

一.实验拓扑 二.根据网段配置IP地址 AR1: [Huawei]int G0/0/0 [Huawei-GigabitEthernet0/0/0]ip add 100.1.1.5 24 [Huawei-GigabitEthernet0/0/0]int L0 [Huawei-LoopBack0]ip add 192.168.0.1 32 [Huawei-LoopBack0]int L1 [Huawei-LoopBack1]ip add 192.168.1.1 32 三.按…

《HCIP-openEuler实验指导手册》1.4 Apache MPM工作模式调整

MPM介绍 二、配置步骤 查看MPM当前工作模式 方法一&#xff1a; httpd -M | grep mpm方法二&#xff1a; 浏览器访问&#xff1a;http://IP:端口/server-status 方法三&#xff1a; cat /etc/httpd/conf.modules.d/00-mpm.conf查看 LoadModule mpm_event_module modules/mo…

分保、等保、关保、密评之间联系与区别

分保、等保、关保、密评之间联系与区别 什么是“三保一评”分保等保关保密评 相关的法律法规依据分保等保关保密评 分保工作简介分保工作流程分级保护技术要求 等保工作简介等保系统定级等保工作流程等保2.0技术保护方案规划等保2.0网络安全设备配置建议等保2.0安全管理规划 关…

[Android]Jetpack Compose加载图标和图片

一、加载本地矢量图标 在 Android 开发中使用本地矢量图标是一种常见的做法&#xff0c;因为矢量图标&#xff08;通常保存为 SVG 或 Android 的 XML vector format&#xff09;具有可缩放性和较小的文件大小。 在 Jetpack Compose 中加载本地矢量图标可以使用内置的支持&…

关于C++STL的总结(基础使用和底层原理)

STL是什么&#xff1f; STL即&#xff08;Standard Template Library&#xff09;标准模板库&#xff0c;提供了常见的数据结构和算法函数等&#xff0c;其下共包含六大组件&#xff1a; 容器算法迭代器仿函数适配器空间配置器 本篇重点介绍容器的使用和简单的底层实现原理&…

二进制,八进制,十六进制 开头的标识符号

1、引言 每个进制开头的标识符号容易忘&#xff0c;写篇小小博客&#xff0c;拯救一下俺的小脑袋瓜子。 2、进制开头标识符号

AJAX——案例

1.商品分类 需求&#xff1a;尽可能同时展示所有商品分类到页面上 步骤&#xff1a; 获取所有的一级分类数据遍历id&#xff0c;创建获取二级分类请求合并所有二级分类Promise对象等待同时成功后&#xff0c;渲染页面 index.html代码 <!DOCTYPE html> <html lang&qu…

《QT实用小工具·三十八》QT炫酷的菜单控件

1、概述 源码放在文章末尾 非常飘逸的 Qt 菜单控件&#xff0c;带有各种动画效果&#xff0c;用起来也十分方便。 无限层级&#xff0c;响应键盘、鼠标单独操作&#xff0c;支持单快捷键。 允许添加自定义 widget、layout&#xff0c;当做特殊的 QDialog 使用。 项目demo演示…

你变了,再也不是我认识的微信小程序了!

以前做了不少的小程序&#xff0c;领导刚说要做的时候以为自己轻车熟路&#xff0c;多大点事&#xff0c;做了才发现近年来微信小程序改动还是挺多的&#xff01;不过第一感觉就是花钱的地方越来越多了&#xff01;接下来就帮大家整理一下我自己总结的有改动的地方&#xff0c;…

自动化软件测试策略

作为一名软件开发人员&#xff0c;我在不同的公司工作过&#xff0c;具有不同的软件测试流程。在大多数情况下&#xff0c;没有特定/记录的测试方法......因此该过程的内容/方式取决于各个开发人员。与大多数情况一样&#xff0c;当没有强制执行或至少记录在案的政策时&#xf…