一.知识归纳
重载运算符
1.重载运算符的限制
重载运算符函数可以对运算符作出新的解释,但原有基本语义不变:
①不改变运算符的优先级;
②不改变运算符的结合性;
③不改变运算符所需要的操作数;
④不能创建新的运算符。
不能重载的算符:
.::.*?:sizeof
可以重载的运算符
+-*/%^&|~
!=<>+=-=*=/=%
^=&=|=<<>>>>=<<===!=
<=>=&&||++--->*‘->
[]()newdeletenew[]delete[]
2.一元与二元运算符的重载
1. 一元运算符
Object op 或 op Object
⑴重载为成员函数,解释为:
Object . operator op ()
操作数由对象Object通过this指针隐含传递
⑵重载为友元函数,解释为:
operator op (Object)
操作数由参数表的参数Object提供
2. 二元运算符
ObjectL op ObjectR
⑴重载为成员函数,解释为:
ObjectL . operator op ( ObjectR )
左操作数由ObjectL通过this指针传递,右操作数由参数ObjectR传递
⑵重载为友元函数,解释为:
operator op ( ObjectL, ObjectR )
左右操作数都由参数传递
3.双目与单目运算符的重载:成员函数
* 成员运算符函数的原型在类的内部声明格式如下:
class X {
//…
返回类型 operator运算符(形参表);
//…
}
在类外定义成员运算符函数的格式如下:
返回类型 X::operator运算符(形参表)
{
函数体
}
1. 对双目运算符而言,成员运算符函数的形参表中仅有一个参数,它作为运算符的右操作数,此时当前对象作为运算符的左操作数,它是通过this指针隐含地传递给函数的。
Eg:
#include <iostream.h>
class Complex
{
public:
Complex( ){real=0,imag=0;}
Complex(double r,double i){real=r; imag=i;}
Complex operator + (Complex &c2);
void display( );
private:
double real;
double imag;
};
Complex Complex:: operator + (Complex &c2)
{return Complex(real+c2.real, imag+c2.imag);}
void Complex::display( )
{cout<<"("<<real<<","<<imag<<"i)"<<endl;}
int main( )
{ Complex c1(3,4),c2(5,-10),c3;
c3=c1+c2;
cout<<"c1=";c1.display( );
cout<<"c2=";c2.display( );
cout<<"c1+c2 =";c3.display( );
return 0;
}
一般而言,如果在类X中采用成员函数重载双目运算符@,成员运算符函数operator@ 所需的一个操作数由对象aa通过this指针隐含地传递,它的另一个操作数bb在参数表中显示,aa和bb是类X的两个对象,则以下两种函数调用方法是等价的:
aa @ bb; // 隐式调用
aa.operator @(bb); // 显式调用
2. 对单目运算符而言,成员运算符函数的参数表中没有参数,此时当前对象作为运算符的一个操作数。
一般而言,采用成员函数重载单目运算符时,以下两种方法是等价的:
@aa; // 隐式调用
aa.operator@(); // 显式调用
成员运算符函数operator @所需的一个操作数由对象aa通过this指针隐含地传递。因此,在它的参数表中没有参数。
4.友元函数重载:常用于运算符的左右操作数类型不同的情况
Eg:
class Complex
{
int Real ;
int Imag ;
public :
Complex ( int a ) { Real = a ; Imag = 0 ; }
Complex ( int a , int b ) { Real = a ; Imag = b ; }
Complex operator + ( Complex ) ;
…
} ;
int f ( )
{ Complex z ( 2 , 3 ) , k ( 3 , 4 ) ;
z = z + 27 ; // z . operator + ( 27 ) √
z = 27 + z ; //27 . operator + ( Z ) ×
…
}
注:
①在第一个参数需要隐式转换的情形下,使用友元函数重载运算符是正确的选择
友元函数没有 this 指针,所需操作数都必须在参数表显式声明,很容易实现类型的隐式转换
②C++中不能用友元函数重载的运算符有
= () [] ->
Eg:
#include<iostream>
using namespace std;
class Complex
{ public:
Complex( double r =0, double i =0 ) { Real = r ; Image = i ; }
Complex(int a) { Real = a ; Image = 0 ; }
void print() const ;
friend Complex operator+ ( const Complex & c1, const Complex & c2 ) ;
friend Complex operator- ( const Complex & c1, const Complex & c2 ) ;
friend Complex operator- ( const Complex & c ) ;
private:
double Real, Image ;
};
Complex operator + ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real + c2.Real ; double i = c1.Image+c2.Image ;
return Complex ( r, i ) ;
}
Complex operator - ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real - c2.Real ; double i = c1.Image - c2.Image ;
return Complex ( r, i ) ;
}
Complex operator- ( const Complex & c )
{ return Complex ( -c.Real, - c.Image ) ; }
void Complex :: print() const
{ cout << '(' << Real << " , " << Image << ')' << endl ; }
5.成员运算符函数与友元运算符函数的比较
(1) 成员运算符函数比友元运算符函数少带一个参数(后置的++、--需要增加一个形参)。
(2) 双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。
6.几个典型运算符重载
1.设 A Aobject ;
运算符 ++和 - - 有两种方式:
前置方式: ++Aobject --Aobject
成员函数 重载 A :: A operator++ () ;
解释为: Aobject . operator ++( ) ;
友元函数 重载 friend A operator++ (A &) ;
解释为: operator ++( Aobject ) ;
后置方式: Aobject ++ Aobject --
成员函数 重载 A :: A operator++ (int) ;
解释为: Aobject . operator ++( 0 ) ;
友元函数 重载: friend A operator++ (A &, int) ;
解释为: operator++(Aobject, 0)
Eg:
#include<iostream>
using namespace std;
class Increase
{ public :
Increase ( ) { value=0; }
void display( ) const { cout<<value<<'\n'; } ;
friend Increase operator ++ ( Increase & ) ; // 前置
friend Increase operator ++ ( Increase &, int ) ; // 后置
private: unsigned value ;
};
Increase operator ++ ( Increase & a )
{ a.value ++ ; return a ; }
Increase operator ++ ( Increase & a, int )
{ Increase temp(a); a.value ++ ; return temp; }
int main( )
{ Increase a , b , n ; int i ;
for ( i = 0 ; i < 10 ; i ++ ) a = n ++ ;
cout <<"n= " ; n.display( ) ; cout <<"a= " ; a.display( ) ;
for ( i = 0 ; i < 10 ; i ++ ) b = ++ n ;
cout << "n= " ; n.display( ) ; cout << "b= " ; b.display( ) ;
}
2. 重载赋值运算符
①赋值运算符重载用于对象数据的复制
②operator= 必须重载为成员函数
③重载函数原型为:
④类名 & 类名 :: operator= ( 类名 ) ;
Eg:
#include<iostream>
#include<cstring>
using namespace std;
class Name
{ public :
Name ( char *pN ) ;
Name( const Name & ) ; //复制构造函数
Name& operator=( const Name& ) ; // 重载赋值运算符
~ Name() ;
protected :
char *pName ;
int size ;
} ;
int main()
{ Name Obj1( "ZhangSan" ) ;
Name Obj2 = Obj1 ; // 调用复制构造函数
Name Obj3( "NoName" ) ;
Obj3 = Obj2 = Obj1 ; // 调用重载赋值运算符函数 (修改对象时调用重载赋值运算符函数)
}
Name::Name ( char *pN )
{ cout <<" Constructing " << pN << endl ;
pName = new char[ strlen( pN ) + 1 ] ;
if( pName != 0 ) strcpy( pName,pN ) ;
size = strlen( pN ) ;
}
Name::Name( const Name & Obj ) //复制构造函数
{ cout << " Copying " << Obj.pName << " into its own block\n";
pName = new char[strlen( Obj.pName ) + 1 ] ;
if ( pName != 0 ) strcpy( pName, Obj.pName ) ;
size = Obj.size;
}
Name & Name::operator= ( const Name & Obj ) // 重载赋值运算符
{ delete []pName ;
pName = new char[ strlen( Obj.pName ) + 1 ] ;
if ( pName != 0 ) strcpy( pName , Obj.pName ) ;
size = Obj.size ;
return *this ;
}
Name::~ Name()
{ cout << " Destructing " << pName << endl ;
delete []pName ;
size = 0;
}
3. 重载运算符[]和()
①运算符 [] 和 () 是二元运算符
②[] 和 () 只能用成员函数重载,不能用友元函数重载
[] :用于访问数据对象的元素
重载格式 类型 类 :: operator[] ( 类型 ) ;
如 设 x 是类 X 的一个对象,则表达式
x [ y ]
可被解释为
x . operator [ ] ( y )
Eg:
#include<iostream>
using namespace std;
class vector
{ public :
vector ( int n ) { v = new int [ n ] ; size = n ; }
~ vector ( ) { delete [ ] v ; size = 0 ; }
int & operator [ ] ( int i ) { return v [ i ] ; }
private :
int * v ; int size ;
};
int main ( )
{ vector a ( 5 ) ;
a [ 2 ] = 12 ;
cout << a [ 2 ] << endl ;
}
():用于函数调用
重载格式 类型 类 :: operator() (参数表) ;
如
设 x 是类 X 的一个对象,则表达式
x ( arg1, arg2, … )
可被解释为
x . operator () (arg1, arg2, … )
Eg:
#include <iostream>
using namespace std ;
class F
{ public :
double operator ( ) ( double x , double y ) ;
} ;
double F :: operator ( ) ( double x , double y )
{ return x * x + y * y ; }
int main ( )
{ F f ;
cout << f ( 5.2 , 2.5 ) << endl ;
}
4. 重载流插入和流提取运算符
①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++编译器和所有操作系统平台都支持的一种库
二. 组件
容器(Container) - 管理某类对象的集合
迭代器(Iterator) - 在对象集合上进行遍历
算法(Algorithm) - 处理集合内的元素
容器适配器(container adaptor)
函数对象(functor)
三.STL容器类别
序列式容器-排列次序取决于插入时机和位置
关联式容器-排列顺序取决于特定准则
能力:
所有容器中存放的都是值而非引用。如果希望存放的不是副本,容器元素只能是指针。
所有元素都形成一个次序(order),可以按相同的次序一次或多次遍历每个元素
元素条件:
必须能够通过拷贝构造函数进行复制
必须可以通过赋值运算符完成赋值操作
必须可以通过析构函数完称销毁动作
序列式容器元素的默认构造函数必须可用
某些动作必须定义operator ==,例如搜寻操作
关联式容器必须定义出排序准则,默认情况是重载operator <
共同操作:
初始化
与大小相关的操作
size()-返回当前容器的元素数量
empty()-判断容器是否为空
max_size()-返回容器能容纳的最大元素数量
比较
==,!=,<,<=,>,>=
比较操作两端的容器必须属于同一类型
如果两个容器内的所有元素按序相等,那么这两个容器相等
采用字典式顺序判断某个容器是否小于另一个容器
赋值和交换
swap用于提高赋值操作效率
与迭代器相关的操作
begin()-返回一个迭代器,指向第一个元素
end()-返回一个迭代器,指向最后一个元素之后
rbegin()-返回一个逆向迭代器,指向逆向遍历的第一个元素
rend()-返回一个逆向迭代器,指向逆向遍历的最后一个元素之后
元素操作
insert(pos,e)-将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)-移除[beg,end]区间内的所有元素
clear()-移除所有元素
三.迭代器
可遍历STL容器内全部或部分元素的对象
指出容器中的一个特定位置
迭代器的基本操作
操作 | 效果 | |
* | 返回当前位置上的元素值。如果该元素有成员,可以通过迭代器以operator ->取用 | |
++ | 将迭代器前进至下一元素 | |
==和!= | 判断两个迭代器是否指向同一位置 | |
= | 为迭代器赋值(将所指元素的位置赋值过去) | |
begin() | 返回一个迭代器,指向第一个元素 | |
end() | 返回一个迭代器,指向最后一个元素之后 |
四.vector
vector模拟动态数组
vector的元素可以是任意类型T,但必须具备赋值和拷贝能力(具有public拷贝构造函数和重载的赋值操作符)
必须包含的头文件#include <vector>
vector支持随机存取
vector的大小(size)和容量(capacity)
size返回实际元素个数,
capacity返回vector能容纳的元素最大数量。如果插入元素时,元素个数超过capacity,需要重新配置内部存储器。
1.构造、拷贝和析构
操作 | 效果 |
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>() | 销毁所有元素并释放内存。 |
2. 非变动操作
操作 | 效果 |
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 |
3.赋值操作
操作 | 效果 |
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) | 同上,全局函数 |
4.元素存取
操作 | 效果 | |
at(idx) | 返回索引idx所标识的元素的引用,进行越界检查 | |
operator [](idx) | 返回索引idx所标识的元素的引用,不进行越界检查 | |
front() | 返回第一个元素的引用,不检查元素是否存在 | |
back() | 返回最后一个元素的引用,不检查元素是否存在 |
5.安插(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的副本 |
6.移除(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相同的元素
1.构造、拷贝和析构
操作 | 效果 |
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() | 销毁所有元素并释放内存。 |
2.赋值
操作 | 效果 |
c1 = c2 | 将c2的全部元素赋值给c1 |
c1.swap(c2) | 将c1和c2的元素互换 |
swap(c1,c2) | 同上,全局函数 |
3.特殊搜寻操作
操作 | 效果 |
count(key) | 返回”键值等于key”的元素个数 |
find(key) | 返回”键值等于key”的第一个元素,找不到返回end |
lower_bound(key) | 返回”键值大于等于key”的第一个元素 |
upper_bound(key) | 返回”键值大于key”的第一个元素 |
equal_range(key) | 返回”键值等于key”的元素区间 |
4.安插(insert)元素
操作 | 效果 |
c.insert(pos,e) | 在pos位置为起点插入e的副本,并返回新元素位置(插入速度取决于pos) |
c.insert(e) | 插入e的副本,并返回新元素位置 |
c.insert(beg,end) | 将区间[beg,end]内所有元素的副本插入到c中 |
5.移除(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相同的元素
1.
操作 | 效果 |
begin() | 返回指向第一个元素的迭代器 |
clear() | 清除所有元素 |
count() | 返回某个值元素的个数 |
empty() | 如果集合为空,返回true |
end() | 返回指向最后一个元素的迭代器 |
equal_range() | 返回集合中与给定值相等的上下限的两个迭代器 |
erase() | 删除集合中的元素 |
find() | 返回一个指向被查找到元素的迭代器 |
get_allocator() | 返回集合的分配器 |
insert() | 在集合中插入元素 |
lower_bound() | 返回指向大于(或等于)某值的第一个元素的迭代器 |
key_comp() | 返回一个用于元素间值比较的函数 |
max_size() | 返回集合能容纳的元素的最大限值 |
rbegin() | 返回指向集合中最后一个元素的反向迭代器 |
rend() | 返回指向集合中第一个元素的反向迭代器 |
size() | 集合中元素的数目 |
swap() | 交换两个集合变量 |
upper_bound() | 返回大于某个值元素的迭代器 |
value_comp() | 返回一个用于比较元素间的值的函数 |
七. 排序和查找算法
1. Find
template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);
返回区间 [first,last) 中的迭代器 i ,使得 * i == val
2.find if
template<class InIt, class Pred>
InIt find_if(InIt first, InIt last, Pred pr);
返回区间 [first,last) 中的迭代器 i, 使得 pr(*i) == true
3. binary_search 折半查找,要求容器已经有序且支持随机访问迭代器,返回是否找到
template<class FwdIt, class T>
bool binary_search(FwdIt first, FwdIt last, const T& val);
上面这个版本,比较两个元素x,y 大小时, 看 x < y
template<class FwdIt, class T, class Pred>
bool binary_search(FwdIt first, FwdIt last, const T& val, Pred pr);
上面这个版本,比较两个元素x,y 大小时, 看 pr(x,y)
二.心得体会
1.重载运算符主要是丰富了运算符可以操作的类型,让我们在使用c++写程序时更加简便。在用重载运算符改ATM时主要修改了一下输入输出,在其中也遇到了一些小问题,比如B程序输入中r1是不需要输入时间的但是r2需要输入时间,这样一来输入的格式便不好统一。有些时候听起来很简单的东西还是要自己试一遍才熟悉,特别是对于我们这些天赋一般的人。
2.STL由集合类和操作算法构成,具有数据结构和算法分离的特点以及可重用性和可扩展性,可以实现高效率地写代码。但前提是得会用。听老师讲的时候觉得差不多懂了,但是到了实际应用时发现根本不是那么回事,简直无从下手。所以用这个来改ATM的情况并不理想,希望通过多练习能渐渐熟悉这个操作套路,在以后的程序中用好。