STL运算符重载

标准模板库
STL组件
容器 － 管理某类对象的集合
迭代器 － 在对象集合上进行遍历
算法 － 处理集合内的元素


STL容器类别
序列式容器－排列次序取决于插入时机和位置
关联式容器－排列顺序取决于特定准则


STL容器的共同能力
所有容器中存放的都是值而非引用。如果希望存放的不是副本，容器元素只能是指针。
所有元素都形成一个次序，可以按相同的次序一次或多次遍历每个元素


STL容器的共同操作
产生一个空容器，以另一个容器元素为初值完成初始化，以数组元素为初值完成初始化，返回当前容器的元素数量，判断容器是否为空，返回容器能容纳的最大元素数量，比较操作两端的容器必须属于同一类型，如果两个容器内的所有元素按序相等，那么这两个容器相等，采用字典式顺序判断某个容器是否小于另一个容器，赋值和交换，
begin()－返回一个迭代器，指向第一个元素
end()－返回一个迭代器，指向最后一个元素之后
rbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素
rend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后
insert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)－移除[beg，end]区间内的所有元素
clear()－移除所有元素


所有容器都提供两种迭代器
container::iterator以“读/写”模式遍历元素
container::const_iterator以“只读”模式遍历元素


迭代器分类
双向迭代器，随机存取迭代器


vector的元素可以是任意类型T，但必须具备赋值和拷贝能力
必须包含的头文件#include
支持随机存取
size返回实际元素个数，
capacity返回vector能容纳的元素最大数量。如果插入元素时，元素个数超过capacity，需要重新配置内部存储器。
vector c产生空的vector，vecto)r c1(c2产生同类型的c1，并将复制c2的所有元素，vector c(n)，利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector，vector c(n,e)产生一个大小为n的vector，每个元素都是e，vector c(beg,end)产生一个vector，以区间[beg,end]为元素初值，~vector()销毁所有元素并释放内存。


c.size()返回元素个数，c.empty()判断容器是否为空，c.max_size()返回元素最大可能数量（固定值），c.capacity()返回重新分配空间前可容纳的最大元素数量，c.reserve(n)扩大容量为n，c1==c2判断c1是否等于c2，c1!=c2判断c1是否不等于c2，c1at(idx)返回索引idx所标识的元素的引用，进行越界检查，operator [](idx)返回索引idx所标识的元素的引用，不进行越界检查，front()返回第一个元素的引用，不检查元素是否存在，back()返回最后一个元素的引用，不检查元素是否存在
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的副本
map c1(c2)产生同类型的c1，并复制c2的所有元素，map c(op)以op为排序准则产生一个空的map，map c(beg,end,op)以op为排序准则，以区间[beg,end]内的元素产生一个map
count(key)返回”键值等于key”的元素个数，lower_bound(key)返回”键值大于等于key”的第一个元素
，upper_bound(key)返回”键值大于key”的第一个元素
c.insert(pos,e)在pos位置为起点插入e的副本，并返回新元素位置（插入速度取决于pos），c.insert(beg,end)将区间[beg,end]内所有元素的副本插入到c中
c.erase(pos)删除迭代器pos所指位置的元素，无返回值，c.erase(beg,end)删除区间[beg,end]内所有元素，无返回值


泛型算法通则
所有算法的前两个参数都是一对iterators：[first，last)，用来指出容器内一个范围内的元素。

每个算法的声明中，都表现出它所需要的最低层次的iterator类型。大部分算法都可以用functioin object 来更改准则。function object又称functor

#include
#include
#include
using namespace std;
const int maxn = 10000 + 5;
char a[maxn];
int main(){
int T;
scanf("%d",&T);
while(T--)
{
scanf("%s",a);
int len = strlen(a);
stacks;
for(int i = 0; i < len; i++)
{
if(a[i] == ']'&&s.size()&&s.top()=='['){
s.pop(); 
}else if(a[i] == ')'&&s.size()&&s.top()=='('){
s.pop();
}else{
s.push(a[i]);
}
}
if(s.size())
{
printf("No\n"); 
}else{
printf("Yes\n");
}
}
return 0;
}        

运算符重载
重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
不改变运算符的优先级
不改变运算符的结合性
不改变运算符所需要的操作数 
不能创建新的运算符
以重载为成员函数或友元函数


一元运算符
Object  op    或    op  Object
重载为成员函数，解释为：
Object . operator op ()
重载为友元函数，解释为：
operator op (Object)
二元运算符
重载为成员函数，解释为：
ObjectL . operator op ( ObjectR )
重载为友元函数，解释为：
operator op ( ObjectL, ObjectR )


单目运算符成员运算符函数的参数表中没有参数
双目运算符成员运算符函数的形参表中仅有一个参数,它作为运算符的右操作数


在第一个参数需要隐式转换的情形下，使用友元函数重载
运算符是正确的选择
友元函数没有 this 指针，所需操作数都必须在参数表显式
容易实现类型的隐式转换
C++中不能用友元函数重载的运算符
成员运算符函数比友元运算符函数少带一个参数（后置的++、--需要增加一个形参）。
双目运算符一般可以被重载为友元运算符函数或成员运算符函数,但当操作数类型不相同时,必须使用友元函数。 
赋值运算符重载用于对象数据的复制 
operator= 必须重载为成员函数 


istream 和 ostream 是 C++ 的预定义流类
cin 是 istream 的对象，cout 是 ostream 的对象
运算符 << 由ostream 重载为插入操作，用于输出基本类型数据
运算符 >> 由 istream 重载为提取操作，用于输入基本类型数据

用友元函数重载 << 和 >> ，输出和输入用户自定义的数据类型

#include
using namespace std;
class Point
{ int x,y;
public:
Point(int x=0, int y=0)
{ this->x = x;
this->y = y;
cout<<"call the default constructor!"<
}
Point & operator++()
{ x++;y++;
cout<<"call the Pre_Selfpuls!"<
return * this;
}
Point operator++(int)
{ Point temp;
temp = * this;
++(this->x);
++(this->y);
cout<<"call the Post_Selfplus!"<
return temp;
}
friend ostream & operator<<(ostream &os,Point&p)
{ os<<"Point P2"<<":"<
return os;
}
~Point(){cout<<"call the destructor!<
};
void main()
{ Point P1(10,20);
cout<
cout<<++P1<
}
要熟练掌握如此众多的函数与方法，也属不易。并且函数命名的方法与种类繁琐众多，笔记记载量可以体现出本章的记忆量之多和脑回路需要不断练习才可以较为熟悉这章的函数运用。