常用函数库

memset

• 是初始化函数：作用是将某一块内存中的内容全部设置为指定的值，这个函数通常为新申请的内存做初始化工作。

• 是对较大的结构体或数组进行清零操作的一种最快方法。

• 需要头文件<string.h>，在c++中为<cstring>

void *memset(void *s, int c, size_t n);

• s:要被初始化的内存块

• c:要被设置的值

• h:要被设置该值的字符数

• 返回类型是一个指向存储区s的指针

注意

1.不能任意赋值

memset函数是按照字节对内存块进行初始化，所以不能用它将int数组初始化为0和-1之外的其他值（除非该值高字节和低字节相同）。

因为memset函数只能取c的后八位给所输入范围的每个字节。也就是说无论c多大只有后八位二进制是有效的。

2.注意所赋值数组的元素类型

（1）对char类型数组a初始化元素为1

char a[4];
memset(a,"1",4);
//输出数组a为  1 1 1 1

（2）对int类型数组a初始化元素为1

int a[4];
memset(a,1,sizeof(a))
//输出数组a为  16843009 16843009 16843009 16843009 

• int数组：一般int所占内存空间为4个字节，所以在使用memset赋值时，不能用memset(a,1,4),不同的机器上int的大小可能不同，所以最好用sizeof()函数

• 当字符型数组时，字符型占据的内存大小就是1Byte，而memset函数也是以字节为单位进行赋值的，所以输出正确

• 当int数组时，整型占据的内存大小为4Byte，而memset函数还是按照字节为单位进行赋值，将1（00000001）赋给每一个字节。那么对于a[0]来说，其值为(00000001 00000001 00000001 00000001），即十进制的16843009。

getline

cin 不能输入包含嵌入空格的字符串，但getline可以

cin.getline()

cin.getline(接收字符串的变量m,接收字符个数，结束字符)

当第三个参数省略时，系统默认为''，

所以：当接收5个字符到m中，其中最后一个为''，只看到4个字符输出。如

char m[20];
cin.getline(m,5);
cout<<m<<endl;
//输入：abcdef  输出：abcd

当读取到结束字符，即结束，如

char m[20];
cin.getline(m,5,c);
cout<<m<<endl;
//输入：abcdef  输出：ab

getline

需#include<string>,而<cstring>不行！

getline(cin,string对象)

string s;
getline(cin,s);
cout<<s;
//输入：hello ee ww   输出：hello ee ww

当使用getline时，如果前面用cin输入东西，则必须输入cin.get()吃掉回车符

否则getline无法读取

strlen

计算字符串sting的长度，并返回字符串string的长度

返回类型 size_t： 是一个无符号长整型类型，直接作为数值运算时得注意，计算结果是否会越界。且无符号类型是大于等于0的，而两个size_t类型的数字进行相减的结果同样也是size_t类型的。

char s[20]="hello hhh";
cout<<strlen(s);
//>>> 9

定义字符串数组后若不初始化，后面用strlen函数可能出错

min & max

• 需头文件<algorithm>

• 两个值之间

min(a,b)

• 多个值之间

max({a,b,c,d})

min_element & max_element

• 需头文件<algorithm>

• 从范围 **[first, last)中获取最小/大值的元素。

• min_element(first,last,cmp)

• cmp：为可选择参数（自定义排序可用，默认不需要填）

• first、lasr：将迭代器输入到要比较的序列的初始位置和最终位置

• 返回值： 两个函数返回的都是迭代器，所以要提取数值的话需要在函数前加上*

• 两个函数默认都是从小到大排列， max_element() 输出最后一个值，min_element() 输出第一个值。

特别注意：如果自定义排序是从大到小的， max_element() 和min_element() 的返回结果相反，即max_element()返回最小值，min_element()返回最大值 。

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	int a[]={1,3,0,2,7,5};
	cout<<*max_element(a,a+6)<<endl;
	cout<<*min_element(a,a+6)<<endl;
}
//>> 7
//   0

sort

• sort()函数是类似于快速排序的方法，时间复杂度为n*log2(n)，执行效率较高

• 需头文件<algorithm>,algorithm意为"算法"

• sort(begin,end,cmp)

• begin：指向待排序数组的第一个元素的指针

• end：指向待排序数组的最后一个元素的下一个位置的指针

• cmp：排序准则，可以不写，如不写则默认从小到大进行排序。

如果想从大到小排序：将cmp参数写为greater<int>()就是对int数组进行排序。当然<>中也可写double、long、float等等。

如果我们需要按照其他的排序准则，就需要自己定义一个bool类型的函数来传入。如：按照每个数的个位进行从大到小排序

#include<iostream>
#include<algorithm>
using namespace std
    
bool cmp(int x,int y){
	return x % 10 > y % 10;
}

int main(){
	int num[10] = {65,59,96,13,21,80,72,33,44,99};
	sort(num,num+10,cmp);
	for(int i=0;i<10;i++){
		cout<<num[i]<<" ";
	}
	return 0;
} 
//输出：59 99 96 65 44 13 33 72 21 80

lower_bound & upper_bound

• 利用二分查找的方法在一个排好序的数组中进行查找

• 需头文件<algorithm>，algorithm意为"算法"

• 在从小到大的排序数组中

• lower_bound( begin,end,num)：

从数组的begin位置到end-1位置，二分查找第一个 >= num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• upper_bound( begin,end,num)：

从数组的begin位置到end-1位置，二分查找第一个 > num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• 在从大到小的排序数组中

• lower_bound( begin,end,num,greater<type>() ):

从数组的begin位置到end-1位置，二分查找第一个 <= num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

• upper_bound( begin,end,num,greater<type>() ):

从数组的begin位置到end-1位置,二分查找第一个 < num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。

accumulate

• 需头文件<numeric>

accumulate(vec.begin() , vec.end() , 起始值 , 自定义操作函数);

• 函数共有四个参数，其中前三个为必须，第四个为非必需。

• 头两个形参：指定元素范围

• 第三个形参：初值

• 若不指定第四个参数，则默认对范围内的元素进行累加操作

• 返回类型：是第三个实参的类型。

• 可以使用accumulate把string型的vector容器中的元素连接起来：

string sum = accumulate(v.begin() , v.end(), string(" "));

从空字符串开始，把vec里的每个元素连接成一个字符串。

累加求和

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;

int main() {
    vector<int> arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = accumulate(arr.begin(), arr.end(), 0); // 初值0 + (1 + 2 + 3 + 4 +... + 10)
    cout << sum << endl;	// 输出55
    return 0;
}

累乘

需要指定第四个参数，这里使用的是乘法函数 multiplies<type>(), type根据元素的类型选择。

vector<int> arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = accumulate(arr.begin(), arr.end(), 1, multiplies<int>());       
// 初值1 * (1 * 2 * 3 * 4 *... * 10)
cout << sum << endl;	// 输出3628800

计算数组中每个元素乘以3之后的和

int fun(int acc, int num) {
    return acc + num * 3;     // 计算数组中每个元素乘以3（要有“acc+”）
}

int main() {
    vector<int> arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int sum = accumulate(arr.begin(), arr.end(), 0, fun);
    cout << sum << endl;	// 输出 165
    return 0;
}

拼接字符串

#include <iostream>
#include <vector>
#include <numeric>
using namespace std;

int main() {
    vector<string> words{"this ", "is ", "a ", "sentence!"};
    string init, res;
    res = accumulate(words.begin(), words.end(), init);    // 连接字符串
    cout << res << endl;    // >>> this is a sentence!
    return 0;
}

初始值要新定义一个空字符串