运算符重载和STL容器

本文详细介绍了C++中的运算符重载,包括重载的限制、方式以及成员函数与友元函数的使用场景。此外,文章还讲解了STL容器的核心概念,如容器、迭代器、算法等,以及常见容器如vector、list、map的操作和特点。重点阐述了赋值运算符、下标运算符和函数调用运算符的重载,并讨论了STL如何使用模板和算法来提供泛型编程的支持。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、知识点

重载运算符

重载运算符的限制

重载运算符函数可以对运算符作出新的解释,但原有基本语义不变:

不改变运算符的优先级 

不改变运算符的结合性

不改变运算符所需要的操作数

不能创建新的运算符

运算符函数可以重载为成员函数或友元函数

一元运算符

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++中不能用友元函数重载的运算符有

       =    ()    []    ->

成员运算符函数与友元运算符函数的比较

成员运算符函数比友元运算符函数少带一个参数(后置的++、--需要增加一个形参)。

 双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。

几个典型运算符重载
数学类中常用的几个运算符重载的特点和应用

设    A  Aobject ;

运算符 ++和 - - 有两种方式:

前置方式:   ++Aobject    --Aobject

成员函数重载    A ::A operator++ () ;

       解释为:Aobject . operator ++( );

   友元函数重载  friendA operator++ (A &) ;

       解释为:operator ++( Aobject ) ;

后置方式:Aobject ++      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;

}

重载输入运算符“>>” (只能被重载成友元函数)

定义输入运算符函数 “>>”重载函数的一般格式如下:

    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,…)而言,以上条件总是满足

STL容器的共同操作
初始化(initialization)

产生一个空容器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]));

与大小相关的操作(size operator)

size()-返回当前容器的元素数量

empty()-判断容器是否为空

max_size()-返回容器能容纳的最大元素数量

比较(comparison)==,!=,<,<=,>,>=

比较操作两端的容器必须属于同一类型

如果两个容器内的所有元素按序相等,那么这两个容器相等

采用字典式顺序判断某个容器是否小于另一个容器

赋值(assignment)和交换(swap)

swap用于提高赋值操作效率

与迭代器(iterator)相关的操作

begin()-返回一个迭代器,指向第一个元素

end()-返回一个迭代器,指向最后一个元素之后

rbegin()-返回一个逆向迭代器,指向逆向遍历的第一个元素

rend()-返回一个逆向迭代器,指向逆向遍历的最后一个元素之后

元素操作

insert(pos,e)-将元素e的拷贝安插于迭代器pos所指的位置

erase(beg,end)-移除[beg,end]区间内的所有元素

clear()-移除所有元素

迭代器(iterator)(示例:iterator)

可遍历STL容器内全部或部分元素的对象

指出容器中的一个特定位置

迭代器的基本操作

 
返回当前位置上的元素值。如果该元素有成员,可以通过迭代器以operator ->取用

++              

将迭代器前进至下一元素

==和!=

 判断两个迭代器是否指向同一位置

=

  为迭代器赋值(将所指元素的位置赋值过去迭代器(iterator)

所有容器都提供获得迭代器的函数

begin() 返回一个迭代器,指向第一个元素

end() 返回一个迭代器,指向最后一个元素之后

半开区间[beg, end)的好处:

1.为遍历元素时循环的结束时机提供了简单的判断依据(只要未到达end(),循环就可以继续)

2.不必对空区间采取特殊处理(空区间的begin()就等于end())

所有容器都提供两种迭代器


container::iterator以“读/写”模式遍历元素

container::const_iterator以“只读”模式遍历元素

迭代器(iterator)

迭代器分类

双向迭代器

可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。

list、set和map提供双向迭代器

随机存取迭代器

除了具备双向迭代器的所有属性,还具备随机访问能力。

可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。

vector、deque和string提供随机存取迭代器

vector

vector模拟动态数组

vector的元素可以是任意类型T,但必须具备赋值和拷贝能力(具有public拷贝构造函数和重载的赋值操作符)

必须包含的头文件#include <vector>

vector支持随机存取

vector的大小(size)和容量(capacity)

size返回实际元素个数,

capacity返回vector能容纳的元素最大数量。如果插入元素时,元素个数超过capacity,需要重新配置内部存储器。

vector

构造、拷贝和析构

操作             效果

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)   扩大容量为n
 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

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)元素

操作 效果

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的副本

移除(remove)元素
操作                                  效果
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的副本)
map/multimap
使用平衡二叉树管理元素
元素包含两部分(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”的第一个元素,找不到返回end
lower_bound(key)     返回”键值大于等于key”的第一个元素
upper_bound(key)     返回”键值大于key”的第一个元素
equal_range(key)     返回”键值等于key”的元素区间
迭代器相关函数

操作          效果
begin() 返回一个双向迭代器,指向第一个元素
end() 返回一个双向迭代器,指向最后一个元素之后
rbegin() 返回一个逆向迭代器,指向逆向遍历的第一个元素
rend() 返回一个逆向迭代器,指向逆向遍历的最后一个元素
安插(insert)元素

操作                               效果
c.insert(pos,e)         在pos位置为起点插入e的副本,并返回新元素位置(插入速度取决于pos)
c.insert(e)         插入e的副本,并返回新元素位置
c.insert(beg,end) 将区间[beg,end]内所有元素的副本插入到c中
移除(remove)元素

操作                 效果
c.erase(pos)           删除迭代器pos所指位置的元素,无返回值
c.erase(val)           移除所有值为val的元素,返回移除元素个数
c.erase(beg,end)   删除区间[beg,end]内所有元素,无返回值
c.clear()               移除所有元素,清空容器

set/multiset


使用平衡二叉树管理元素

集合(Set)是一种包含已排序对象的关联容器。

必须包含的头文件#include <set>

map容器是键-值对的集合,好比以人名为键的地址和电话号码。相反地,set容器只是单纯的键的集合。当我们想知道某位用户是否存在时,使用set容器是最合适的。

set中不允许key相同的元素,multiset允许key相同的元素


操作                        效果
begin()                          
返回指向第一个元素的迭代器
clear()                                 
清除所有元素
count()                    
返回某个值元素的个数
empty()                  
如果集合为空,返回true
end()                      
返回指向最后一个元素的迭代器
equal_range()          
返回集合中与给定值相等的上下限的两个迭代器
erase()                     
删除集合中的元素
find()                       
返回一个指向被查找到元素的迭代器
get_allocator()        
返回集合的分配器
SET实例    multiset实例
操作                                     效果                                    
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又讲完了,落下的越来越多,也越来越跟不上,之后只能靠自己了,会的不太多,也没太多感想,只是觉得接下来的自学很重要,毕竟这个学期过了一大半了,自己努努力吧,争取多学点,多会点,接下来的时间就要认真学运算符重载了,努力能自己编出程序。




 





 



 


 



       







评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值