c、c++ 常用API汇总

baiiu

已于 2024-01-26 07:55:35 修改

阅读量1w

点赞数 14

分类专栏： linux、c、c++、jni等文章标签： C语言 C++

于 2021-04-15 10:28:14 首次发布

本文链接：https://blog.csdn.net/u014099894/article/details/115717793

版权

linux、c、c++、jni等专栏收录该内容

18 篇文章 1 订阅

订阅专栏

前言

本文汇总c、cpp里常用API，会持续更新，便于查阅。
C语言部分参考：C语言基础知识整理

<string.h>

传入此类函数的指针必须是以空字符为结尾的。

char *strchr(const char *str, int c)
在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置；
如果未找到该字符则返回 NULL。
char *strstr(const char *haystack, const char *needle)
在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’；
返回字符串str中第一次出现子串substr的地址；如果没有检索到子串，则返回NULL。
int strncasecmp(const char *s1, const char *s2, size_t n);
比较参数s1 和s2 字符串前n个字符，并且忽略大小写。
若参数s1 和s2 字符串相同则返回0。s1 若大于s2 则返回大于0 的值，s1 若小于s2 则返回小于0 的值。
char * strncpy(char *dest, const char *src, size_t n);
dest 为目标字符串指针，src 为源字符串指针。strncpy()会将字符串src前n个字符拷贝到字符串dest。
strncpy()不会向dest追加结束标记’\0’。
使用strncpy()最安全方式是使n等于strlen(src)+1，即拷贝整个字符串，同时将’\0’追加到dest。
char *strcpy(char *dest, const char *src);
dest 为目标字符串指针，src 为源字符串指针。
注意：src 和 dest 所指的内存区域不能重叠，且 dest 必须有足够的空间放置 src 所包含的字符串(包含结束符NULL)；如果参数 dest 所指的内存空间不够大，可能会造成缓冲溢出(buffer Overflow)的错误情况。
strcpy只用于字符串复制，并且它不仅复制字符串内容之外，还会复制字符串的结束符。
void *memcpy(void *str1, const void *str2, size_t n)
从存储区 str2 复制 n 个字节到存储区 str1；
该函数返回一个指向目标存储区 str1 的指针。
memcpy是按字节拷贝，在拷贝字符串时需要多加一位；

   const char src[50] = "123";
   int len = strlen(src) + 1;
   char dest[50];
 
   memcpy(dest, src, len);
   dest[len] = '\0';

void *memset(void *str, int c, size_t n)
复制字符 c（一个无符号字符）到参数 str 所指向的字符串的前 n 个字符。
int strcmp(const char* s1,const char* s2);
当s1 < s2时，返回负数；
当s1 == s2时，返回值 = 0；
当s1 > s2时，返回正数`

<stdlib.h>

int atoi (const char * str);
atoi() 函数会扫描参数 str 字符串，跳过前面的空白字符，直到遇上数字或正负符号才开始做转换，遇到多少数字转换多少，直到遇见非数字字符为止；
返回转换后的整型数；如果 str 不能转换成 int 或者 str 为空字符串，那么将返回 0。

<stdio.h>

int sprintf(char *str, char * format [, argument, ...]);
str为要写入的字符串；format为格式化字符串，与printf()函数相同；argument为变量；
sprintf的作用是将一个格式化的字符串输出到一个目的字符串中，而printf是将一个格式化的字符串输出到屏幕；
sprintf()会根据参数format 字符串来转换并格式化数据，然后将结果复制到参数str 所指的字符串数组，直到出现字符串结束(‘\0’)为止；
成功则返回参数str字符串长度，失败则返回-1，错误原因存于errno 中；
如果str的长度不够，sprintf()很容易造成缓冲区溢出，带来意想不到的后果。

std::string

头文件：#include<string>

初始化
当初始值只有一个时，使用直接初始化和拷贝初始化都可以。

string s1;  // 默认初始化，s1是一个空串
string s2(s1); // s2是s1的一个副本
string s3("value"); // s3是字面值"value"的副本，除了最后\0字符以外； 直接初始化
string s3 = "value"; // 等价于s3("value")，s3是字面值"value"的副本； 拷贝初始化
string s4(n, 'c');  // 把s4初始化为n个c字符组成的串

string substr(int pos, int n)：
截取字符串；第一个是开始位置，第二个是获取子串的长度；
const char* c_str()、const char* data()
string转char*；区别是 c_str()方法会在末尾添加‘\0’;
string s(charArr, charArr + strlen(st))
char*转string；
添加元素
string.append(1, 'c'); 添加一个c字符
string.erase(string.size() - 1); 删除最后一个字符
string.push_back('c')添加一个c字符
string.pop_back(); 删除最后一个字符
s1.compare(s2)
返回值为0，则两者相等
获取char
string[index];
string.at(index);
包含
str.find('o') != string::npos
str.find("xxx") != string::npos
转换相关
stoi()、stol()、stoll()等把字符串转换成整数；
stof()、stod()等把字符串转换成浮点数；
to_string()把整数、浮点数转换成字符串。

std::pair

pair<T1, T2> p1; 创建一个空的pair对象（使用默认构造），它的两个元素分别是T1和T2类型，采用值初始化。
make_pair(v1, v2); 以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。
p1.first; 返回对象p1中名为first的公有数据成员
p1.second; 返回对象p1中名为second的公有数据成员
queue.push({1,2}) 向queue<pair<int,int>>中添加pair元素

数组

数组声明如a[d]；其中a是数组的名字，d是数组的维度。
维度d应该在编译的时候就确定，即数组的个数d是一个常量表达式。

默认情况下，数组内的元素会被默认初始化。

// arraySize 必须是一个大于零的整数常量
int arr[100]; 

// 遍历，常量引用，最高效； 知道类型的情况下不适用auto效率最高
for (const int& value : arr) {
	cout << value << endl;
}

const int length = 2;
Person arr[length];
for (int i = 0; i < length; ++i) {
    // 无
}

for (Person p : arr) {
    // 调用拷贝构造函数
}

for (const Person &p : arr) {
    // 无
}

std::vector

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。
向量是一个能够存放任意类型的动态数组。

头文件：#include <vector>

初始化

vector<T> v1;  // v1是一个空vector，潜在元素为T类型，执行默认初始化；此时不能使用v1[index]访问，会报错；
vector<T> v2(v1); // v2中包含v1所有元素的副本
vector<T> v2 = v1;  // 等价于v2(v1)，v2中包含v1所有元素的副本
vector<T> v3(n, val); // v3包含了n个重复的元素，每个元素的值都是val
vetor<T> v4(n); // n4包含了n个重复的执行了值初始化的对象，即T对象的默认初始化
vector<T> v5{a,b,c}; // v5包含了初始值个数的元素，每个元素被赋予相应的初始值
vector<T> v5 = {a,b,c}; // 等价于v5{a,b,c}

vector<int> v1(10); // 列表有10个元素，每个元素都是0
vector<int> v1{10}; // 列表有1一个元素，该元素值为10

vector<int> v1(10,1); // 列表有10个元素，每个元素都是1
vector<int> v1{10,1}; // 列表有2一个元素，元素值为10，1

vector<vector<T>> preSum(row ,vector<T>(column)); // 创建二维数组
vector<int> temp(column + 1);
preSum.resize(row + 1, temp); // 重新初始化二维数组

vec.reserve(2); 目的是预设容量，避免动态扩充；
vec.resize(2); 目的是改变vector的长度，size = 2, capacity = 2, 从第2个位置开始填充，默认为{0,0}
vec.resize(10, 5); 用元素5填充数组长度到10个；

vec[i]; 取元素，[] operator 在回傳元素時是不會作任何的邊界檢查
vec.at(i); 取元素，at() 取元素时会做边界判断，超出时会抛出out_of_range

vec.push_back(1); 向末尾新增一个元素1，长度满了的话扩充
vec.emplace_back(1)， c++11中使用该方法替代push_back，在容器尾部添加一个元素，这个元素原地构造，不需要触发拷贝构造和转移构造。而且调用形式更加简洁，直接根据参数初始化临时对象的成员。
emplace_back() 和 push_back 的区别

vec.pop_back(); 刪除 vector 最尾端的元素
vec.insert(vec.begin() + 2, 6); 在第二个位置插入6
vec.emplace(vec.begin() + 2, 6); 在第二个位置插入6
emplace() 在插入元素时，是在容器的指定位置直接构造元素，而不是先单独生成，再将其复制（或移动）到容器中。因此，在实际使用中，推荐大家优先使用 emplace()。
C++ STL vector插入元素（insert()和emplace()）详解

vec.erase(iterator position); 迭代器遍历时删除
vec.clear(); 清空元素
vec.empty(); 如果 vector 內部為空，則傳回 true 值

// 判断是否存在某个元素
if (std::count(v.begin(), v.end(), key)){
	// 存在
}

if (std::find(v.begin(), v.end(), key) != v.end()) {
	// 存在
}

std::map, std::unordered_map

头文件：#include <map>，#include <unordered_map>

初始化

map<string, int> m1;
m1["def"] = 2;
m1.insert({ "abc", 1 });
m1.insert(make_pair(string("def"), 2));
m1.insert(pair<string, int>(string("ghi"), 3));
// c++11及以上可以使用列表初始化
map<string,int> m2 = {
    {"string",1}, {"sec",2}, {"trd",3}
};
// 遍历数组直接添加，不用判断是否存在
unordered_map<int, int> map;
for (auto& v : nums) {
	map[v]++;
}

count(key)
返回返回指定元素出现的次数；
返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。
map.find(key) == map.end()
返回的是被查找元素的位置，没有则返回map.end()。
插入元素
map.insert(pair<int,string>(1,"test"));
map.insert(std::map<int, std::string>::value_type (1, "test"));
map[key] = value
删除元素
map.erase(const key_type& k)
遍历

for (unordered_map<key,T>::iterator iter = map.begin(); iter != map.end(); iter++) {
	printf("key: %s, value: %s", iter.first, iter.second);
}

for (auto &v:map) {
	printf("key: %s, value: %s", v.first, v.second);
}

std::set, std::unordered_set

头文件：#include <set>，#include <unordered_set>
set.insert(xx) ：插入元素
set.size()；获取元素个数
set.erase()：删除集合中的元素

set.count(key)：返回返回指定元素出现的次数；返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。
set.find(key) == set.end()：返回的是被查找元素的位置，没有则返回map.end()。

std::stack

头文件：#include <stack>

stack<int> stk; 创建栈；
stk.push(xx);：压栈元素
int number = stk.top(); 获取栈顶元素；
stk.pop(); 弹出栈顶元素
stk.size()； 获取栈内元素个数
stk.empty()； 判断是否为空；

std::queue

头文件：#include <queue>

queue<int> queue; 创建队列
queue.front();返回 queue 中第一个元素的引用。
queue.pop();删除 queue 中的第一个元素。
queue.back();返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。
queue.push(const T& obj)：在 queue 的尾部添加一个元素的副本。这是通过调用底层容器的成员函数 push_back() 来完成的。
queue.push(T&& obj);以移动的方式在 queue 的尾部添加元素。这是通过调用底层容器的具有右值引用参数的成员函数 push_back() 来完成的。
queue.size();返回 queue 中元素的个数。
queue.empty();如果 queue 中没有元素的话，返回 true。

std::priority_queue

priority_queue<int, vector<int>, function<bool(int, int)>> queue([] (int a, int b) { return a->val > b->val; }); 初始化带比较器的priority_queue；
queue.top(); 取第一个元素引用；
queue.pop();删除 queue 中的第一个元素；