一、心得总结
运算符重载使得用户自定义的数据以一种更简洁的方式工作。例如在做ATM模拟系统时，使用重载“<”来比较时间，可以简化程序，减少代码。另外，我们也可以重载运算符函数，将运算符用于操作自定义的数据类型。重载运算符函数可以对运算符做出新的解释，即定义用户所需要的各种操作。但运算符重载后，原有的基本语义不变，包括：不改变运算符的优先级，不改变运算符的结合性，不改变运算符所需要的操作数，不能创建新的运算符。优先级和结合性主要体现在重载运算符的使用上，而操作数的个数不但体现在重载运算符的使用上，更关系到函数定义时的参数设定。例如，一元运算符重载函数不能有两个参数，调用时也不能作用于两个对象。不能创建新的运算符，只有系统预定义的运算符才能被重载。
STL是C++标准程序库的核心，深刻影响了标准程序库的整体结构。
C++语言中大部分预定义的运算符都可以被重载。下列是可以重载的运算符：
+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> <<= == != <= >= && || ++ -- ->* ' -> [] () new delete
一下运算符不能被重载：
. .* :: ?; sizepf
二、内容总结及实例分析
&1运算符重载
1.1重载运算符的语法形式
运算符函数是一种特殊的成员函数或友元函数。成员函数的语句格式为：
类型 类名：：operator op(参数表)
{
// 相对于该类定义的操作
}
其中，“类型”是函数的返回类型。“类名”是要重载该运算符的类。“op”表示要重载的运算符。函数名是"operator op"，由关键字operator和被重载的运算符op组成。“参数表”列出该运算符所需要的操作数。
1.2用成员或友元函数重载运算符
1.一元运算符
一元运算符不论前置或后置，都要求有一个操作数：
Object op 或 op Object
当重载为成员函数时，编译器解释为：
Object.operator op()
函数operator op所需的操作数由对象Object通过this指针隐含传递，所以参数表为空。
当重载为友元函数时，编译器解释为：
operator op(Object)
函数operator op所需的操作数由参数表的参数Object提供。
2.二元运算符
任何二元运算符都要求有左、右操作数：
当重载为成员函数时，编译器解释为：
Object.operator op(ObjectR)
左操作数由对象OpbjectL通过this指针传递，右操作数由参数ObjectR传递。
重载为友元函数时，编译器解释为：
operator op(Object.ObjectR)
左、右操作数都由参数传递。
不管是成员函数还是友元函数重载，运算符的使用方法都相同。但由于它们传递参数的方法不同，因此导致实现的代码不同，应用场合不同。
1.2.1用成员函数重载运算符
当一元运算符的操作数，或者二元运算符的左操作数是该类的一个对象是，重载运算符函数一般定义为成员函数。
成员运算符函数的原型在类的内部声明格式如下：
class X
{
//...
返回类型operaor运算符（形参表）；
//...
}
再类外定义成员运算符函数的格式如下：
返回类型X::operator运算符（形参表）
{
函数体
}
1.2.2.双目运算符重载为成员函数
对双目运算符而言，成员运算符函数的形参表中仅有一个参数，它作为运算符的右操作数，此时当前对象作为运算符的左操作数，它是通过this指针隐含地传递给函数的。
例：
#include<bits/stdc++.h>
class complex{
public:
complex(){real=0,imag=0;}
private:
double real;
double imag;
};
complex(double r,double i){real=r;imap=i;}
complex operator +(complex &c2);
void display();
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.diaplay();
return 0;
}
一般而言，如果在类X中采用成员函数重载双目运算符@，成员运算符函数operator@所需的一个操作数由对象aa通过this指针隐含地传递，它的另一个操作数bb在参数表中显示，aa和bb是类X的两个对象，则以下两种函数调用方法是等价的：
aa@bb;//隐式调用
aa.operator@(bb);//显式调用
1.2.3单目运算符重载为成员函数
对单目运算符而言，成员函数运算符函数的参数表中没有参数，此时当前对象作为运算符的一个操作数。
有一个Time类，包含数据成员minute（分）和（秒），模拟秒表，每次走一秒，满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;
};
Time Time::operator++()
{
if(++sec>=60)
{
sec-=60; //满60进1分钟
++minute;
}
return *this; //返回当前对象值
Time Time::operator++(int) //定义后置自增运算符“++"重载函数
{
Time temp(*this)
sec++;
if(sec>=60)
{
sec-=60;
++minute;
}
return temp; //返回的是自加前的对象
}
}
1.2.4.用友元函数重载运算符
友元函数重载运算符常用于运算符的左右操作数类型不同的情况
<1>.在第一个参数需要隐式转换的情形下，使用友元函数重载
<2>.友元函数没有this指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换
<3>.C++中不能用友元函数重载的运算符有= () [] ->
成员函数运算符函数与友元运算符函数的比较
（1）成员运算符函数比友元运算符函数少带一个参数（后置的++、--需要增加一个形参）。
（2）双目运算符一般可以被重载为友元运算符函数或成员运算符函数，但当操作数类型不相同时，必须使用友元函数。
1.3几个典型运算符重载
1.3.1.重载++与--
自增个自减运算符有前置和后置两张形式。C++规定，前置形式重载为一元运算符函数，后置形式重载为二元运算符函数。
例如，设有类A的对象Aobject，其前置自增表达式和后置自增表达式说明如下。
（1）前置自增表达式
++Aobject
若用成员函数重载，则编译器解释为：
Aobject.operator++（）
对应的函数原型为：
A&A::operator++();
若用友元函数重载，则编译器解释为：
operator++(Aobject)
对应的函数原型为：
friend A&operator++(A&)
（2）后置自增表达式
Aobject++
成员函数重载的解释为：
Aobject.operator++（0）
对应的函数原型为：
friend A&operator++(A &,int);
在此，参数0是一个伪值，用于与前置形式重载相区别。另外，友元重载函数返回类类型的引用是为了减少函数返回时对象复制的开销，可以根据需要选择是否返回类类型的引用是为了减少函数返回时对象复制的开销，可以根据需要选择是否返回类类型的引用。
#include<iostream>
using namespace 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();
}
1.3.2.重载赋值运算符
赋值运算符重载用于对象数据的复制，只能用成员函数重载。重载函数原型为：
类名 & 类名：：operator=(类名)；
#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; // 调用重载赋值运算符函数
}
注意，重载赋值运算符函数和复制构造函数的实现十分相似。不同的是，重载函数返回*this，以符合语言版本的原有赋值语义。
赋值构造函数和重载赋值运算符函数虽然都是实现数据成员的复制，但执行时机不同。前者用于对象的初始化，后者用于程序运行时修改对象的数据。
C++提供系统版本的重载赋值运算，实现数据成员的简单复制。这一点和浅复制的操作一样。所以，对于用指针管理堆的数据成员，以及大多数重要的类，系统的赋值运算符操作往往不够，需要程序员自己进行重载。
运算符函数operator=必须重载为成员函数，而且不能被继承。
1.3.3.重载运算符[]和()
运算符[]和()是二元函数，[]和()只能用成员函数重载，不能用友元函数重载。
1.重载下标运算符[]
下标运算符[]是二元运算符，用于访问数据对象的元素。其重载函数调用的一般形式为：
对象[运算符]
例如，类X有重载函数：
int & X::operator[](int);
其中，x是X类的对象，则调用函数的表达式；
x[k],被解释为：x.operator[](k)
#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;
}
2.重载函数调用运算符
函数调用运算符（）可以看成一个二元运算符。其重载函数调用的一般形式：
对象（表达式表）
其中，“表达式表”可以为空。例如，类A有重载函数：
int A::operator；
若a是A类对象，则调用函数的表达式：
a(x,y)被解释为：a.operator()(x,y)
例，设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;
}
1.3.4.重载流插入和流提取运算符
istream和ostream是C++的预定义流类，cin是istream的对象，cout是ostream的对象，运算符<<由osream重载为插入操作，用于输出基本类型数据，运算符>>由istream重载为提取操作，用于输入基本类型数据，用友元函数重载<<和>>，输出和输入用户自定义的数据类型
重载输出运算符“<<”（只能被重载成友元函数），不能重载成成员函数
定义输出运算符“>>”重载解释的一般格式如下：
istream&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;
}
&2标准模板库（STL）
2.1STL概述
STL由一些可适应不同需求的集合类，以及在这些数据集合上操作的算法构成
STL内的所有组件都由模版构成，其元素可以是任意类型
STL是所有C++编译器和所有操作系统平台都支持的一种库
STL组件
1.容器（container）——管理某类对象的集合
2.迭代器（Lierator）——在对象集合上进行遍历
3.算法（Algorithm）——处理集合内的元素
4.容器适配器（Container adaptor）
5.函数对象（functor）
STL容器类别
1.序列式容器——排列次序取决于插入时机和位置
2.关联式容器——排列顺序取决于特定准则
STL容器的共同能力
1.所有容器中存放的都有值而非引用。如果希望存放的不是副本，容器元素只能是指针。
2.所有元素都形成一个次序（order），可以按相同的次序一次或多次遍历每个元素
STL容器元素的条件
1.必须能够通过拷贝构造函数进行复制
2.必须可以通过赋值运算符完成赋值操作
3.必须可以通过析构函数完成销毁动作
4.序列式容器元素的默认构造函数必须可用
5.某些动作必须定义operator==，例如搜寻操作
6.关联式容器必须定义出排序准则，默认情况是重载operator<
对于基本数据类型（int ,long,char,double...）而言，以上条件总是满足。
STL容器的共同操作
1.初始化
1.产生一个空容器
std::list<int>l;
2.以另一个容器元素为初值完成初始化
std::list<int>l;
...
std::vector<float>c(l.begin(),l.end());
3.以数组元素为初值完成初始化
int array[]-{2,4,6,1345};
...
srd::set<int>c(array,array+sizeo(array)/sizeo(array[0]);
2.与大小相关的操作（size operator）
size()——返回当前容器的元素数量
empty()——判断容器是否为空
max_size()——返回容器能容纳的最大元素数量
3.比较
==，!=,<,<=,>,>=
比较操作两端的容器必须属于同一类型
如果两个容器内的所有元素按序相等，那么这两个容器相等
采用字典式顺序判断某个容器是否小于另一个容器
4.赋值和交换
swap用于提高赋值操作效果
5.与迭代器相关的操作
begin（）——返回一个迭代器，指向第一个元素
end（）——返回一个迭代器，指向最后一个之后
rbegin（）——返回一个逆向迭代器，指向逆向遍历的第一个元素
rend（）——返回一个逆向迭代器，指向遍历的最后一个元素之后
容器的共同操作
1.元素操作
insert（pos，e）——将元素e的拷贝安插与迭代器pos所指的位置
erase（beg，end）——移除[beg，end]区间内的所有元素
clear（）——移除所有元素
2.迭代器
1.可遍历STL容器内全部或部分元素的对象
2.指出容器中的一个特定位置
3.迭代器的基本操作
操作 效果
* 返回当前位置上的元素值。如果该元素有成员，可以通过迭代器以operator->取用
++ 将迭代器前进至下一元素
==和！= 判断两个迭代器是否指向同一位置
= 为迭代器赋值（将所指元素的位置赋值过去）
4.所有容器都提供两种迭代器
操作 效果
begin() 返回一个迭代器，指向第一个元素
end() 返回一个迭代器，指向最后一个元素之后
5.所有容器都提供两种迭代器
container：：iterator以“读、写”模式遍历元素
container：：const_iterator以“只读”模式遍历元素
2.2.STL容器
1. vector
1.vecror模拟动态数组
2.vector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）
3. 必须包含的头文件#include<vector>
4.vector的大小（size）和容量（capacity）
size返回实际元素个数
capacity返回能容纳的元素最大数量。如果插入元素时，元素个数超过capacity需要从新配置内部储存器。
5.构造、拷贝和析构
操作 效果
vector<T>c 产生空的vector
vector<T>c1(c2) 产生同类型的c1，病将复制c2的所有元素
vectorc<T>(n) 利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector
vectorc<T>(n,e) 产生一个大小为n的vector，每个元素都是e
vector<T>(beg,end) 产生一个vector，以区间[beg,end]为元素初值
vector<T>() 产生所有元素并释放内存
6.非变动操作
操作 效果
c.size() 返回元素个数
c.empty() 判断容器是否为空
c.max_size() 返回元素最大可能数量（固定值）
c.capacity() 返回重新分配空间前可容纳的最大元素数量
c.reserve() 扩大容量为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
7.赋值操作
操作 效果
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) 同上，全局函数
8.元素存取
操作 效果
at(idx) 返回索引idx所标识的元素的引用，进行越界检查
operator[](idx) 返回索引idx所标识的元素的引用，不进行越界检查
front() 返回第一个元素的引用，不检查元素是否存在
back() 返回最后一个元素的引用，不检查是否存在
9.迭代器相关函数
操作 效果
begin() 返回一个迭代器，指向第一个元素
end() 返回一个迭代器，指向最后一个元素
rbegin() 返回一个迭代器，指向逆向遍历的第一个元素
rend() 返回一个迭代器，指向逆向遍历的最后一个元素
10.安插元素
操作 效果
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的副本
11.移除元素
操作 效果
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的副本）
2.map/multimap
1.使用平衡二叉树管理元素
2.元素包含两部分（key,value）,key和value可以是任意类型
3.必须包含的头文件#include<map>
4.根据元素的key自动对元素排序，因此根据元素的key进行定位很快，但根据元素的value定位很慢
5.不能直接改变元素的key，可以通过operator[]直接存取元素值
6.map中不允许key相同的元素，multimap运行key相同的元素
7.构造、拷贝和析构
操作 效果
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() 销毁所有元素并释放内存
8.非变动性操作
操作 效果
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
9.复制
操作 效果
c1=c2 将c2的全部元素赋值给c1
c1.swap(c2) 将c1和c2的元素互换
swap(c1,c2) 同上，全局函数
10.特殊搜寻操作
操作 效果
count(key) 返回“键值等于key”的元素个数
find(key) 返回“键值等于key”的第一个元素，找不到返回end
lower_bound(key) 返回“键值大于等于key”的第一个元素
upper_bound(key) 返回“键值大于key”的第一个元素
equal_range(key) 返回”键值等于key”的元素区间
11.迭代器相关函数
操作 效果
begin() 返回一个双向迭代器，指向最后一个元素之后
end() 返回一个双向迭代器，指向最后一个元素之后
rbegin() 返回一个逆向迭代器，指向逆向遍历的第一个元素
rend() 返回一个逆向迭代器，指向逆向遍历的最后一个元素
12.安插元素
操作 效果
c.insert(pos,e) 在pos位置起点插入e的副本，并返回新元素位置
c.insert(e) 插入e的副本，并返回新元素位置
c.c.insert(beg,end) 将区间[beg,end]内所有元素的副本插入到c中
13.移除元素
操作 效果
c.erase(pos) 删除迭代器pos所指位置元素，无返回值
c.erase(val) 移除所有值为val的元素，返回移除元素个数
c.erase(beg,end) 删除区间[beg,end]内所有元素，无返回值
c.clear(） 移除所有元素，清空容器
3.set/multiset
1.使用平衡二叉树管理元素
2.集合石一种包含已排序对象的关联容器
3.必须包括的头文件#include<set>
4.map容器石键值对的集合，好比以人名为键的地址和电话号码。相反地，set容器只是单纯的键的集合。当我们想知道某位用户是否存在使，使用set使容器是最合适的
5.set中不允许key相同的意思，multiset允许key相同的元素
6.
操作 效果
返回指向第一个元素的迭代器 | |
清除所有元素 | |
返回某个值元素的个数 | |
如果集合为空，返回true | |
返回指向最后一个元素的迭代器 | |
返回集合中与给定值相等的上下限的两个迭代器 | |
删除集合中的元素 | |
返回一个指向被查找到元素的迭代器 | |
返回集合的分配器 |
在集合中插入元素 | |
返回指向大于（或等于）某值的第一个元素的迭代器 | |
返回一个用于元素间值比较的函数 | |
返回集合能容纳的元素的最大限值 | |
返回指向集合中最后一个元素的反向迭代器 | |
返回指向集合中第一个元素的反向迭代器 | |
集合中元素的数目 | |
交换两个集合变量 | |
返回大于某个值元素的迭代器 | |
返回一个用于比较元素间的值的函数 |
273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
