基础知识点
运算符重载可以使用户自定义的数据以一种更简洁的方式工作
●不能重载的算符
. :: .* ?: sizeof
●可以重载的运算符
+ - * / % ^ & | ~
! = < > += -= *= /= %
^= &= |= << >> >>= <<= == !=
<= >= && || ++ -- ->* ‘ ->
[] () new delete new[] delete[]
●重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
Ø 不改变运算符的优先级
Ø 不改变运算符的结合性
Ø 不改变运算符所需要的操作数
Ø 不能创建新的运算符
Ø 运算符函数可以重载为成员函数或友元函数
●一元运算符
Object op 或 op Object
Ø 重载为成员函数，解释为：
Object . operator op()
操作数由对象Object通过this指针隐含传递
Ø重载为友元函数，解释为：
operator op (Object)
操作数由参数表的参数Object提供
●二元运算符
Ø 重载为成员函数，解释为：
ObjectL . operatorop ( ObjectR )
左操作数由ObjectL通过this指针传递，右操作数由参数ObjectR传递
Ø重载为友元函数，解释为：
operator op (ObjectL, ObjectR )
左右操作数都由参数传递
●对双目运算符而言,成员运算符函数的形参表中仅有一个参数,它作为运算符的右操作数,此时当前对象作为运算符的左操作数,它是通过this指针隐含地传递给函数的。
●一般而言,如果在类X中采用成员函数重载双目运算符@,成员运算符函数operator@ 所需的一个操作数由对象aa通过this指针隐含地传递,它的另一个操作数bb在参数表中显示,aa和bb是类X的两个对象,则以下两种函数调用方法是等价的:
aa @ bb; // 隐式调用
aa.operator @(bb); // 显式调用
●对单目运算符而言,成员运算符函数的参数表中没有参数,此时当前对象作为运算符的一个操作数。
● 一般而言,采用成员函数重载单目运算符时,以下两种方法是等价的:
@aa; // 隐式调用
aa.operator@(); // 显式调用
成员运算符函数operator @所需的一个操作数由对象aa通过this指针隐含地传递。因此,在它的参数表中没有参数。
Ø●在第一个参数需要隐式转换的情形下，使用友元函数重载
运算符是正确的选择
Ø 友元函数没有this 指针，所需操作数都必须在参数表显式
声明，很容易实现类型的隐式转换
Ø C++中不能用友元函数重载的运算符有
= （） ［］ －>
●成员运算符函数与友元运算符函数的比较
(1) 成员运算符函数比友元运算符函数少带一个参数（后置的++、--需要增加一个形参）。
(2) 双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。
●数学类中常用的几个运算符重载的特点和应用
设 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)
●重载赋值运算符
Ø 赋值运算符重载用于对象数据的复制
Ø operator= 必须重载为成员函数
Ø重载函数原型为：
类名 & 类名 :: operator= ( 类名 ) ;
●重载运算符[]和()
Ø 运算符 [] 和 () 是二元运算符
Ø [] 和 () 只能用成员函数重载，不能用友元函数重载
●重载下标运算符 []
[] 运算符用于访问数据对象的元素
重载格式 类型 类 ::operator[] ( 类型 ) ；
●重载函数调用符 ()
() 运算符用于函数调用
重载格式 类型 类 :: operator() ( 参数表 ) ；
●重载流插入和流提取运算符
Ø istream和 ostream 是 C++ 的预定义流类
Øcin 是 istream 的对象，cout 是 ostream 的对象
Ø运算符 << 由ostream重载为插入操作，用于输出基本类型数据
Ø运算符 >> 由 istream重载为提取操作，用于输入基本类型数据
Ø用友元函数重载 << 和 >>，输出和输入用户自定义的数据类型
STL概述
n STL是C++标准程序库的核心，深刻影响了标准程序库的整体结构
n STL由一些可适应不同需求的集合类（collection class），以及在这些数据集合上操作的算法（algorithm）构成
n STL内的所有组件都由模板（template）构成，其元素可以是任意类型
n STL是所有C++编译器和所有操作系统平台都支持的一种库
●STL组件
Ø容器（Container） － 管理某类对象的集合
Ø迭代器（Iterator） － 在对象集合上进行遍历
Ø算法（Algorithm） － 处理集合内的元素
Ø容器适配器（container adaptor）
●STL容器的共同能力
Ø所有容器中存放的都是值而非引用。如果希望存放的不是副本，容器元素只能是指针。
Ø所有元素都形成一个次序（order），可以按相同的次序一次或多次遍历每个元素
●STL容器元素的条件
Ø必须能够通过拷贝构造函数进行复制
Ø必须可以通过赋值运算符完成赋值操作
Ø必须可以通过析构函数完称销毁动作
Ø序列式容器元素的默认构造函数必须可用
Ø某些动作必须定义operator ==，例如搜寻操作
Ø关联式容器必须定义出排序准则，默认情况是重载operator <
对于基本数据类型（int,long,char,double,…）而言，以上条件总是满足
●STL容器的共同操作
Ø与大小相关的操作（size operator）
Fsize()－返回当前容器的元素数量
Fempty()－判断容器是否为空
Fmax_size()－返回容器能容纳的最大元素数量
Ø比较（comparison）
F==,!=,<,<=,>,>=
F比较操作两端的容器必须属于同一类型
F如果两个容器内的所有元素按序相等，那么这两个容器相等
F采用字典式顺序判断某个容器是否小于另一个容器
Ø赋值（assignment）和交换（swap）
Fswap用于提高赋值操作效率
Ø与迭代器（iterator）相关的操作
Fbegin()－返回一个迭代器，指向第一个元素
Fend()－返回一个迭代器，指向最后一个元素之后
Frbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素
Frend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
Ø 元素操作
Finsert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置
Ferase(beg,end)－移除[beg，end]区间内的所有元素
Fclear()－移除所有元素
●迭代器（iterator）（示例:iterator）
Ø可遍历STL容器内全部或部分元素的对象
Ø指出容器中的一个特定位置
Ø迭代器的基本操作
操作 | 效果 |
* | 返回当前位置上的元素值。如果该元素有成员，可以通过迭代器以operator ->取用 |
++ | 将迭代器前进至下一元素 |
==和!= | 判断两个迭代器是否指向同一位置 |
= | 为迭代器赋值（将所指元素的位置赋值过去） |
●vector
Øvector模拟动态数组
Øvector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
Ø必须包含的头文件#include <vector>
Øvector支持随机存取
Øvector的大小（size）和容量（capacity）
Fsize返回实际元素个数，
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) | 扩大容量为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() | 销毁所有元素并释放内存。 |
Ø非变动性操作
操作 | 效果 |
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) | 同上，全局函数 |
Ø特殊搜寻操作
操作 | 效果 |
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相同的元素
Øset/multset
操作 | 效果 |
返回指向第一个元素的迭代器 | |
清除所有元素 | |
返回某个值元素的个数 | |
如果集合为空，返回true | |
返回指向最后一个元素的迭代器 | |
返回集合中与给定值相等的上下限的两个迭代器 | |
删除集合中的元素 | |
返回一个指向被查找到元素的迭代器 | |
返回集合的分配器 | |
操作 | 效果 SET实例 multiset实例 |
在集合中插入元素 | |
返回指向大于（或等于）某值的第一个元素的迭代器 | |
返回一个用于元素间值比较的函数 | |
返回集合能容纳的元素的最大限值 | |
返回指向集合中最后一个元素的反向迭代器 | |
返回指向集合中第一个元素的反向迭代器 | |
集合中元素的数目 | |
交换两个集合变量 | |
返回大于某个值元素的迭代器 | |
返回一个用于比较元素间的值的函数 |
例子
●成员运算符函数的原型在类的内部声明格式如下:
class X
{
//…
返回类型 operator运算符(形参表);
//…
}
●在类外定义成员运算符函数的格式如下:
返回类型 X::operator运算符(形参表)
{
函数体
}
●双目运算符重载为成员函数
#include <iostream.h>
class Complex
{
public:
Complex() {real=0,imag=0;}
Complex(doubler,double i) {real=r; imag=i;}
Complex operator + (Complex &c2);
voiddisplay( );
private:
double real;
double imag;
};
Complex Complex::operator + (Complex &c2)
{
returnComplex(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;
}
●有一个Time类，包含数据成员minute(分)和sec(秒)，模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值。
class Time
{
public:
Time( ){minute=0;sec=0;}
Time(int m,int s):minute(m),sec(s){}
Time operator++( ); //声明前置自增运算符“++”重载函数
Time operator++(int); //声明后置自增运算符“++”重载函数
private:
int minute;
int sec;
};
TimeTime∷operator++( ) //定义前置自增运算符“++”重载函数
{
if(++sec>=60) {
sec-=60; //满60秒进1分钟
++minute;
}
return *this; //返回当前对象值
}
TimeTime∷operator++(int) //定义后置自增运算符“++”重载函数
{
Time temp(*this);
sec++;
if(sec>=60) {
sec-=60;
++minute;
}
return temp; //返回的是自加前的对象
}
●复数运算
#include<iostream>
usingnamespace 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 ;
};
Complexoperator + ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real + c2.Real ; double i = c1.Image+c2.Image ;
return Complex ( r, i ) ;
}
Complexoperator - ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real - c2.Real ; double i = c1.Image - c2.Image ;
return Complex ( r, i ) ;
}
Complexoperator- ( const Complex & c )
{ return Complex ( -c.Real, - c.Image ) ; }
void Complex:: print() const
{ cout << '(' << Real <<" , " << Image << ')' << endl ; }
●成员函数重载++
#include<iostream>
usingnamespace std;
class Increase
{ public :
Increase ( ) { value=0; }
void display( ) const {cout<<value<<'\n'; } ;
Increase operator ++ ( ) ; // 前置
Increase operator ++ ( int ) ; // 后置
private: unsigned value ;
};
Increase Increase :: operator ++ ( )
{ value ++ ; return *this ; }
Increase Increase :: operator ++ ( int )
{ Increase temp; temp.value = 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( ) ;
}
●友元函数重载++
#include<iostream>
usingnamespace 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( ) ;
}
●定义Name类的重载赋值函数
#include<iostream>
#include<cstring>
usingnamespace 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 ownblock\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 = newchar[ strlen( Obj.pName ) + 1 ] ;
if ( pName != 0 ) strcpy( pName , Obj.pName) ;
size = Obj.size ;
return *this ;
}
●设 x 是类 X 的一个对象，则表达式
x [ y ]
可被解释为
x . operator[ ] ( y )
#include<iostream>
usingnamespace 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 ;
}
●设 x 是类 X 的一个对象，则表达式
x ( arg1, arg2, … )
可被解释为
x . operator () (arg1, arg2, … )
#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;
}
●重载输出运算符“<<”(只能被重载成友元函数，不能重载成成员函数)
定义输出运算符“<<”重载函数的一般格式如下:
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;
}
●#include<iostream>
#include<cstdlib>
usingnamespace std;
class vector
{ public :
vector( int size =1 ) ; ~vector() ;
int & operator[] ( int i ) ;
friend ostream & operator << (ostream & output , vector & ) ;
friend istream & operator >> (istream & input, vector & ) ;
private :
int * v ; int len ;
};
int main(){
int k ; cout << "Input the length of vector A :\n" ; cin >> k ;
vector A( k ) ; cout << "Input the elements ofvector A :\n" ;
cin >> A ; cout << "Output theelements of vector A :\n" ;
cout << A ;
}
vector::vector(int size )
{ if (size<= 0 || size > 100 )
{ cout << "The size of "<< size << " is null !\n" ; exit( 0 ) ; }
v = new int[ size ] ; len = size ;
}
vector ::~vector() { delete[] v ; len = 0 ; }
int &vector :: operator [] ( int i )
{ if( i >=0&& i < len ) return v[ i ] ;
cout << "The subscript "<< i << " is outside !\n" ; exit( 0 ) ;
}
ostream & operator<< ( ostream & output, vector & ary )
{ for(int i =0 ; i < ary.len ; i ++ ) output<< ary[ i ] << " ";
output << endl ;
return output ;
}
istream & operator>> ( istream & input, vector & ary )
{ for( int i =0 ; i < ary.len ; i ++ ) input>> ary[ i ] ;
return input ;
}
●设计一个集合类，用无符号整数数组表示集合，重载运算符实现集合的基本运算，以及集合元素的输入、输出。
#include<iostream>
usingnamespace std;
//集合类
class setType
{ public:
setType( unsigned e=128 ); //构造函数
setType( const setType & B ); //复制构造函数
~setType(); //析构函数
setType operator+= ( unsigned x ); //重载+=，把元素x并入集合
setType operator= ( setType B ); //重载=，集合变量赋值
setType operator() (unsigned x=0); //重载()，集合置元素x，默认置空
setType operator+ ( setType B ); //重载+,求并集
setType operator* ( setType B ); //重载*,求交集
setType operator- ( setType B ); //重载-,求差集
bool operator<= ( setType B ); //重载<=,判集合蕴含
//重载!运算符，判空集。集合空返回false，否则返回true
bool operator ! ();
//重载<，判元素属于集合
friend bool operator< ( unsigned x,setType A );
//重载>>，输入集合元素
friend istream & operator>>( istream &input, setType &A );
//重载<<，输出集合的全部元素
friend ostream & operator<<( ostream &output, setType &A );
private:
unsigned *set; //建立动态数组指针
unsigned n; //数组长度
unsigned e; //全集元素个数
};
//test.cpp
#include"setTypeHead.h"
int main()
{ setType setA, setB, setC; unsigned x;
cout << "Input the elements ofsetA, 1-128, until input 0 :\n";
cin >> setA; //输入setA的元素
cout << "Input the elements ofsetB, 1-128, until input 0 :\n";
cin >> setB; //输入setB的元素
cout << "setA = " <<setA << endl; //输出setA的元素
cout << "setB ="<<setB << endl; //输出setB的元素
cout << "Input x: "; cin >> x;
setA += x; //把元素x并入setA
cout << "Put " << x<< " in setA = " << setA << endl;
setC = setA + setB; //求并集
cout << "setC = setA+setB =" << setC << endl;
setC = setA *setB; //求交集
cout << "setC = setA*setB =" << setC << endl;
setC = setA - setB; //求差集
cout << “setC = setA-setB = ”<< setC << endl;
//判断setA是否蕴含于setB
if( setA <= setB ) cout << "setA <= setB\n";
else cout << "not setA <= setB\n";
cout << "Input x: "; cin >> x;
//判断元素x是否属于setA
if( x < setA ) cout << x << " in "<< setA << "\n";
else cout << x << " not in " << setA <<"\n";
setC = setA + setB + setC; //多个集合变量运算
cout << "setC = setA+setB+setC =" << setC << endl;
setC(); //置setC为空集
cout<<"setC = " <<setC << endl;
}
●pair 模板:
#include <set>
#include<iostream>
usingnamespace std;
main() {
typedef set<double,less<double>> double_set;
const int SIZE = 5;
double a[SIZE] = {2.1,4.2,9.5,2.1,3.7 };
double_set doubleSet(a,a+SIZE);
ostream_iterator<double>output(cout," ");
cout << "1) ";
copy(doubleSet.begin(),doubleSet.end(),output);
cout << endl;
pair<double_set::const_iterator,bool> p;
p = doubleSet.insert(9.5);
if( p.second )
cout << "2) "<< * (p.first) << "inserted" << endl;
else
cout << "2) "<< * (p.first) << " notinserted" << endl;
}
//insert函数返回值是一个pair对象, 其first是被插入元素的迭代器，second代表是否成功插入了
输出：
1) 2.1 3.7 4.29.5
2) 9.5 notinserted
●#include <iostream>
#include<map>
usingnamespace std;
ostream &operator <<( ostream & o,const pair< int,double> & p)
{
o << "(" <<p.first << "," <<p.second << ")";
return o;
}
intmain() {
typedef map<int,double,less<int>> mmid;
mmid pairs;
cout << "1) " <<pairs.count(15) << endl;
pairs.insert(mmid::value_type(15,2.7));
pairs.insert(make_pair(15,99.3));//make_pair生成一个pair对象
cout << "2) " <<pairs.count(15) << endl;
pairs.insert(mmid::value_type(20,9.3));
mmid::iterator i;
cout << "3) ";
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
cout << endl;
cout << "4) ";
int n = pairs[40];//如果没有关键字为40的元素，则插入一个
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
cout << endl;
cout << "5) ";
pairs[15] = 6.28; //把关键字为15的元素值改成6.28
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
}
输出：
1) 0
2) 1
3)(15,2.7),(20,9.3),
4)(15,2.7),(20,9.3),(40,0),
5)(15,6.28),(20,9.3),(40,0),
学习感悟
运算符重载和STL的灵活运用都可以使代码变得更简洁、方便，但是这两块内容较为复杂，不好记忆，需要花费大量的时间去理解掌握，上课听着还能听懂大概的意思，但是当自己实践的时候就会搞得一团糟，还是要多上机练习，单纯靠死记是很难学好的，希望可以尽快理解它的原理，而不是生搬硬套的去运用。运算符重载与STL学习总结
基础知识点
运算符重载可以使用户自定义的数据以一种更简洁的方式工作
●不能重载的算符
. :: .* ?: sizeof
●可以重载的运算符
+ - * / % ^ & | ~
! = < > += -= *= /= %
^= &= |= << >> >>= <<= == !=
<= >= && || ++ -- ->* ‘ ->
[] () new delete new[] delete[]
●重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
Ø 不改变运算符的优先级
Ø 不改变运算符的结合性
Ø 不改变运算符所需要的操作数
Ø 不能创建新的运算符
Ø 运算符函数可以重载为成员函数或友元函数
●一元运算符
Object op 或 op Object
Ø 重载为成员函数，解释为：
Object . operator op()
操作数由对象Object通过this指针隐含传递
Ø重载为友元函数，解释为：
operator op (Object)
操作数由参数表的参数Object提供
●二元运算符
Ø 重载为成员函数，解释为：
ObjectL . operatorop ( ObjectR )
左操作数由ObjectL通过this指针传递，右操作数由参数ObjectR传递
Ø重载为友元函数，解释为：
operator op (ObjectL, ObjectR )
左右操作数都由参数传递
●对双目运算符而言,成员运算符函数的形参表中仅有一个参数,它作为运算符的右操作数,此时当前对象作为运算符的左操作数,它是通过this指针隐含地传递给函数的。
●一般而言,如果在类X中采用成员函数重载双目运算符@,成员运算符函数operator@ 所需的一个操作数由对象aa通过this指针隐含地传递,它的另一个操作数bb在参数表中显示,aa和bb是类X的两个对象,则以下两种函数调用方法是等价的:
aa @ bb; // 隐式调用
aa.operator @(bb); // 显式调用
●对单目运算符而言,成员运算符函数的参数表中没有参数,此时当前对象作为运算符的一个操作数。
● 一般而言,采用成员函数重载单目运算符时,以下两种方法是等价的:
@aa; // 隐式调用
aa.operator@(); // 显式调用
成员运算符函数operator @所需的一个操作数由对象aa通过this指针隐含地传递。因此,在它的参数表中没有参数。
Ø●在第一个参数需要隐式转换的情形下，使用友元函数重载
运算符是正确的选择
Ø 友元函数没有this 指针，所需操作数都必须在参数表显式
声明，很容易实现类型的隐式转换
Ø C++中不能用友元函数重载的运算符有
= （） ［］ －>
●成员运算符函数与友元运算符函数的比较
(1) 成员运算符函数比友元运算符函数少带一个参数（后置的++、--需要增加一个形参）。
(2) 双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。
●数学类中常用的几个运算符重载的特点和应用
设 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)
●重载赋值运算符
Ø 赋值运算符重载用于对象数据的复制
Ø operator= 必须重载为成员函数
Ø重载函数原型为：
类名 & 类名 :: operator= ( 类名 ) ;
●重载运算符[]和()
Ø 运算符 [] 和 () 是二元运算符
Ø [] 和 () 只能用成员函数重载，不能用友元函数重载
●重载下标运算符 []
[] 运算符用于访问数据对象的元素
重载格式 类型 类 ::operator[] ( 类型 ) ；
●重载函数调用符 ()
() 运算符用于函数调用
重载格式 类型 类 :: operator() ( 参数表 ) ；
●重载流插入和流提取运算符
Ø istream和 ostream 是 C++ 的预定义流类
Øcin 是 istream 的对象，cout 是 ostream 的对象
Ø运算符 << 由ostream重载为插入操作，用于输出基本类型数据
Ø运算符 >> 由 istream重载为提取操作，用于输入基本类型数据
Ø用友元函数重载 << 和 >>，输出和输入用户自定义的数据类型
STL概述
n STL是C++标准程序库的核心，深刻影响了标准程序库的整体结构
n STL由一些可适应不同需求的集合类（collection class），以及在这些数据集合上操作的算法（algorithm）构成
n STL内的所有组件都由模板（template）构成，其元素可以是任意类型
n STL是所有C++编译器和所有操作系统平台都支持的一种库
●STL组件
Ø容器（Container） － 管理某类对象的集合
Ø迭代器（Iterator） － 在对象集合上进行遍历
Ø算法（Algorithm） － 处理集合内的元素
Ø容器适配器（container adaptor）
Ø函数对象(functor)
●STL容器类别
Ø序列式容器－排列次序取决于插入时机和位置
Ø关联式容器－排列顺序取决于特定准则
●STL容器的共同能力
Ø所有容器中存放的都是值而非引用。如果希望存放的不是副本，容器元素只能是指针。
Ø所有元素都形成一个次序（order），可以按相同的次序一次或多次遍历每个元素
●STL容器元素的条件
Ø必须能够通过拷贝构造函数进行复制
Ø必须可以通过赋值运算符完成赋值操作
Ø必须可以通过析构函数完称销毁动作
Ø序列式容器元素的默认构造函数必须可用
Ø某些动作必须定义operator ==，例如搜寻操作
Ø关联式容器必须定义出排序准则，默认情况是重载operator <
对于基本数据类型（int,long,char,double,…）而言，以上条件总是满足
●STL容器的共同操作
Ø与大小相关的操作（size operator）
Fsize()－返回当前容器的元素数量
Fempty()－判断容器是否为空
Fmax_size()－返回容器能容纳的最大元素数量
Ø比较（comparison）
F==,!=,<,<=,>,>=
F比较操作两端的容器必须属于同一类型
F如果两个容器内的所有元素按序相等，那么这两个容器相等
F采用字典式顺序判断某个容器是否小于另一个容器
Ø赋值（assignment）和交换（swap）
Fswap用于提高赋值操作效率
Ø与迭代器（iterator）相关的操作
Fbegin()－返回一个迭代器，指向第一个元素
Fend()－返回一个迭代器，指向最后一个元素之后
Frbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素
Frend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
Ø 元素操作
Finsert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置
Ferase(beg,end)－移除[beg，end]区间内的所有元素
Fclear()－移除所有元素
●迭代器（iterator）（示例:iterator）
Ø可遍历STL容器内全部或部分元素的对象
Ø指出容器中的一个特定位置
Ø迭代器的基本操作
操作 | 效果 |
* | 返回当前位置上的元素值。如果该元素有成员，可以通过迭代器以operator ->取用 |
++ | 将迭代器前进至下一元素 |
==和!= | 判断两个迭代器是否指向同一位置 |
= | 为迭代器赋值（将所指元素的位置赋值过去） |
●vector
Øvector模拟动态数组
Øvector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
Ø必须包含的头文件#include <vector>
Øvector支持随机存取
Øvector的大小（size）和容量（capacity）
Fsize返回实际元素个数，
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) | 扩大容量为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() | 销毁所有元素并释放内存。 |
Ø非变动性操作
操作 | 效果 |
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) | 同上，全局函数 |
Ø特殊搜寻操作
操作 | 效果 |
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相同的元素
Øset/multset
操作 | 效果 |
返回指向第一个元素的迭代器 | |
清除所有元素 | |
返回某个值元素的个数 | |
如果集合为空，返回true | |
返回指向最后一个元素的迭代器 | |
返回集合中与给定值相等的上下限的两个迭代器 | |
删除集合中的元素 | |
返回一个指向被查找到元素的迭代器 | |
返回集合的分配器 | |
操作 | 效果 SET实例 multiset实例 |
在集合中插入元素 | |
返回指向大于（或等于）某值的第一个元素的迭代器 | |
返回一个用于元素间值比较的函数 | |
返回集合能容纳的元素的最大限值 | |
返回指向集合中最后一个元素的反向迭代器 | |
返回指向集合中第一个元素的反向迭代器 | |
集合中元素的数目 | |
交换两个集合变量 | |
返回大于某个值元素的迭代器 | |
返回一个用于比较元素间的值的函数 |
例子
●成员运算符函数的原型在类的内部声明格式如下:
class X
{
//…
返回类型 operator运算符(形参表);
//…
}
●在类外定义成员运算符函数的格式如下:
返回类型 X::operator运算符(形参表)
{
函数体
}
●双目运算符重载为成员函数
#include <iostream.h>
class Complex
{
public:
Complex() {real=0,imag=0;}
Complex(doubler,double i) {real=r; imag=i;}
Complex operator + (Complex &c2);
voiddisplay( );
private:
double real;
double imag;
};
Complex Complex::operator + (Complex &c2)
{
returnComplex(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;
}
●有一个Time类，包含数据成员minute(分)和sec(秒)，模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值。
class Time
{
public:
Time( ){minute=0;sec=0;}
Time(int m,int s):minute(m),sec(s){}
Time operator++( ); //声明前置自增运算符“++”重载函数
Time operator++(int); //声明后置自增运算符“++”重载函数
private:
int minute;
int sec;
};
TimeTime∷operator++( ) //定义前置自增运算符“++”重载函数
{
if(++sec>=60) {
sec-=60; //满60秒进1分钟
++minute;
}
return *this; //返回当前对象值
}
TimeTime∷operator++(int) //定义后置自增运算符“++”重载函数
{
Time temp(*this);
sec++;
if(sec>=60) {
sec-=60;
++minute;
}
return temp; //返回的是自加前的对象
}
●复数运算
#include<iostream>
usingnamespace 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 ;
};
Complexoperator + ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real + c2.Real ; double i = c1.Image+c2.Image ;
return Complex ( r, i ) ;
}
Complexoperator - ( const Complex & c1, const Complex & c2 )
{ double r = c1.Real - c2.Real ; double i = c1.Image - c2.Image ;
return Complex ( r, i ) ;
}
Complexoperator- ( const Complex & c )
{ return Complex ( -c.Real, - c.Image ) ; }
void Complex:: print() const
{ cout << '(' << Real <<" , " << Image << ')' << endl ; }
●成员函数重载++
#include<iostream>
usingnamespace std;
class Increase
{ public :
Increase ( ) { value=0; }
void display( ) const {cout<<value<<'\n'; } ;
Increase operator ++ ( ) ; // 前置
Increase operator ++ ( int ) ; // 后置
private: unsigned value ;
};
Increase Increase :: operator ++ ( )
{ value ++ ; return *this ; }
Increase Increase :: operator ++ ( int )
{ Increase temp; temp.value = 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( ) ;
}
●友元函数重载++
#include<iostream>
usingnamespace 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( ) ;
}
●定义Name类的重载赋值函数
#include<iostream>
#include<cstring>
usingnamespace 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 ownblock\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 = newchar[ strlen( Obj.pName ) + 1 ] ;
if ( pName != 0 ) strcpy( pName , Obj.pName) ;
size = Obj.size ;
return *this ;
}
●设 x 是类 X 的一个对象，则表达式
x [ y ]
可被解释为
x . operator[ ] ( y )
#include<iostream>
usingnamespace 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 ;
}
●设 x 是类 X 的一个对象，则表达式
x ( arg1, arg2, … )
可被解释为
x . operator () (arg1, arg2, … )
#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;
}
●重载输出运算符“<<”(只能被重载成友元函数，不能重载成成员函数)
定义输出运算符“<<”重载函数的一般格式如下:
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;
}
●#include<iostream>
#include<cstdlib>
usingnamespace std;
class vector
{ public :
vector( int size =1 ) ; ~vector() ;
int & operator[] ( int i ) ;
friend ostream & operator << (ostream & output , vector & ) ;
friend istream & operator >> (istream & input, vector & ) ;
private :
int * v ; int len ;
};
int main(){
int k ; cout << "Input the length of vector A :\n" ; cin >> k ;
vector A( k ) ; cout << "Input the elements ofvector A :\n" ;
cin >> A ; cout << "Output theelements of vector A :\n" ;
cout << A ;
}
vector::vector(int size )
{ if (size<= 0 || size > 100 )
{ cout << "The size of "<< size << " is null !\n" ; exit( 0 ) ; }
v = new int[ size ] ; len = size ;
}
vector ::~vector() { delete[] v ; len = 0 ; }
int &vector :: operator [] ( int i )
{ if( i >=0&& i < len ) return v[ i ] ;
cout << "The subscript "<< i << " is outside !\n" ; exit( 0 ) ;
}
ostream & operator<< ( ostream & output, vector & ary )
{ for(int i =0 ; i < ary.len ; i ++ ) output<< ary[ i ] << " ";
output << endl ;
return output ;
}
istream & operator>> ( istream & input, vector & ary )
{ for( int i =0 ; i < ary.len ; i ++ ) input>> ary[ i ] ;
return input ;
}
●设计一个集合类，用无符号整数数组表示集合，重载运算符实现集合的基本运算，以及集合元素的输入、输出。
#include<iostream>
usingnamespace std;
//集合类
class setType
{ public:
setType( unsigned e=128 ); //构造函数
setType( const setType & B ); //复制构造函数
~setType(); //析构函数
setType operator+= ( unsigned x ); //重载+=，把元素x并入集合
setType operator= ( setType B ); //重载=，集合变量赋值
setType operator() (unsigned x=0); //重载()，集合置元素x，默认置空
setType operator+ ( setType B ); //重载+,求并集
setType operator* ( setType B ); //重载*,求交集
setType operator- ( setType B ); //重载-,求差集
bool operator<= ( setType B ); //重载<=,判集合蕴含
//重载!运算符，判空集。集合空返回false，否则返回true
bool operator ! ();
//重载<，判元素属于集合
friend bool operator< ( unsigned x,setType A );
//重载>>，输入集合元素
friend istream & operator>>( istream &input, setType &A );
//重载<<，输出集合的全部元素
friend ostream & operator<<( ostream &output, setType &A );
private:
unsigned *set; //建立动态数组指针
unsigned n; //数组长度
unsigned e; //全集元素个数
};
//test.cpp
#include"setTypeHead.h"
int main()
{ setType setA, setB, setC; unsigned x;
cout << "Input the elements ofsetA, 1-128, until input 0 :\n";
cin >> setA; //输入setA的元素
cout << "Input the elements ofsetB, 1-128, until input 0 :\n";
cin >> setB; //输入setB的元素
cout << "setA = " <<setA << endl; //输出setA的元素
cout << "setB ="<<setB << endl; //输出setB的元素
cout << "Input x: "; cin >> x;
setA += x; //把元素x并入setA
cout << "Put " << x<< " in setA = " << setA << endl;
setC = setA + setB; //求并集
cout << "setC = setA+setB =" << setC << endl;
setC = setA *setB; //求交集
cout << "setC = setA*setB =" << setC << endl;
setC = setA - setB; //求差集
cout << “setC = setA-setB = ”<< setC << endl;
//判断setA是否蕴含于setB
if( setA <= setB ) cout << "setA <= setB\n";
else cout << "not setA <= setB\n";
cout << "Input x: "; cin >> x;
//判断元素x是否属于setA
if( x < setA ) cout << x << " in "<< setA << "\n";
else cout << x << " not in " << setA <<"\n";
setC = setA + setB + setC; //多个集合变量运算
cout << "setC = setA+setB+setC =" << setC << endl;
setC(); //置setC为空集
cout<<"setC = " <<setC << endl;
}
●pair 模板:
#include <set>
#include<iostream>
usingnamespace std;
main() {
typedef set<double,less<double>> double_set;
const int SIZE = 5;
double a[SIZE] = {2.1,4.2,9.5,2.1,3.7 };
double_set doubleSet(a,a+SIZE);
ostream_iterator<double>output(cout," ");
cout << "1) ";
copy(doubleSet.begin(),doubleSet.end(),output);
cout << endl;
pair<double_set::const_iterator,bool> p;
p = doubleSet.insert(9.5);
if( p.second )
cout << "2) "<< * (p.first) << "inserted" << endl;
else
cout << "2) "<< * (p.first) << " notinserted" << endl;
}
//insert函数返回值是一个pair对象, 其first是被插入元素的迭代器，second代表是否成功插入了
输出：
1) 2.1 3.7 4.29.5
2) 9.5 notinserted
●#include <iostream>
#include<map>
usingnamespace std;
ostream &operator <<( ostream & o,const pair< int,double> & p)
{
o << "(" <<p.first << "," <<p.second << ")";
return o;
}
intmain() {
typedef map<int,double,less<int>> mmid;
mmid pairs;
cout << "1) " <<pairs.count(15) << endl;
pairs.insert(mmid::value_type(15,2.7));
pairs.insert(make_pair(15,99.3));//make_pair生成一个pair对象
cout << "2) " <<pairs.count(15) << endl;
pairs.insert(mmid::value_type(20,9.3));
mmid::iterator i;
cout << "3) ";
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
cout << endl;
cout << "4) ";
int n = pairs[40];//如果没有关键字为40的元素，则插入一个
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
cout << endl;
cout << "5) ";
pairs[15] = 6.28; //把关键字为15的元素值改成6.28
for( i = pairs.begin(); i != pairs.end();i++ )
cout << * i << ",";
}
输出：
1) 0
2) 1
3)(15,2.7),(20,9.3),
4)(15,2.7),(20,9.3),(40,0),
5)(15,6.28),(20,9.3),(40,0),
学习感悟
运算符重载和STL的灵活运用都可以使代码变得更简洁、方便，但是这两块内容较为复杂，不好记忆，需要花费大量的时间去理解掌握，上课听着还能听懂大概的意思，但是当自己实践的时候就会搞得一团糟，还是要多上机练习，单纯靠死记是很难学好的，希望可以尽快理解它的原理，而不是生搬硬套的去运用。
扫一扫
142
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
