C++常用函数合集

万能头文件：#include<bits/stdc++.h>

1. 输入输出流（I/O）函数

`1.1cin`

用于从标准输入流读取数据。

`1.2cout`

用于向标准输出流写入数据。

// 输入输出流（I/O）函数
#include <iostream>
using namespace std;
int main() {
    int a;
    cin >> a;  // 输入一个整数
    cout << "你输入的数字是: " << a << endl;  // 输出
    return 0;
}

1.3 `cerr` (标准错误流)

cerr 用于输出错误信息，通常与错误处理或异常有关。它会将信息输出到标准错误流，并且默认情况下不进行缓冲。这意味着错误信息会立刻输出。

1.4 `clog` (日志流)

clog 用于输出日志信息，通常用于记录程序的运行状态、警告、调试信息等。它通常与程序的运行日志有关，默认情况下会进行缓冲，这意味着它的输出可能会稍微延迟，直到缓冲区满或程序结束时。

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    // 使用 cerr 输出错误信息
    cerr << "Error: Something went wrong!" << endl;

    // 使用 clog 输出日志信息
    clog << "Log: Program is starting..." << endl;

    // 模拟文件打开失败，使用 cerr 输出错误信息
    ifstream file("nonexistent_file.txt");
    if (!file.is_open()) {
        cerr << "Error: Failed to open the file!" << endl;
    }

    // 输出日志信息
    clog << "Log: Program completed." << endl;

    return 0;
}

2. 字符串处理函数

`2.1 strlen`

strlen 是一个标准库函数，定义在 <cstring> 头文件中，用于返回以空字符 '\0' 结束的 C 风格字符串的长度（不包括空字符）。

#include <iostream>
#include <cstring>  // 包含strlen
using namespace std;

int main() {
    const char* str = "Hello, World!";
    cout << "字符串长度是: " << strlen(str) << endl;  // 输出 13
    return 0;
}

`2.2 strcmp`

strcmp 函数用于比较两个 C 风格字符串。它逐字符比较两个字符串的 ASCII 值，返回一个整数值：

如果两个字符串相等，返回 0。
如果第一个字符串小于第二个字符串，返回负值。
如果第一个字符串大于第二个字符串，返回正值。

#include <iostream>
#include <cstring>  // 包含strcmp
using namespace std;

int main() {
    const char* str1 = "Hello";
    const char* str2 = "World";

    int result = strcmp(str1, str2);
    if (result == 0) {
        cout << "字符串相等" << endl;
    } else if (result < 0) {
        cout << "str1 小于 str2" << endl;
    } else {
        cout << "str1 大于 str2" << endl;
    }

    return 0;
}

`2.3 strcpy`

strcpy 用于将一个字符串的内容复制到另一个字符串中。它也定义在 <cstring> 头文件中。

#include <iostream>
#include <cstring>  // 包含strcpy
using namespace std;

int main() {
    const char* src = "Hello, World!";
    char dest[50];  // 目标字符串数组，确保有足够空间存放源字符串

    strcpy(dest, src);  // 复制源字符串到目标字符串
    cout << "目标字符串是: " << dest << endl;

    return 0;
}

`2.4 strcat`

strcat 函数用于连接两个 C 风格字符串（即将第二个字符串附加到第一个字符串的末尾）。

#include <iostream>
#include <cstring>  // 包含strcat
using namespace std;

int main() {
    char str1[50] = "Hello, ";
    const char* str2 = "World!";

    strcat(str1, str2);  // 连接str2到str1
    cout << "连接后的字符串是: " << str1 << endl;

    return 0;
}

`2.5 stoi`、`stol`、`stof`、`stod`

这些函数用于将字符串转换为不同的数字类型（整数、长整型、浮点数）。它们定义在 <string> 头文件中。

stoi：将字符串转换为 int 类型。
stol：将字符串转换为 long 类型。
stof：将字符串转换为 float 类型。
stod：将字符串转换为 double 类型。

#include <iostream>
#include <string>  // 包含stoi, stol, stof, stod
using namespace std;

int main() {
    string str_int = "123";
    string str_long = "9876543210";
    string str_float = "3.14";
    string str_double = "2.71828";

    // 将字符串转换为不同类型
    int num1 = stoi(str_int);
    long num2 = stol(str_long);
    float num3 = stof(str_float);
    double num4 = stod(str_double);

    cout << "字符串转换为整数: " << num1 << endl;
    cout << "字符串转换为长整型: " << num2 << endl;
    cout << "字符串转换为浮点数: " << num3 << endl;
    cout << "字符串转换为双精度浮点数: " << num4 << endl;

    return 0;
}

3. 数学函数

`3.1 abs`

abs 是一个标准库函数，用于返回给定整数的绝对值，即无论输入是正数、负数还是零，返回一个非负的整数

#include <iostream>
#include <cstdlib>  // 包含abs
using namespace std;

int main() {
    int num1 = -10;
    int num2 = 5;

    cout << "num1 的绝对值: " << abs(num1) << endl;  // 输出 10
    cout << "num2 的绝对值: " << abs(num2) << endl;  // 输出 5

    return 0;
}

`3.2 sqrt`

sqrt 是标准库函数，用于计算一个非负数的平方根。它定义在 <cmath> 头文件中。请注意，sqrt 不能对负数计算平方根，它会返回 NaN（不是一个数字）或导致运行时错误。

#include <iostream>
#include <cmath>  // 包含sqrt
using namespace std;

int main() {
    double num = 25.0;

    cout << "num 的平方根: " << sqrt(num) << endl;  // 输出 5

    return 0;
}

`3.3 pow`

pow 是一个用于计算幂的函数，定义在 <cmath> 头文件中。它有两个参数：底数和指数，返回底数的指数次幂（即底数的指数次方）。

#include <iostream>
#include <cmath>  // 包含pow
using namespace std;

int main() {
    double base = 2.0;
    double exponent = 3.0;

    cout << "base 的 exponent 次幂: " << pow(base, exponent) << endl;  // 输出 8.0

    return 0;
}

计算 x 的整数 n 次幂函数（即，x的n 次方）

`3.4 sin`、`cos`、`tan`

在 <cmath> 头文件中，sin、cos 和 tan 分别用于计算一个角度的正弦、余弦和正切值。注意，这些函数的参数是弧度而不是角度。

sin(x)：返回角度 x 的正弦值。
cos(x)：返回角度 x 的余弦值。
tan(x)：返回角度 x 的正切值。

#include <iostream>
#include <cmath>  // 包含 sin, cos, tan
using namespace std;

int main() {
    double angle = M_PI / 4;  // 45度，即 π/4 弧度

    cout << "sin(45度): " << sin(angle) << endl;  // 输出 0.707107
    cout << "cos(45度): " << cos(angle) << endl;  // 输出 0.707107
    cout << "tan(45度): " << tan(angle) << endl;  // 输出 1

    return 0;
}

`3.5 exp`

在 <cmath> 头文件中，sin、cos 和 tan 分别用于计算一个角度的正弦、余弦和正切值。注意，这些函数的参数是弧度而不是角度。

sin(x)：返回角度 x 的正弦值。
cos(x)：返回角度 x 的余弦值。
tan(x)：返回角度 x 的正切值。

#include <iostream>
#include <cmath>  // 包含 exp
using namespace std;

int main() {
    double exponent = 2.0;

    cout << "e^2: " << exp(exponent) << endl;  // 输出 7.389056

    return 0;
}

`3.6 log`

log(x) 函数返回 x 的自然对数（即以 e 为底的对数），它是数学中对数的常用形式。

#include <iostream>
#include <cmath>  // 包含 log
using namespace std;

int main() {
    double value = 7.389056;

    cout << "log(7.389056): " << log(value) << endl;  // 输出 2

    return 0;
}

`3.7 ceil`、`floor`

ceil(x)：返回大于或等于 x 的最小整数（即向上取整）。
floor(x)：返回小于或等于 x 的最大整数（即向下取整）。

#include <iostream>
#include <cmath>  // 包含 ceil 和 floor
using namespace std;

int main() {
    double value1 = 4.3;
    double value2 = -4.3;

    cout << "ceil(4.3): " << ceil(value1) << endl;  // 输出 5
    cout << "floor(4.3): " << floor(value1) << endl;  // 输出 4

    cout << "ceil(-4.3): " << ceil(value2) << endl;  // 输出 -4
    cout << "floor(-4.3): " << floor(value2) << endl;  // 输出 -5

    return 0;
}

4. 时间与日期函数

`4.1 time`

time() 函数返回当前的时间戳，也就是从 1970 年 1 月 1 日 00:00:00 UTC 到当前时刻的秒数。返回值是一个 time_t 类型的整数。

#include <iostream>
#include <ctime>  // 包含 time
using namespace std;

int main() {
    time_t currentTime = time(0);  // 获取当前时间戳
    cout << "当前时间戳: " << currentTime << endl;

    return 0;
}

`4.2clock`

clock() 函数返回程序执行的 CPU 时间，单位是时钟周期（通常是毫秒）。可以通过 CLOCKS_PER_SEC 来获取时钟周期每秒的数量，进而换算为秒。

#include <iostream>
#include <ctime>  // 包含 clock 和 CLOCKS_PER_SEC
using namespace std;

int main() {
    clock_t start = clock();  // 获取程序开始时的 CPU 时间

    // 假设程序做一些工作（比如循环）
    for (int i = 0; i < 1000000; ++i);

    clock_t end = clock();  // 获取程序结束时的 CPU 时间
    double timeTaken = double(end - start) / CLOCKS_PER_SEC;  // 计算所用时间

    cout << "程序执行时间: " << timeTaken << " 秒" << endl;

    return 0;
}

`4.3localtime`

localtime() 函数将给定的时间戳（time_t 类型）转换为当地时间，并返回一个 tm 结构体。该结构体包含了如年、月、日、小时、分钟、秒等详细信息。

#include <iostream>
#include <ctime>  // 包含 localtime
using namespace std;

int main() {
    time_t currentTime = time(0);  // 获取当前时间戳
    struct tm *localTime = localtime(&currentTime);  // 将时间戳转换为当地时间

    cout << "当前本地时间: "
         << 1900 + localTime->tm_year << "-"  // 年份需要加上1900
         << 1 + localTime->tm_mon << "-"      // 月份从0开始计数，需要加1
         << localTime->tm_mday << " "
         << localTime->tm_hour << ":"
         << localTime->tm_min << ":"
         << localTime->tm_sec << endl;

    return 0;
}

`4.4strftime`

strftime() 函数用于格式化日期和时间。你可以指定一个格式字符串来控制输出的日期时间格式。它使用 tm 结构体中的时间数据进行格式化。

#include <iostream>
#include <ctime>  // 包含 strftime
using namespace std;

int main() {
    time_t currentTime = time(0);  // 获取当前时间戳
    struct tm *localTime = localtime(&currentTime);  // 转换为当地时间

    char formattedTime[100];
    strftime(formattedTime, sizeof(formattedTime), "%Y-%m-%d %H:%M:%S", localTime);  // 格式化日期时间

    cout << "格式化的时间: " << formattedTime << endl;

    return 0;
}

5. 内存管理函数

`5.1 malloc`、`calloc`

malloc(size_t size)：用于动态分配内存。它返回一个指向分配内存区域的指针。分配的内存没有初始化，因此内存的内容是未定义的。
calloc(size_t num, size_t size)：用于动态分配内存，并初始化为零。它实际上是分配 num 个元素，每个元素大小为 size 字节的内存。

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr;
    size_t n = 5;

    // 使用 malloc 分配内存
    arr = (int *)malloc(n * sizeof(int));  // 为 5 个 int 元素分配内存
    if (arr == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    // 给 malloc 分配的内存赋值
    for (size_t i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // 输出数组元素
    printf("使用 malloc 分配的内存内容：\n");
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 使用 calloc 分配内存
    int *arr2 = (int *)calloc(n, sizeof(int));  // 为 5 个 int 元素分配内存，并初始化为零
    if (arr2 == NULL) {
        printf("内存分配失败！\n");
        free(arr);  // 释放 malloc 分配的内存
        return 1;
    }

    // 输出 calloc 分配的内存内容（应该都是 0）
    printf("使用 calloc 分配的内存内容：\n");
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr2[i]);  // 所有元素都为 0
    }
    printf("\n");

    // 释放动态分配的内存
    free(arr);
    free(arr2);

    return 0;
}

`5.2 free`

free(pointer)：释放由 malloc 或 calloc 分配的内存。在使用完动态分配的内存后，调用 free 可以释放内存并避免内存泄漏。

`5.3 new`、`delete`

在 C++ 中，new 和 delete 运算符用于动态内存分配和释放，它们比 malloc 和 free 更加方便和安全。

new：分配内存并返回指向该内存的指针。如果分配失败，抛出 std::bad_alloc 异常（C++ 语言特性）。
delete：释放由 new 分配的内存。使用 delete[] 来释放数组形式的内存。

#include <iostream>
using namespace std;

int main() {
    size_t n = 5;

    // 使用 new 分配内存
    int* arr = new int[n];  // 为 5 个 int 元素分配内存
    if (arr == nullptr) {
        cout << "内存分配失败！" << endl;
        return 1;
    }

    // 给 new 分配的内存赋值
    for (size_t i = 0; i < n; i++) {
        arr[i] = i + 1;
    }

    // 输出数组元素
    cout << "使用 new 分配的内存内容：" << endl;
    for (size_t i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // 使用 new[] 分配内存
    int* arr2 = new int[n];  // 为 5 个 int 元素分配内存
    if (arr2 == nullptr) {
        cout << "内存分配失败！" << endl;
        delete[] arr;  // 释放 arr
        return 1;
    }

    // 输出 arr2（其内容将是未定义的，除非你手动初始化它们）
    cout << "使用 new[] 分配的内存内容：" << endl;
    for (size_t i = 0; i < n; i++) {
        cout << arr2[i] << " ";  // 输出将是未定义的值
    }
    cout << endl;

    // 释放动态分配的内存
    delete[] arr;  // 释放由 new[] 分配的数组内存
    delete[] arr2; // 释放由 new[] 分配的数组内存

    return 0;
}

6. 容器和算法

`6.1 vector`

vector 是一个可以动态扩展的数组容器，它的底层是基于动态数组实现的。相比于普通的数组，vector 提供了更加灵活的内存管理和操作方式，自动处理元素的添加、删除和内存扩展。

主要特点：

动态大小：vector 可以根据需要动态地扩展或收缩，能够在运行时动态分配内存。
按索引访问元素：与数组一样，vector 允许通过索引来直接访问元素。
支持自动扩容：当 vector 满了，它会自动分配更大的内存来容纳更多的元素。
元素连续存储：vector 内部是一个连续的内存块，元素是按顺序存储的。

常用操作：

添加元素：使用 push_back() 可以将元素添加到 vector 的末尾。
访问元素：通过 operator[] 或 at() 可以访问 vector 中的元素。
删除元素：使用 pop_back() 删除 vector 的最后一个元素。

#include <iostream>
#include <vector>

int main() {
    // 创建一个空的 vector
    std::vector<int> vec;

    // 向 vector 中添加元素
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    // 访问并输出 vector 中的元素
    std::cout << "vector 中的元素：" << std::endl;
    for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";  // 或者使用 vec.at(i)
    }
    std::cout << std::endl;

    // 删除最后一个元素
    vec.pop_back();

    // 输出删除后的元素
    std::cout << "删除最后一个元素后的 vector：" << std::endl;
    for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

`6.2 map`

map 是一个基于键值对的关联容器，它通过键（key）来存储和访问数据。每个键都是唯一的，且 map 会自动根据键的顺序对其进行排序。底层通常采用红黑树实现，因此它提供了对键的快速查找、插入和删除操作。

主要特点：

键值对存储：map 中的每个元素都是一个键值对（key-value），你通过键来存储和查找值。
有序：map 会根据键进行排序，默认是升序排列（你也可以自定义排序规则）。
不允许重复键：map 中的键必须唯一。如果尝试插入相同的键，新的值将替代旧的值。

常用操作：

插入元素：使用 insert() 或 [] 来插入键值对。
访问元素：使用 [] 或 at() 来通过键访问对应的值。
删除元素：使用 erase() 删除指定的键值对。

#include <iostream>
#include <map>

int main() {
    // 创建一个空的 map
    std::map<int, std::string> m;

    // 向 map 中插入元素
    m[1] = "苹果";
    m[2] = "香蕉";
    m[3] = "橙子";

    // 使用 insert() 插入元素
    m.insert({4, "葡萄"});

    // 访问并输出 map 中的元素
    std::cout << "map 中的元素：" << std::endl;
    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 删除键为 2 的元素
    m.erase(2);

    // 输出删除后的 map
    std::cout << "删除键为 2 后的 map：" << std::endl;
    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

`6.3 set`

set 是 C++ 标准库中的一个容器，用于存储唯一的元素，并且元素会自动按照升序排列。set 不允许有重复的元素，并且对元素的查找、插入、删除等操作的时间复杂度为对数级别（O(log n)）。

#include <iostream>
#include <set>

int main() {
    std::set<int> s;

    // 向 set 中插入元素
    s.insert(10);
    s.insert(20);
    s.insert(30);
    s.insert(20);  // 插入重复的元素，set 会忽略它

    // 输出 set 中的元素
    std::cout << "set 中的元素：" << std::endl;
    for (const int& elem : s) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

`6.4 sort`

sort 是 C++ 标准库中的排序算法，它用于对容器中的元素进行排序。默认情况下，它是按升序排序的，但也可以自定义排序规则。

#include <iostream>
#include <vector>
#include <algorithm>  // sort 函数需要包含此头文件

int main() {
    std::vector<int> vec = {30, 10, 20, 50, 40};

    // 对 vector 中的元素进行升序排序
    std::sort(vec.begin(), vec.end());

    // 输出排序后的 vector
    std::cout << "排序后的元素：" << std::endl;
    for (const int& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

`6.5 find`

find 是 C++ 标准库中的一个算法，用于在容器中查找某个元素。它返回一个迭代器，如果元素找到，返回指向该元素的迭代器；如果未找到，返回容器的 end() 迭代器。

#include <iostream>
#include <vector>
#include <algorithm>  // find 函数需要包含此头文件

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};

    // 查找元素 30
    auto it = std::find(vec.begin(), vec.end(), 30);

    if (it != vec.end()) {
        std::cout << "找到了元素: " << *it << std::endl;
    } else {
        std::cout << "没有找到元素!" << std::endl;
    }

    return 0;
}

`6.6 reverse`

reverse 是 C++ 标准库中的一个算法，用于反转容器中的元素。它会直接修改容器中的顺序，使元素的顺序从尾到头反转。

#include <iostream>
#include <vector>
#include <algorithm>  // reverse 函数需要包含此头文件

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};

    // 反转 vector 中的元素
    std::reverse(vec.begin(), vec.end());

    // 输出反转后的 vector
    std::cout << "反转后的元素：" << std::endl;
    for (const int& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

7. 文件操作函数

fstream：文件输入输出流。
ifstream：输入文件流。
ofstream：输出文件流。

// 文件操作函数
#include <fstream>
#include <iostream>
using namespace std;
int main() {
    ofstream outFile("example.txt");  // 创建并打开文件
    outFile << "Hello, file!" << endl;
    outFile.close();  // 关闭文件
    return 0;
}

8. 智能指针（C++11及以上）

shared_ptr：共享指针，多个指针共享同一对象的所有权。
unique_ptr：独占指针，一个指针拥有对象的所有权。
weak_ptr：弱引用指针，不会影响对象的生命周期。

// 智能指针（C++11及以上）
#include <memory>
#include <iostream>
using namespace std;
int main() {
    shared_ptr<int> p1 = make_shared<int>(10);  // 使用智能指针
    cout << *p1 << endl;
    return 0;
}