【类和对象】4

日期类的拓展

c语言中的printf函数只能打印内置类型，为了弥补这一不足，c++利用运算符重载可以打印自定义类型。

void operator<<(ostream&out);//声明在date.h中

void Date::operator<<(ostream& out)//定义在date.cpp中
{out<<this->_year <<"年" << this->_month<<"月" << this->_day<<"日";}

int main()//.cpp中
{Date d1(2024, 3, 30);d1.operator<<(cout);}

如果我们修改成这样呢.cpp

int main()
{Date d1(2024, 3, 30);//d1.operator<<(cout);cout << d1;}

在这里插入图片描述
由于我们的运算符重载是定义在日期类里面的，所以默认*this是左操作数，所以类定义的对象必须放在左边。修改如下：

int main()
{Date d1(2024, 3, 30);//d1.operator<<(cout);d1<<cout;
}

如果我们就要使类对象在右边呢？
所以我们必须将该函数放在全局，但是放在全局的话，类对象的变量都是私有，就不能访问到，我们先改成共有：

void operator<<(ostream& out, Date& d);//声明放全局在date.h中

void operator<<(ostream& out, Date& d)//定义在date.cpp中
{out << d._year << "年" << d._month << "月" << d._day << "日";}

int main()//在.cpp中
{Date d1(2024, 3, 30);//d1.operator<<(cout);cout<<d1;}

如果我们不将变量改成共有，我们全局函数怎么才能访问到类成员变量呢？

friend void operator<<(ostream& out, Date& d);

在声明中加上这个，使全局的函数成为类的友元函数，就可以访问类的变量了。

我们知道变量可以连续赋值，这里可以支持连续输出吗？
在这里插入图片描述
赋值运算符从右向左，先把q的值赋值为10，然后再把q的值赋给p,然后把p的值赋给i,实现连续赋值，因此需要返回值

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

ostream& operator<<(ostream& out, Date& d);//声明

int main()
{Date d1 = (2002, 3, 11);Date d2 = (2012, 3, 11);cout << d1 << d2;}

既然能输出自定义类型，那怎么使用运算符重载函数实现自定义类型输入呢？
实现如下：

istream& operator>>(istream& in, Date& d);//声明在date.h全局

istream& operator>>(istream& in, Date& d)//date.cpp定义
{in>>d._year >> d._month >> d._day ;return in;}

int main()
{Date d1 ;Date d2 ;cin >> d1 >> d2;//给输入cout << d1 << d2;//输出}

日期类的安全性修改

比如，如果输入不合法，就提示，我们需要写一个检测的函数
修改后的日期类
date.h

#pragma once
#include<iostream>
using namespace std;
class Date{public:// 获取某年某月的天数int GetMonthDay(int year, int month);// 全缺省的构造函数Date(int year = 1900, int month = 1, int day = 1);// 拷贝构造函数// d2(d1)Date(const Date& d);// 赋值运算符重载// d2 = d3 -> d2.operator=(&d2, d3)Date& operator=(const Date& d);// 析构函数~Date();// 日期+=天数Date& operator+=(int day);// 日期+天数Date operator+(int day);// 日期-天数Date operator-(int day);// 日期-=天数Date& operator-=(int day);// 前置++Date& operator++();// 后置++Date operator++(int);// 后置--Date operator--(int);// 前置--Date& operator--();// >运算符重载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);bool  isvalid(Date& d);// 日期-日期 返回天数int operator-(const Date& d);void print();/*void operator<<(ostream&out);*/friend ostream & operator<<(ostream& out, Date& d);friend istream& operator>>(istream& in, Date& d);
private:int _year;int _month;int _day;};
ostream& operator<<(ostream& out, Date& d);
istream& operator>>(istream& in, Date& d);

date.cpp

#include "date.h"
Date::Date(int year, int month, int day)
{_year = year;_month = month;_day = day;if (!(this->isvalid(*this))){cout << "初始化非法" << endl;}}
void Date:: print()
{cout << _year << "." << _month << "." << _day<<endl;
}
Date::Date(const Date& d)
{_year = d._year;_month = d._month;_day = d._day;}
Date::~Date()
{_year = 0;_month = 0;_day = 0;}
int Date:: GetMonthDay(int year, int month)
{int arr[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 arr[month];}
Date& Date:: operator=(const Date& d)
{if (this != &d){_year = d._year;_month = d._month;_day = d._day;}return *this;}
Date & Date::operator+=(int day)
{_day+= day;while (_day > GetMonthDay(_year,_month)){_day -= GetMonthDay(_year, _month);_month++;if (_month == 13){_month = 0;}}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._month = 0;}}return tmp;}
Date& Date:: operator-=(int day)
{_day -= day;while (_day <= 0){_month--;if (_month == 0){_year--;_month = 12;}_day += GetMonthDay(_year, _month);}return *this;}
Date Date::operator-(int day)
{Date tmp = *this;tmp -= (day);return tmp;}
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){if (_day > d._day)return true;}}}}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   *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::operator++()
{*this = *this + 1;return *this;}Date Date:: operator++(int)
{Date tmp = *this;*this=*this+ 1;return tmp;}Date Date::operator--(int)
{Date tmp =*this;*this=*this-1;return tmp;}
Date& Date:: operator--()
{*this = *this - 1;return *this;}int Date::operator-(const Date& d)
{Date max = *this;Date min = d;int flag = 1;if (min > (max)){max = d;min = *this;flag = -1;}int n = 0;while (max != min){n++;min++;}return flag*n;}
bool Date::isvalid(Date& d)
{if (_year < 0 || _month <= 0 || _month>12 || _day<1 || _day>GetMonthDay(_year, _month)){return false;}true;}
ostream& operator<<(ostream& out, Date& d)
{out << d._year << "年" << d._month << "月" << d._day << "日";return out;}
istream& operator>>(istream& in, Date& d)
{while (1){cout << "请输入时间" << endl;in >> d._year >> d._month >> d._day;if (!d.isvalid(d)){cout << "输入不合法" << endl;}else{break;}}return in;
}

权限问题

首先看一个问题
在这里插入图片描述
在这里插入图片描述
我们这里调用print函数发现调用不动
在这里插入图片描述

应该怎么修改呢？
在printhan函数的声明和定义后面加上const

void Date:: print() const//定义
{cout << _year << "." << _month << "." << _day<<endl;
}

void print() const;//声明

此时该函数中*this指向的内容不能被修改。现在调用相当于权限平移，就可以了。

此时我们的print函数时加了const

int main()
{Date d1 ;Date d2(2003,3,3);const Date d3(2002,1,2);d3.print();d2.print();}

d2是非const的类对象，也能调用const函数print,因为权限缩小了，所以可以。

总结：
成员函数，如果是一个对成员变量只进行读访问的函数，建议函数+const,这样const对象和非const对象都可以使用
如果一个对成员变量要进行读写访问的函数，不能加const,否则不能修改成员变量

  1. const对象可以调用非const成员函数吗？ 权限放大
  2. 非const对象可以调用const成员函数吗？ 权限缩小
  3. const成员函数内可以调用其它的非const成员函数吗？权限放大
  4. 非const成员函数内可以调用其它的const成员函数吗？权限缩小

权限放大和缩小和平移适用于指针和引用

取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date
{ 
public :Date* operator&(){return this ;}const Date* operator&()const{return this ;}
private :int _year ; // 年int _month ; // 月int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

class Date
{
public:
Date(int year, int month, int day){_year = year;_month = month;_day = day;_year=1;}
private:
int _year;
int _month;
int _day;
};

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
Date(int year, int month, int day): _year(year), _month(month), _day(day){}
private:
int _year;
int _month;
int _day;
};

因为我们的常量，引用必须在定义的时候初始化。

#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;_year = 1;n = 1;}
private:int _year;int _month;int _day;const int n;
};int main(){Date d1(2003, 3, 11);}

在这里插入图片描述

所以我们常量初始化一定要放在初始化列表中。

#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day):n(1), _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;const int n;
};int main(){Date d1(2003, 3, 11);}

引用类型必须在初始化时候给初值

#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day,int&p):n(3), _year(year), _month(month), _day(day),x(p){}
private:int _year;int _month;int _day;const int n=1;int& x;
};int main(){int num = 5;Date d1(2003, 3, 11,num);}

p是num的别名，而x又是p的别名。

3.当我们类成员变量里面有自定义类型的话，并且我们没有在初始化列表初始化，初始化列表会给他调用他自己的默认构造函数完成初始化。（这里的默认构造是我们写的全缺省构造函数）

#include<iostream>
using namespace std;
class A
{
public:A(int a=3):_a(a){cout << "调用" << endl;}
private:int _a;
};
class Date
{
public:Date(int year, int month, int day,int&p):n(3), _year(year), _month(month), _day(day),x(p){}
private:int _year;int _month;int _day;const int n=1;int& x;A cou;
};int main(){int num = 5;Date d1(2003, 3, 11,num);}

如果A dou对象没有默认构造呢（默认构造包括全缺省，无参，系统生成的，这里构造有参，所以没有默认构造）

我们可以在初始化列表给自定义类型初始化。

#include<iostream>
using namespace std;
class A
{
public:A(int a):_a(a){cout << "调用" << endl;}
private:int _a;
};
class Date
{
public:Date(int year, int month, int day,int&p):n(3), _year(year), _month(month), _day(day),x(p),cou(5){}
private:int _year;int _month;int _day;const int n=1;int& x;A cou;
};int main(){int num = 5;Date d1(2003, 3, 11,num);}

在这里插入图片描述
【注意】

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
  • 引用成员变量
  • const成员变量
  • 自定义类型成员(且该类没有默认构造函数时)

同时也可以在初始化列表给指针初始化，可以在初始化列表中检查空间是否申请

#include<iostream>
#include<stdlib.h>
using namespace std;
class A
{
public:A(int a):_a(a){cout << "调用" << endl;}
private:int _a;
};
class Date
{
public:Date(int year, int month, int day,int&p):n(3), _year(year), _month(month), _day(day),x(p),cou(5),ptr((int*)malloc(sizeof(int))){if (ptr == NULL){perror("malloc fail");}}
private:int _year;int _month;int _day;const int n=1;int& x;A cou;int* ptr;
};int main(){int num = 5;Date d1(2003, 3, 11,num);}

总结：声明的缺省参数是给初始化列表的，如果初始化列表没有给一个变量初始化，这个变量就拿的是缺省参数的值，自定义类型如果初始化列表没有初始化，就会去调用自己的默认构造函数，来进行初始化，如果没有默认构造函数的话，就要看对象实例化的时候有没有给自己写的构造函数有没有传值，如果没有的话，就是随机值，如果初始化列表给自定义类型初始化了，就没有上面的一系列操作了，初始化列表后还可以在括号里面给变量赋值（除了那3个）相当于构造函数。

单参数构造函数支持隐式类型转换

#include<iostream>
#include<stdlib.h>
using namespace std;
class C
{
public:C(int x = 0):_x(x){}C(const C& cc){cout << "C(const C& cc)" << endl;}private:int _x;
};
int main()
{C cc2 = 2;}

在这里插入图片描述
编译器优化，连续步骤的·构造，一般会合二为一

和隐式类型转化差不多
在这里插入图片描述

如果我们的自定义的对象没有在初始化列表中初始化，并且也没有自己的默认构造函数的话，我们要给缺省值给自定义对象赋值，我们必须在全局实例化一个类对象，然后将该类对象拷贝构造给里面的自定义变量。

#include<iostream>
#include<stdlib.h>
using namespace std;
class C
{
public:C(int x = 0):_x(x){}C(const C& cc){cout << "C(const C& cc)" << endl;}private:int _x;
};
class Stack
{
public:void Push(const C& c){}
};int main()
{Stack st;C cc3(3);st.Push(cc3);st.Push(3);return 0;
}

这里如果我们要入一个C类的对cc3，并且cc3类成员变量初始化为3，本来我们需要先给cc3对象赋值，然后再将C类对象cc3入栈，现在支持单参数构造函数支持隐式类型转换，就可以入栈一个类成员变量初始化为3，并且是C类对象。
在这里插入图片描述

c++11支持多参数构造函数支持隐式类型转换

#include<iostream>
#include<stdlib.h>
using namespace std;
class A
{
public:A(int a1, int a2):_a1(a1),_a2(a2){}private:int _a1;int _a2;
};int main()
{A aa1 = { 1, 2 };return 0;
}

explicit关键字

#include<iostream>
#include<stdlib.h>
using namespace std;
class A
{
public:explicit A(int a1, int a2):_a1(a1),_a2(a2){}private:int _a1;int _a2;
};int main()
{A aa1 = { 1, 2 };return 0;
}

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

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

上述代码会出现什么情况？D
A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值
因为是按照声明次序初始化，所以_a2初始化的时候，_a1还没有初始化，所以_a2是随机值，然后_a1按照初始化列表初始化为1

static成员

概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

class A
{
public:A(){}A(const A& aa){}private:int a = 0;
};A Func()
{A aa;return aa;
}int main()
{A aa1;A aa2;Func();return 0;
}

实现一个类，计算程序中创建出了多少个类对象
1.我们定义一个全局变量统计构造函数和拷贝构造函数调用了多少次

#include<iostream>
#include<stdlib.h>
using namespace std;
int n = 0;
class A
{
public:A(){n++;}A(const A& aa){n++;}private:int a = 0;
};A Func()
{A aa;return aa;
}int main()
{A aa1;A aa2;Func();cout << n << endl;return 0;
}

2.由于全局变量可以在任意位置被修改，我们将n定义在类中，但是类中的n是私有的，我们可以使用静态变量static,然后去掉私有，但是static 必须在类外面定义初始化，这时候n就可以在每个类对象中使用了（突破类域使用n）

#include<iostream>
#include<stdlib.h>
using namespace std;class A
{
public:A(){n++;}A(const A& aa){n++;}int a = 0;static int n;
};int A::n = 0;A Func()
{A aa;return aa;
}int main()
{A aa1;A aa2;Func();cout << aa1.n << endl;cout << aa2.n << endl;cout << A::n << endl;return 0;
}

3.使用静态函数返回静态变量，静态函数中没有this指针，只能操作静态变量。

#include<iostream>
#include<stdlib.h>
using namespace std;class A
{
public:A(){n++;}A(const A& aa){n++;}static int GetN(){return n;}private:int a = 0;static int n;
};int A::n = 0;A Func()
{A aa;return aa;
}int main()
{A aa1;A aa2;Func();cout << aa1.GetN() << endl;cout << A::GetN() << endl;return 0;
}

特性

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Java正则表达式之Pattern和Matcher

Java正则表达式之Pattern和Matcher

目录 前言一、Pattern和Matcher的简单使用二、Pattern详解2.1 Pattern 常用方法2.1.1 compile(String regex)2.1.2 matches(String regex, CharSequence input)2.1.3 split(CharSequence input)2.1.4 pattern()2.1.5 matcher(CharSequence input) 三、Matcher详解3.1 Matcher 常…
阅读更多...
wangEditor v4的简单使用

wangEditor v4的简单使用

当前文档是 wangEditor v4 版本的。 wangEditor v5 已经正式发布&#xff0c;可参考文档。 v5 发布之后&#xff0c;v4 将不再开发新功能。 介绍 English documentation wangEditor4 —— 轻量级 web 富文本编辑器&#xff0c;配置方便&#xff0c;使用简单。 官网&#…
阅读更多...
[python]基于LSTR车道线实时检测onnx部署

[python]基于LSTR车道线实时检测onnx部署

【框架地址】 https://github.com/liuruijin17/LSTR 【LSTR算法介绍】 LSTR车道线检测算法是一种用于识别和定位车道线的计算机视觉算法。它基于图像处理和机器学习的技术&#xff0c;通过对道路图像进行分析和处理&#xff0c;提取出车道线的位置和方向等信息。 LSTR车道线…
阅读更多...
「效果图渲染」效果图与3D影视动画渲染平台

「效果图渲染」效果图与3D影视动画渲染平台

效果图渲染和3D影视动画渲染都是视觉图像渲染的领域应用。效果图渲染主要服务于建筑、室内设计和产品设计等行业&#xff0c;这些领域通常对视觉呈现的精度和细节有较高要求。与之相比&#xff0c;3D影视动画渲染则普遍应用于电影、电视、视频游戏和广告等媒体领域&#xff0c;…
阅读更多...
项目安全-----加密算法实现

项目安全-----加密算法实现

目录 对称加密算法 AES &#xff08;ECB模式&#xff09; AES(CBC 模式)。 非对称加密 对称加密算法 对称加密算法&#xff0c;是使用相同的密钥进行加密和解密。使用对称加密算法来加密双方的通信的话&#xff0c;双方需要先约定一个密钥&#xff0c;加密方才能加密&#…
阅读更多...
无人机激光雷达标定板

无人机激光雷达标定板

机载激光雷达标定板是用于校准和验证机载激光雷达系统的设备。由于机载激光雷达系统在测量地形、建筑物和植被等方面具有广泛的应用&#xff0c;因此标定板的使用对于确保测量结果的准确性和可靠性至关重要。 标定板通常由高反射率的材料制成&#xff0c;如镀金的玻璃或陶瓷&am…
阅读更多...
flv视频格式批量截取封面图（不占内存版）--其他视频格式也通用

flv视频格式批量截取封面图（不占内存版）--其他视频格式也通用

flv视频格式批量截取封面图&#xff08;不占内存版&#xff09;--其他视频格式也通用 需求&#xff08;实现的效果&#xff09;功能实现htmlcssjs 需求&#xff08;实现的效果&#xff09; 批量显示视频&#xff0c;后端若返回有imgUrl,则直接显示图1&#xff0c; 若无&#xf…
阅读更多...
【推荐】运放作为跟随器时，负反馈上加电阻的作用？

【推荐】运放作为跟随器时，负反馈上加电阻的作用？

请问何种信号源或者输出是什么状况下跟随器需要使用电阻呢&#xff1f;使用多大阻值&#xff1f; 答&#xff1a;信号源内阻较大时&#xff0c;添加阻值与信号源内阻相同的反馈电阻&#xff0c;可以减少输出失调电压&#xff0c;提高精度。 R2的作用是为了防止输出意外接地&am…
阅读更多...
AspNet web api 和mvc 过滤器差异

AspNet web api 和mvc 过滤器差异

最近在维护老项目。定义个拦截器记录接口日志。但是发现不生效 最后发现因为继承的 ApiController不是Controller 只能用 System.Web.Http下的拦截器生效。所以现在总结归纳一下 Web Api: System.Web.Http.Filters.ActionFilterAttribute 继承该类 Mvc: System.Web.Mvc.Ac…
阅读更多...
版本管理git及其命令介绍-附带详细操作

版本管理git及其命令介绍-附带详细操作

前言 在版本管理时代之前&#xff0c;人们写软件的方式如下图1所示 图1 无版本管理的代码 其坏处就是软件版本随着时间越来越多&#xff0c;每个版本修改了什么内容&#xff0c;修改了哪些文件&#xff0c;如果没有详细记录也不知道。这样久会导致如果我们想回退到某个版本内…
阅读更多...
４通过干扰 Char 设备为 PRNG 添加后门＿Linux＿Rootkit．md

４通过干扰 Char 设备为 PRNG 添加后门＿Linux＿Rootkit．md

Xcellerator 密码学Linux其他逆向工程 文章目录 [Linux Rootkit 第 4 部分&#xff1a;通过干扰 Char 设备为 PRNG 添加后门](https://xcellerator.github.io/posts/linux_rootkits_04/)Linux 中的字符设备字符设备的读取例程编写 Rootkit我们能去哪里呢&#xff1f; Linux Ro…
阅读更多...
js中的数据类型（存储上的差别）

js中的数据类型（存储上的差别）

文章目录 前言一、基本类型NumberUndefinedStringNullBooleanSymbol 二、引用类型ObjectArrayFunction其他引用类型 三、存储区别基本类型引用类型 小结 前言 在JavaScript中&#xff0c;我们可以分成两种类型&#xff1a; 基本类型复杂类型 两种类型的区别是&#xff1a;存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023