一、知识点
重载运算符
重载运算符的限制
重载运算符函数可以对运算符作出新的解释,但原有基本语义不变:
不改变运算符的优先级
不改变运算符的结合性
不改变运算符所需要的操作数
不能创建新的运算符
运算符函数可以重载为成员函数或友元函数
一元运算符
二元运算符Object op 或 op Object
重载为成员函数,解释为:
Object. operator op ()
操作数由对象Object通过this指针隐含传递
重载为友元函数,解释为:
operatorop (Object)
操作数由参数表的参数Object提供
用成员函数重载运算符ObjectL op ObjectR
重载为成员函数,解释为:ObjectL. operator op ( ObjectR )左操作数由ObjectL通过this指针传递,右操作数由参数ObjectR传递
重载为友元函数,解释为:operatorop ( ObjectL, ObjectR )左右操作数都由参数传递
双目运算符重载为成员函数成员运算符函数的原型在类的内部声明格式如下:
class X {
//…
返回类型 operator运算符(形参表);
//…
}
在类外定义成员运算符函数的格式如下:
返回类型 X::operator运算符(形参表)
{
函数体
}
单目运算符重载为成员函数对双目运算符而言,成员运算符函数的形参表中仅有一个参数,它作为运算符的右操作数,此时当前对象作为运算符的左操作数,它是通过this指针隐含地传递给函数的。
一般而言,如果在类X中采用成员函数重载双目运算符@,成员运算符函数operator@ 所需的一个操作数由对象aa通过this指针隐含地传递,它的另一个操作数bb在参数表中显示,aa和bb是类X的两个对象,则以下两种函数调用方法是等价的:
aa @ bb; // 隐式调用
aa.operator @(bb); // 显式调用
对单目运算符而言,成员运算符函数的参数表中没有参数,此时当前对象作为运算符的一个操作数
一般而言,采用成员函数重载单目运算符时,以下两种方法是等价的:
@aa; // 隐式调用
aa.operator@(); // 显式调用
成员运算符函数operator @所需的一个操作数由对象aa通过this指针隐含地传递。因此,在它的参数表中没有参数。用友元函数重载
成员运算符函数与友元运算符函数的比较在第一个参数需要隐式转换的情形下,使用友元函数重载运算符是正确的选择
友元函数没有 this 指针,所需操作数都必须在参数表显式声明,很容易实现类型的隐式转换
C++中不能用友元函数重载的运算符有
= () [] ->
几个典型运算符重载成员运算符函数比友元运算符函数少带一个参数(后置的++、--需要增加一个形参)。
双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。
数学类中常用的几个运算符重载的特点和应用
前置方式: ++Aobject --Aobject设 A Aobject ;
运算符 ++和 - - 有两种方式:
后置方式:Aobject ++ Aobject --成员函数重载 A ::A operator++ () ;
解释为:Aobject . operator ++( );
友元函数重载 friendA operator++ (A &) ;
解释为:operator ++( Aobject ) ;
重载赋值运算符成员函数重载 A ::A operator++ (int) ; 解释: Aobject . operator ++( 0) ;
友元函数重载: friendA operator++ (A &, int) ; 解释为: operator++(Aobject, 0)
赋值运算符重载用于对象数据的复制
operator= 必须重载为成员函数
重载函数原型:类名 & 类名 ::operator= ( 类名 );
重载运算符[]和()
运算符[] 和 () 是二元运算符[] 和 ()只能用成员函数重载,不能用友元函数重载
重载下标运算符 []
[] 运算符用于访问数据对象的元素
重载格式 类型 类 :: operator[] ( 类型 ) ;
重载函数调用符 ()
() 运算符用于函数调用
重载格式 类型 类 :: operator() ( 参数表 ) ;
重载流插入和流提取运算符
重载输出运算符“<<”(只能被重载成友元函数,不能重载成成员函数)istream 和 ostream 是 C++的预定义流类
cin 是 istream 的对象,cout是 ostream 的对象
运算符<< 由ostream 重载为插入操作,用于输出基本类型数据
运算符>> 由 istream 重载为提取操作,用于输入基本类型数据
用友元函数重载 << 和 >> ,输出和输入用户自定义的数据类型
重载输入运算符“>>” (只能被重载成友元函数)定义输出运算符“<<”重载函数的一般格式如下:
ostream& operator<<(ostream& out,class_name&obj)
{
out<<obj.item1;
out<<obj.item2;
.. .
out<<obj.itemn;
return out;
}
STL概述定义输入运算符函数 “>>”重载函数的一般格式如下:
istream& operator>>(istream&in,class_name& obj)
{
in>>obj.item1;
in>>obj.item2;
. . .
in>>obj.itemn;
return in;
}
STL组件STL是C++标准程序库的核心,深刻影响了标准程序库的整体结构
STL由一些可适应不同需求的集合类(collection class),以及在这些数据集合上操作的算法(algorithm)构成
STL内的所有组件都由模板(template)构成,其元素可以是任意类型
STL是所有C++编译器和所有操作系统平台都支持的一种库
STL容器类别容器(Container) - 管理某类对象的集合
迭代器(Iterator) - 在对象集合上进行遍历
算法(Algorithm) - 处理集合内的元素
容器适配器(container adaptor)
函数对象(functor)
STL容器的共同能力序列式容器-排列次序取决于插入时机和位置
关联式容器-排列顺序取决于特定准则
STL容器元素的条件所有容器中存放的都是值而非引用。如果希望存放的不是副本,容器元素只能是指针。
所有元素都形成一个次序(order),可以按相同的次序一次或多次遍历每个元素
STL容器的共同操作必须能够通过拷贝构造函数进行复制
必须可以通过赋值运算符完成赋值操作
必须可以通过析构函数完称销毁动作
序列式容器元素的默认构造函数必须可用
某些动作必须定义operator ==,例如搜寻操作
关联式容器必须定义出排序准则,默认情况是重载operator <
对于基本数据类型(int,long,char,double,…)而言,以上条件总是满足
初始化(initialization)
与大小相关的操作(size operator)产生一个空容器std::list<int> l;
以另一个容器元素为初值完成初始化std::list<int> l;
std::vector<float> c(l.begin(),l.end());
以数组元素为初值完成初始化int array[]={2,4,6,1345};
std::set<int> c(array,array+sizeof(array)/sizeof(array[0]));
赋值(assignment)和交换(swap)size()-返回当前容器的元素数量
empty()-判断容器是否为空
max_size()-返回容器能容纳的最大元素数量
比较(comparison)==,!=,<,<=,>,>=
比较操作两端的容器必须属于同一类型
如果两个容器内的所有元素按序相等,那么这两个容器相等
采用字典式顺序判断某个容器是否小于另一个容器
元素操作swap用于提高赋值操作效率
与迭代器(iterator)相关的操作
begin()-返回一个迭代器,指向第一个元素
end()-返回一个迭代器,指向最后一个元素之后
rbegin()-返回一个逆向迭代器,指向逆向遍历的第一个元素
rend()-返回一个逆向迭代器,指向逆向遍历的最后一个元素之后
迭代器(iterator)(示例:iterator)insert(pos,e)-将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)-移除[beg,end]区间内的所有元素
clear()-移除所有元素
可遍历STL容器内全部或部分元素的对象
指出容器中的一个特定位置
迭代器的基本操作
返回当前位置上的元素值。如果该元素有成员,可以通过迭代器以operator ->取用
所有容器都提供获得迭代器的函数++
将迭代器前进至下一元素
==和!=
判断两个迭代器是否指向同一位置
=
为迭代器赋值(将所指元素的位置赋值过去迭代器(iterator)
begin() 返回一个迭代器,指向第一个元素
end() 返回一个迭代器,指向最后一个元素之后
半开区间[beg, end)的好处:
1.为遍历元素时循环的结束时机提供了简单的判断依据(只要未到达end(),循环就可以继续)
2.不必对空区间采取特殊处理(空区间的begin()就等于end())
所有容器都提供两种迭代器
container::iterator以“读/写”模式遍历元素
container::const_iterator以“只读”模式遍历元素
迭代器(iterator)
vector迭代器分类
双向迭代器
可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。
list、set和map提供双向迭代器
随机存取迭代器
除了具备双向迭代器的所有属性,还具备随机访问能力。
可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。
vector、deque和string提供随机存取迭代器
vectorvector模拟动态数组
vector的元素可以是任意类型T,但必须具备赋值和拷贝能力(具有public拷贝构造函数和重载的赋值操作符)
必须包含的头文件#include <vector>
vector支持随机存取
vector的大小(size)和容量(capacity)
size返回实际元素个数,
capacity返回vector能容纳的元素最大数量。如果插入元素时,元素个数超过capacity,需要重新配置内部存储器。
赋值操作构造、拷贝和析构
操作 效果
vector<T> c 产生空的vector
vector<T> c1(c2 产生同类型的c1,并将复制c2的所有元素
vector<T> c(n) 利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector
vector<T> c(n,e) 产生一个大小为n的vector,每个元素都是e
vector<T> c(beg,end) 产生一个vector,以区间[beg,end]为元素初值
~vector<T>() 销毁所有元素并释放内存。
非变动操作c.size() 返回元素个数c.empty( 判断容器是否为空c.max_size() 返回元素最大可能数量(固定值)c.capacity() 返回重新分配空间前可容纳的最大元素数量c.reserve(n) 扩大容量为nc1==c2 判断c1是否等于c2c1!=c2 判断c1是否不等于c2c1<c2 判断c1是否小于c2c1>c2 判断c1是否大于c2c1<=c2 判断c1是否大于等于c2c1>=c2 判断c1是否小于等于c2
元素存取操作 效果
c1 = c2 将c2的全部元素赋值给c1
c.assign(n,e) 将元素e的n个拷贝赋值给c
c.assign(beg,end) 将区间[beg,end]的元素赋值给c
c1.swap(c2) 将c1和c2元素互换
swap(c1,c2) 同上,全局函数
所有的赋值操作都有可能调用元素类型的默认构造函数,拷贝构造函数,赋值操作符和析构函数
迭代器相关函数操作 效果
at(idx) 返回索引idx所标识的元素的引用,进行越界检查
operator [](idx) 返回索引idx所标识的元素的引用,不进行越界检查
front() 返回第一个元素的引用,不检查元素是否存在
back() 返回最后一个元素的引用,不检查元素是否存在
操作 效果begin() 返回一个迭代器,指向第一个元素end() 返回一个迭代器,指向最后一个元素之后rbegin() 返回一个逆向迭代器,指向逆向遍历的第一个元素rend() 返回一个逆向迭代器,指向逆向遍历的最后一个元素迭代器持续有效,除非发生以下两种情况:
安插(insert)元素删除或插入元素
容量变化而引起内存重新分配
移除(remove)元素操作 效果
c.insert(pos,e) 在pos位置插入元素e的副本,并返回新元素位置
c.insert(pos,n,e) 在pos位置插入n个元素e的副本
c.insert(pos,beg,end) 在pos位置插入区间[beg,end]内所有元素的副本
c.push_back(e) 在尾部添加一个元素e的副本
map/multimap操作 效果c.pop_back() 移除最后一个元素但不返回最后一个元素c.erase(pos) 删除pos位置的元素,返回下一个元素的位置c.erase(beg,end) 删除区间[beg,end]内所有元素,返回下一个元素的位置c.clear() 移除所有元素,清空容器c.resize(num) 将元素数量改为num(增加的元素用defalut构造函数产生,多余的元素被删除)c.resize(num,e) 将元素数量改为num(增加的元素是e的副本)
构造、拷贝和析构使用平衡二叉树管理元素元素包含两部分(key,value),key和value可以是任意类型必须包含的头文件#include <map>根据元素的key自动对元素排序,因此根据元素的key进行定位很快,但根据元素的value定位很慢不能直接改变元素的key,可以通过operator []直接存取元素值map中不允许key相同的元素,multimap允许key相同的元素
非变动性操作操作 效果
map c 产生空的map
map c1(c2) 产生同类型的c1,并复制c2的所有元素
map c(op) 以op为排序准则产生一个空的map
map c(beg,end) 以区间[beg,end]内的元素产生一个map
map c(beg,end,op) 以op为排序准则,以区间[beg,end]内的元素产生一个map
~ map() 销毁所有元素并释放内存。
其中map可以是下列形式
map<key,value> 一个以less(<)为排序准则的map,
map<key,value,op> 一个以op为排序准则的map
赋值操作 效果
c.size() 返回元素个数
c.empty() 判断容器是否为空
c.max_size() 返回元素最大可能数量
c1==c2 判断c1是否等于c2
c1!=c2 判断c1是否不等于c2
c1<c2 判断c1是否小于c2
c1>c2 判断c1是否大于c2
c1<=c2 判断c1是否大于等于c2
c1>=c2 判断c1是否小于等于c2
特殊搜寻操作操作 效果
c1 = c2 将c2的全部元素赋值给c1
c1.swap(c2) 将c1和c2的元素互换
swap(c1,c2) 将c1和c2的元素互换.全局函数
操作 效果count(key) 返回”键值等于key”的元素个数find(key) 返回”键值等于key”的第一个元素,找不到返回endlower_bound(key) 返回”键值大于等于key”的第一个元素upper_bound(key) 返回”键值大于key”的第一个元素equal_range(key) 返回”键值等于key”的元素区间
操作 效果begin() 返回一个双向迭代器,指向第一个元素end() 返回一个双向迭代器,指向最后一个元素之后rbegin() 返回一个逆向迭代器,指向逆向遍历的第一个元素rend() 返回一个逆向迭代器,指向逆向遍历的最后一个元素
操作 效果c.insert(pos,e) 在pos位置为起点插入e的副本,并返回新元素位置(插入速度取决于pos)c.insert(e) 插入e的副本,并返回新元素位置c.insert(beg,end) 将区间[beg,end]内所有元素的副本插入到c中
操作 效果c.erase(pos) 删除迭代器pos所指位置的元素,无返回值c.erase(val) 移除所有值为val的元素,返回移除元素个数c.erase(beg,end) 删除区间[beg,end]内所有元素,无返回值c.clear() 移除所有元素,清空容器
set/multiset
SET实例 multiset实例使用平衡二叉树管理元素
集合(Set)是一种包含已排序对象的关联容器。
必须包含的头文件#include <set>
map容器是键-值对的集合,好比以人名为键的地址和电话号码。相反地,set容器只是单纯的键的集合。当我们想知道某位用户是否存在时,使用set容器是最合适的。
set中不允许key相同的元素,multiset允许key相同的元素
操作 效果begin()返回指向第一个元素的迭代器clear()清除所有元素count()返回某个值元素的个数empty()如果集合为空,返回trueend()返回指向最后一个元素的迭代器equal_range()返回集合中与给定值相等的上下限的两个迭代器erase()删除集合中的元素find()返回一个指向被查找到元素的迭代器get_allocator()返回集合的分配器
操作 效果insert() 在集合中插入元素lower_bound() 返回指向大于(或等于)某值的第一个元素的迭代器key_comp() 返回一个用于元素间值比较的函数max_size() 返回集合能容纳的元素的最大限值rbegin() 返回指向集合中最后一个元素的反向迭代器rend() 返回指向集合中第一个元素的反向迭代器size() 集合中元素的数目swap() 交换两个集合变量upper_bound() 返回大于某个值元素的迭代器value_comp() 返回一个用于比较元素间的值的函数
pair 模板: pair模板可以用于生成 key-value对
二、例题
三、感想ATM 运算符重载#include<bits/stdc++.h>
using namespace std;
class Time
{
int month,day,hour,minute;
public:
Time(int a,int b,int c,int d)
{
month=a;day=b;hour=c;minute=d;
}
Time()
{
month=day=hour=minute=0;
}
void setMonth(int x){month=x;}
int getMonth(){return month;}
void setDay(int y){day=y;}
int getDay(){return day;}
void setHour(int h){hour=h;}
int getHour(){return hour;}
void setMinute(int m){minute=m;}
int getMinute(){return minute;}
friend class user;
friend class record;
friend ostream&operator<<(ostream&os,const Time&d);
friend istream&operator>>(istream&is,Time&d);
};
ostream&operator<<(ostream&os,const Time&d)
{
os<<d.month<<" ";
os<<d.day<<" ";
os<<d.hour<<" ";
os<<d.minute;
return os;
}
istream&operator>>(istream&is,Time&d)
{
is>>d.month>>d.day>>d.hour>>d.minute;
return is;
}
class record
{
int no;
Time date;
string caozuo;
int jine;
double yue;
public:
record(int a,Time t,string s,int b,double c)
{
no=a;date=t;caozuo=s;jine=b;yue=c;
}
record()
{
no=jine=yue=0;
}
void setNo(int x){no=x;}
int getNo(){return no;}
void setJine(int jin){jine=jin;}
int getJine(){return jine;}
void setYue(int y){yue=y;}
int getYue(){return yue;}
void setCaozuo(string s){this->caozuo=s;}
string getCaozuo(){return caozuo;}
friend class user;friend class userop;
friend ostream &operator<<(ostream&out,const record&R);
friend istream &operator>>(istream&in,record&R);
};
ostream &operator<<(ostream&out,const record&R)
{
out<<R.no<<" ";out<<R.date;
out<<R.caozuo<<" "<<R.jine<<" "<<R.yue<<endl;
return out;
}
istream &operator>>(istream&in,record&R)
{
in>>R.no>>R.date>>R.caozuo>>R.jine>>R.yue;
return in;
}
class user
{
int no;
string name;
string mima;
double yue;
int n;
record r[200];
public:
user()
{
no=yue=0;
}
user(int x,string na,string mi,double b)
{
no=x;yue=b;name=na;mima=mi;
}
void setMima(string s){this->mima=s;}
string getMima(){return mima;}
void add(record r);
void disprecord(int i);
void dispAllrecord();
void queryByTime(int m1,int d1,int m2,int d2);
void queryByType(string caozuo);
double getYue(){return yue;}
int getNo(){return no;}
void setYue(double x){yue=x;}
void addd(int no,int a,int b,int c,int d,string caozuo,int jine,double yue);
void display();
};
void user::display()
{
cout<<no<<" "<<name<<" "<<mima<<" "<<yue<<endl;
}
void user::disprecord(int i)
{
cout<<r[i];
}
void user::addd(int no,int a,int b,int c,int d,string caozuo,int jine,double yue)
{
Time t(a,b,c,d);
record s(no,t,caozuo,jine,yue);
r[++n]=s;
}
void user::add(record s)
{
r[++n]=s;
}
void user::dispAllrecord()
{
for (int i=1;i<=n;i++)
cout<<r[i];
}
void user::queryByTime(int m1,int d1,int m2,int d2)
{
for (int i=1;i<=n;i++)
{
if (r[i].date.month>=m1&&r[1].date.month<=m2)
if (r[i].date.day>=d1&&r[1].date.day<=d2)
cout<<r[i];
}
}
void user::queryByType(string caozuo)
{
for (int i=1;i<=n;i++)
{
if (r[i].getCaozuo()==caozuo)
cout<<r[i];
}
}
class userop
{
Time t;
user usr;
public:
userop(int a,string b,string c,double d,int e,int f,int h,int w)
{
user q(a,b,c,d);
Time p(e,f,h,w);
usr=q;
t=p;
}
userop(user a,int b,int c,int d,int e)
{
usr=a;Time p(b,c,d,e);
t=p;
}
void withdraw(int a);
void deposit(int b);
void Bytime(int m1,int d1,int m2,int d2){usr.queryByTime(m1,d1,m2,d2);}
void Bytype(string s){usr.queryByType(s);}
void display(){usr.display();usr.dispAllrecord();}
};
void userop::withdraw(int a)
{
double b;
int c;
b=usr.getYue();
usr.setYue(b-a);
b=usr.getYue();
c=usr.getNo();
record m(c,t,"qq",a,b);
usr.add(m);
}
void userop::deposit(int a)
{
double b;
int c;
b=usr.getYue();
usr.setYue(b+a);
b=usr.getYue();
c=usr.getNo();
record m(c,t,"cq",a,b);
usr.add(m);
}
int main()
{
int a,e,f,g,h,o,p,e1,f1,g1,h1,o1,p1,a1;
string b,c;
double d;
cin>>a>>b>>c>>d>>e>>f>>g>>h>>o>>p;
cin>>e1>>f1>>g1>>h1>>o1>>p1>>a1;
userop uop1(a,b,c,d,e,f,g,h);user u1(a,b,c,d);
u1.display();
uop1.deposit(o);
uop1.withdraw(p);
uop1.Bytype("cq");
uop1.display();
user u2(2,"wyy","321",2000);
userop uop2(u2,e1,f1,g1,h1);
uop2.withdraw(o1);
uop2.withdraw(p1);
uop2.Bytype("qq");
uop2.deposit(a1);
uop2.display();
return 0;
}
刘凯 2018/5/24 14:43:29
#include<bits/stdc++.h>
using namespace std;
class Time
{
int month,day,hour,minute;
public:
Time(int a,int b,int c,int d)
{
month=a;day=b;hour=c;minute=d;
}
Time()
{
month=day=hour=minute=0;
}
void setMonth(int x){month=x;}
int getMonth(){return month;}
void setDay(int y){day=y;}
int getDay(){return day;}
void setHour(int h){hour=h;}
int getHour(){return hour;}
void setMinute(int m){minute=m;}
int getMinute(){return minute;}
friend class user;
friend class record;
friend ostream&operator<<(ostream&os,const Time&d);
friend istream&operator>>(istream&is,Time&d);
};
ostream&operator<<(ostream&os,const Time&d)
{
os<<d.month<<" ";
os<<d.day<<" ";
os<<d.hour<<" ";
os<<d.minute;
return os;
}
istream&operator>>(istream&is,Time&d)
{
is>>d.month>>d.day>>d.hour>>d.minute;
return is;
}
class record
{
int no;
Time date;
string caozuo;
int jine;
double yue;
public:
record(int a,Time t,string s,int b,double c)
{
no=a;date=t;caozuo=s;jine=b;yue=c;
}
record()
{
no=jine=yue=0;
}
void setNo(int x){no=x;}
int getNo(){return no;}
void setJine(int jin){jine=jin;}
int getJine(){return jine;}
void setYue(int y){yue=y;}
int getYue(){return yue;}
void setCaozuo(string s){this->caozuo=s;}
string getCaozuo(){return caozuo;}
friend class user;friend class userop;
friend ostream &operator<<(ostream&out,const record&R);
friend istream &operator>>(istream&in,record&R);
};
ostream &operator<<(ostream&out,const record&R)
{
out<<R.no<<" ";out<<R.date<<" ";
out<<R.caozuo<<" "<<R.jine<<" "<<R.yue<<endl;
return out;
}
istream &operator>>(istream&in,record&R)
{
in>>R.no>>R.date>>R.caozuo>>R.jine>>R.yue;
return in;
}
class user
{
int no;
string name;
string mima;
double yue;
int n;
record r[200];
public:
user()
{
no=yue=0;
}
user(int x,string na,string mi,double b)
{
no=x;yue=b;name=na;mima=mi;
}
void setMima(string s){this->mima=s;}
string getMima(){return mima;}
void add(record r);
void disprecord(int i);
void dispAllrecord();
void queryByTime(int m1,int d1,int m2,int d2);
void queryByType(string caozuo);
double getYue(){return yue;}
int getNo(){return no;}
void setYue(double x){yue=x;}
void addd(int no,int a,int b,int c,int d,string caozuo,int jine,double yue);
void display();
};
void user::display()
{
cout<<no<<" "<<name<<" "<<mima<<" "<<yue<<endl;
}
void user::disprecord(int i)
{
cout<<r[i];
}
void user::addd(int no,int a,int b,int c,int d,string caozuo,int jine,double yue)
{
Time t(a,b,c,d);
record s(no,t,caozuo,jine,yue);
r[++n]=s;
}
void user::add(record s)
{
r[++n]=s;
}
void user::dispAllrecord()
{
for (int i=1;i<=n;i++)
cout<<r[i];
}
void user::queryByTime(int m1,int d1,int m2,int d2)
{
for (int i=1;i<=n;i++)
{
if (r[i].date.month>=m1&&r[1].date.month<=m2)
if (r[i].date.day>=d1&&r[1].date.day<=d2)
cout<<r[i];
}
}
void user::queryByType(string caozuo)
{
for (int i=1;i<=n;i++)
{
if (r[i].getCaozuo()==caozuo)
cout<<r[i];
}
}
class userop
{
Time t;
user usr;
public:
userop(int a,string b,string c,double d,int e,int f,int h,int w)
{
user q(a,b,c,d);
Time p(e,f,h,w);
usr=q;
t=p;
}
userop(user a,int b,int c,int d,int e)
{
usr=a;Time p(b,c,d,e);
t=p;
}
void withdraw(int a);
void deposit(int b);
void Bytime(int m1,int d1,int m2,int d2){usr.queryByTime(m1,d1,m2,d2);}
void Bytype(string s){usr.queryByType(s);}
void display(){usr.display();usr.dispAllrecord();}
};
void userop::withdraw(int a)
{
double b;
int c;
b=usr.getYue();
usr.setYue(b-a);
b=usr.getYue();
c=usr.getNo();
record m(c,t,"qq",a,b);
usr.add(m);
}
void userop::deposit(int a)
{
double b;
int c;
b=usr.getYue();
usr.setYue(b+a);
b=usr.getYue();
c=usr.getNo();
record m(c,t,"cq",a,b);
usr.add(m);
}
int main()
{
int a,e,f,g,h,o,p,e1,f1,g1,h1,o1,p1,a1;
string b,c;
double d;
cin>>a>>b>>c>>d>>e>>f>>g>>h>>o>>p;
cin>>e1>>f1>>g1>>h1>>o1>>p1>>a1;
userop uop1(a,b,c,d,e,f,g,h);user u1(a,b,c,d);
u1.display();
uop1.deposit(o);
uop1.withdraw(p);
uop1.Bytype("cq");
uop1.display();
user u2(2,"wyy","321",2000);
userop uop2(u2,e1,f1,g1,h1);
uop2.withdraw(o1);
uop2.withdraw(p1);
uop2.Bytype("qq");
uop2.deposit(a1);
uop2.display();
return 0;
}
又学完一章了,会的还是不多,上一章还没搞懂,这一章又学完了,程序也不怎么会写,重载运算符也没怎么看懂,STL又讲完了,落下的越来越多,也越来越跟不上,之后只能靠自己了,会的不太多,也没太多感想,只是觉得接下来的自学很重要,毕竟这个学期过了一大半了,自己努努力吧,争取多学点,多会点,接下来的时间就要认真学运算符重载了,努力能自己编出程序。