重载运算符和STL总结

一．知识归纳

重载运算符

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的情况并不理想，希望通过多练习能渐渐熟悉这个操作套路，在以后的程序中用好。