C++学习笔记

语法：

   template  void myswap(T &a,T &b){}

 使用方式：
 1.自动类型推导 `myswap(1,2);`  不会发生隐式类型转换  或：
 2.显示指定类型 'myswap（1,2）;` 可以进行隐式类型转换（和普通函数一样）
 模板必须要确定T的数据类型才可以使用
 ps：隐式类型转换举例：int和其他类型数据运算，其他类型隐式转换为int

 模板和普通函数的调用规则：

1.普通函数和模板都可调用时，优先普通函数

2.可使用空参数列表模板强制调用模板`myswap<>（1，2）；`

3.模板也可以重载

4.如果模板更好的匹配，优先模板 模板具有局限性，可以用函数模板重载方法，将模板参数具体化，会优先调用参数具体化的模板 

template <> bool mycompare（person &p1，person &p2）{}；

类模板：

template   class person{ 
person(nametype name,agetype age){} 
}  
person p("yxh",2);

 1.类模板没有自动类型推导  

2.类模板参数列表可以有默认参数

  template 

 普通类的成员函数一开始就可以被创建（定义时） 类模板的成员函数只有在调用时才会被创建

类模板作函数参数三种方式：

1.指定参数类型

void printperson( person{} ) 

2.参数模板化

template  void printperson(person){}   
//查看某个类型的名字：`typeid（nametype）.name（）`  

3.整个参数模板化

template  void printperson(T &p){}

类模板与继承：

如果父类是类模板，子类需要指定父类的T的类型，或者，子类也成为一个类模板

类模板成员函数类外实现：

template 
person::person(nametype name,agetype age){}

类模板分文件编写：

由于类模板的成员函数是在调用时才创建，只包含头文件h而不包含源文件cpp时，不 可行，解决办法：1.直接包含cpp文件，2.将h和cpp内容写到一起，命名为hpp文件，包含hpp文件

stl广义上分为：容器（序列式容器、关联式容器）、算法（质变算法、非质变算法）、迭代器  //（还有仿函数、适配器、空间配置器）

容器和算法通过迭代器链接，每个容器都有自己的迭代器，算法通过迭代器访问容器中的数据

string字符串拼接：

string& operator+=(const char* str); 
string& operator+=(const char ch); 
string& operator+=(const string& str);  
string& append(const char* str); 
string& append(const char* str,int n); 
string& append(const string &str); 
string& append(const string &str,int pos,int n);

string字符串查找：

int find(const string& str,int pos);  
int find(const char* str,int pos);  
int find(const char* str,int pos,int n);  
int find(char c,int pos); //查找第一个位置，rfind用于查找最后一个位置

string字符串替换：

string& replace(int pos,int n,const string& str); 
string& replace(int pos,int n,const char* str);

string字符串比较：

int compare(const string& str);  
int compare(const char* str);

string字符串获取：

char& at(int n);

string字符串插入：

string& insert（int pos,const char* str）;  
string& insert（int pos,const string& str）;  
string& insert（int pos,int n,char c）;

string字符串删除：

string& erase(int pos,int n);

string获取子串：

string& substr（int pos，int n）;

vector构造函数：

vector v;  
vector(v1.begin(),v1.end());  
vector(n,elem);  
vector(const vector &v1);

vector赋值 *** 作：

assign(v1.begin(),v1.end());  
assign(int n,elem e);

vector容量 *** 作：

v.empty();  
v.size(); 
v.capacity()；  
v.resize(int n);  
v.resize(int n,elem e);

vector通过迭代器删除：

v.insert(const_iterator pos,elem e);  
v.insert(const_iterator pos,int num,elem e);  
v.erase(const_iterator pos);  
v.erase(const_iterator begin,const_iterator end); 
v.clear();

vector取数据：

v.front（）；
v.back（）；

vector交换两个容器的数据：

v.swap（v1） 
vector(v).swap(v);    //可利用swap和匿名对象减小空间浪费 
//vector预留空间：
reserve(int n)          //预留位置不初始化不可访问

deque： vector单端数组，deque双端数组，vector头部插入删除效率低，deque访问速度慢，deque无capacity接口，没有容量概念
deque排序：`sort（begin（），end（））；` //sort算法，对于支持随机访问的迭代器的容器，都可以用sort排序

list：迭代器不支持随机访问，是一个双向迭代器，也不可用[]和at访问元素
 翻转：reverse（）、排序sort（）  //两个都是成员函数

 特点：插入时会自动排序，属于关联式容器，底层结构是二叉树，set不允许有重复元素，multiset允许
  删除的重载：erase（elem e）； 
  查找：find（elem e）；//若存在，则返回该元素的迭代器，否则返回end（）    
  统计：count（elem e）； 
   插入只有insert（）；
  set内置数据类型时有默认排序规则，也可通过仿函数修改规则，但自定义类型必须先指定排序规则，否则无法插入   

pair对组：成对出现的数据，利用对组可以返回两个数据
 创建方式：

pair p(value1,value2);  
pair p=make_pair(value1,value2) 
//利用first和second取数据

 map中所有元素为pair类型，pair第一个数据为key值，起索引作用，第二个为value值，所有元素按照key值自动排序，属于关联式容器，底层结构是二叉树

map m; 
m.insert(pair)(type1value,type2value)) m.insert(make_pair(type1value,type2value)) 
//可用[]访问元素：m[key]=value

重载函数调用符()的类，其对象称为函数对象
 函数对象在使用时，可以像普通函数那样，有参数，有返回值
 函数对象可以有自己的状态，可以作为参数进行传递
返回bool类型的仿函数称为：谓词

搬运算法：transform（v1.begin,v1.end,v.begin)  //搬运前需要开辟空间
遍历算法：for_each(v1.begin,v1.end,fun)

常用查找算法：find、find_if、adjacent_find、binary_search、count、count_if

常用排序算法：sort、random_shuffle、merge、reverse

常用拷贝和替换算法：copy、replace、replace_if、swap

常用算术生成算法：fill、accumulate  //include

常用集合算法：set_intersection、set_uniom、set_difference