C++常用函数汇总（持续更新）

注：写这篇文章是为了平时学习积累噢！文中的内容都表明出处啦，我只写了大概，不如原博主写的好，大家见谅哈~

vector

作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。

特别注意：

使用vector需要注意以下几点：

1、如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；

2、Vector作为函数的参数或者返回值时，需要注意它的写法：

double Distance(vector&a, vector&b) 其中的“&”绝对不能少！！！

实例：vectortest;

//建立一个vector，int为数组元素的数据类型，test为动态数组名

简单的使用方法如下：

vector<int>test;//建立一个vector

test.push_back(1);

test.push_back(2);//把1和2压入vector，这样test[0]就是1,test[1]就是2

vector<vector<Point2f> > points; //定义一个二维数组

points[0].size();  //指第一行的列数

基本操作

(1)头文件#include.

(2)创建vector对象，vector vec;

(3)尾部插入数字：vec.push_back(a);

(4)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的。

(5)使用迭代器访问元素.

vector<int>::iterator it;

for(it=vec.begin();it!=vec.end();it++)

    cout<<*it<<endl;

(6)插入元素： vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;

(7)删除元素： vec.erase(vec.begin()+2);删除第3个元素

vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始

(8)向量大小:vec.size();

(9)清空:vec.clear();
算法

• 使用reverse将元素翻转：需要头文件 #include<algorithm>

reverse(vec.begin(),vec.end());将元素翻转，即逆序排列！

(在vector中，如果一个函数中需要两个迭代器，一般后一个都不包含)

• 使用sort排序：需要头文件#include，

sort(vec.begin(),vec.end());(默认是按升序排列,即从小到大).

可以通过重写排序比较函数按照降序比较，如下：

定义排序比较函数：

bool Comp(const int &a,const int &b)
{
    return a>b;
}

调用时:sort(vec.begin(),vec.end(),Comp)，这样就降序排序。

• 输出Vector的中的元素

vector<float> vecClass; 

int nSize = vecClass.size();   

//打印vecClass,方法一：

for(int i=0;i<nSize;i++)  
{  
   cout<<vecClass[i]<<"     ";  
}  
   cout<<endl; 

需要注意的是：以方法一进行输出时，数组的下标必须保证是整数。
//打印vecClass,方法二：

for(int i=0;i<nSize;i++)  
{  
   cout<<vecClass.at(i)<<"     ";  
}  
   cout<<endl;  

//打印vecClass,方法三：输出某一指定的数值时不方便

for(vector<float>::iterator it = vecClass.begin();it!=vecClass.end();it++)  
{  
    cout<<*it<<"   ";  
}  
    cout<<endl;  

二维数组的使用：

#include "stdafx.h"
#include <cv.h>
#include <vector> 
#include <iostream> 
using namespace std;
int main()
{
	using namespace std;
	int out[3][2] = { 1, 2, 
			 3, 4,
			5, 6 };
	vector <int*> v1;
 
	v1.push_back(out[0]);
	v1.push_back(out[1]);
	v1.push_back(out[2]);
 
	cout << v1[0][0] << endl;//1
	cout << v1[0][1] << endl;//2
	cout << v1[1][0] << endl;//3
	cout << v1[1][1] << endl;//4
	cout << v1[2][0] << endl;//5
	cout << v1[2][1] << endl;//6
 
	return 0;
}

转自博主 那年聪聪

使用const引用是一个好习惯(const 修饰容器，则初始化后不能增删元素也不能修改元素，也不能改变容器大小 ,也就说不能做任何改动。）
在C++中容器都是值拷贝的，因此不使用引用的话，会大量拷贝垃圾数据.其实，可以这么说C/C++是值拷贝编程语言。不使用额外的技术，比如指针、引用，都会发生垃圾数据的拷贝。当然，到底是不是垃圾数据由你自己决定，值拷贝是无法彻底摒弃的。

c++中vector和vector<int*>的用法比较（转自 军说网事）

accumulate

accumulate定义在#include<numeric>中，作用有两个，一个是累加求和，另一个是自定义类型数据的处理

• 算法简介：accumulate(iterator beg, iterator end, value);
  计算容器元素累计总和；[beg,end)为起始迭代器和结束迭代器，vaule为起始值 。

主要用于数值的累加求和、字符串的连接。

例子
使用accumulate(iterator beg, iterator end, value)函数计算vector容器中所有元素（0-100）的和，其初始值为1000

#include<iostream>
#include<vector>
#include<string>
#include<numeric>
using namespace std;
 
// 常用算术生成算法: accumulate(iterator beg, iterator end, value); 计算[beg,end)区间中所有元素的和
// all = value + sum(beg,end) 
 
void test01(){
	
	vector<int> vec;
	for(int i=0; i<=100; i++){
		vec.push_back(i); 
	} 
	
	vector<string> vecs;
	vecs.push_back("Hello");
	vecs.push_back("World");
	vecs.push_back("!");
	
    // 对string类型进行累积
	string sunStr = accumulate(vecs.begin(), vecs.end(), string(""));
	
	// 计算vec容器中所有元素的总和 
	int sumNum = accumulate(vec.begin(), vec.end(), 1000);
	
	cout << "vec容器中元素的总和为：" << sumNum << endl;
	cout << "vecs为:" << sunStr << endl;
	
}
 
int main(){
	
	test01();
	
	system("pause");
	return 0;
	
} 

转自博主 凉冰难消一腔热血
构建二维动态数组

int **p;
p = new int*[10];    //注意，int*[10]表示一个有10个元素的指针数组
for (int i = 0; i < 10; ++i)
{
    p[i] = new int[5];
}

定义二维vector

vector<vector<int>> v;

访问二维vector的元素的三种方式
如果指定外层和内层向量的大小，就可用operator[]进行读和写；如果只指定外层向量大小，就能用push_back()函数进行写，不能用operator[]进行读和写。

1. 指定外层vector大小

可用push_back函数进行初始化：

v.resize(3);
v[1].push_back(9);

2. 遍历指定内层vector大小
   提前设定好每行vector的大小，就可用operator[]访问，如下：

for(int i=0;i<3;i++)
    v[i].resize(3);

3. 一次指定内外层vector大小

v.resize(n, vector<int>(m));

---

定义一个二维整形数组并初始化：

vector<vector<int> > array(m); //这个m一定不能少//vector<int> array[m];
//初始化一个m*n的二维数组
for(int i=0;i<m;i++) 
{
    array[i].resize(n);
}
//遍历赋值
for(i = 0; i < array.size(); i++)
{
 　　for (j = 0; j < array[0].size();j++) 
    { 　　
        array[i][j] = (i+1)*(j+1); 
    } 
}

sort

用法：

1、sort函数可以三个参数也可以两个参数，必须的头文件#include < algorithm>;

2、它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)

3、sort函数有三个参数：（第三个参数可不写）
（1）第一个是要排序的数组的起始地址。
（2）第二个是结束的地址（最后一位要排序的地址）
（3）第三个参数是排序的方法，可以是降序也可是升序；还可以不写第三个参数，此时默认的是升序。

两个参数：

#include<iostream>
#include<algorithm> 
using namespace std;
 
int main(){
	int a[10]={1,3,5,2,14,6,7,62,9};
	for(int i=0;i<10;i++){
		sort(a,a+10);
		for(i=0;i<10;i++){
			cout<<a[i]<<" ";
		}
	}
	system("pause");
	return 0;
	
} 

三个参数：

#include<iostream>
#include<vector>
#include<algorithm> 
using namespace std;
 
bool myfunction(int i,int j){
	return (i<j);
}//升序排列 
bool myfunction2(int i,int j){
	return (i>j);
}//降序排列 
struct myclass{
	bool operator()(int i,int j){
		return (i<j);
	}
}myobject; 

int main(){
	
	int myints[8]={32,14,64,3,23,6,44,75};
	vector<int> myvector(myints,myints+8);
	
	sort(myvector.begin(),myvector.begin()+4);
	sort(myvector.begin()+4,myvector.end(),myfunction);
	sort(myvector.begin(),myvector.end(),myobject);
	
	cout<<"myvector contains:";
	for(vector<int>::iterator it=myvector.begin();it!=myvector.end();it++){
		cout<<' '<<*it;
	}
	cout<<'\n';
	
	system("pause");
	return 0;
	
} 

string使用反向迭代器来完成逆序排列（rbegin,rend)

#include<iostream>
using namespace std;
 
int main(){
	string str("abcdef");
	string s(str.rbegin(),str.rend());
	cout<<s<<endl;
	 
	return 0;
	
} 

转自博主 布林叮咚

想要拷贝元素：for(auto x:range)

想要修改元素 : for(auto &&x:range)

想要只读元素：for(const auto &x:range)

find

find() 函数本质上是一个模板函数，用于在指定范围内查找和目标元素值相等的第一个元素。

如下为 find() 函数的语法格式：
InputIterator find (InputIterator first, InputIterator last, const T& val);

其中，first 和 last 为输入迭代器，[first, last) 用于指定该函数的查找范围；val 为要查找的目标元素。