C++常用函数合集

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

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

`1.1cin`

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

`1.2cout`

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

cpp 复制代码

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

cpp 复制代码

#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 风格字符串的长度（不包括空字符）。

cpp 复制代码

#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。
如果第一个字符串小于第二个字符串，返回负值。
如果第一个字符串大于第二个字符串，返回正值。

cpp 复制代码

#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> 头文件中。

cpp 复制代码

#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 风格字符串（即将第二个字符串附加到第一个字符串的末尾）。

cpp 复制代码

#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 类型。

cpp 复制代码

#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 是一个标准库函数，用于返回给定整数的绝对值，即无论输入是正数、负数还是零，返回一个非负的整数

cpp 复制代码

#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（不是一个数字）或导致运行时错误。

cpp 复制代码

#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> 头文件中。它有两个参数：底数和指数，返回底数的指数次幂（即底数的指数次方）。

cpp 复制代码

#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 的正切值。

cpp 复制代码

#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 的正切值。

cpp 复制代码

#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 为底的对数），它是数学中对数的常用形式。

cpp 复制代码

#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 的最大整数（即向下取整）。

cpp 复制代码

#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 类型的整数。

cpp 复制代码

#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 来获取时钟周期每秒的数量，进而换算为秒。

cpp 复制代码

#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 结构体。该结构体包含了如年、月、日、小时、分钟、秒等详细信息。

cpp 复制代码

#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 结构体中的时间数据进行格式化。

cpp 复制代码

#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 字节的内存。

cpp 复制代码

#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[] 来释放数组形式的内存。

cpp 复制代码

#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 的最后一个元素。

cpp 复制代码

#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() 删除指定的键值对。

cpp 复制代码

#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)）。

cpp 复制代码

#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++ 标准库中的排序算法，它用于对容器中的元素进行排序。默认情况下，它是按升序排序的，但也可以自定义排序规则。

cpp 复制代码

#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() 迭代器。

cpp 复制代码

#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++ 标准库中的一个算法，用于反转容器中的元素。它会直接修改容器中的顺序，使元素的顺序从尾到头反转。

cpp 复制代码

#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：输出文件流。

cpp 复制代码

// 文件操作函数
#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：弱引用指针，不会影响对象的生命周期。

cpp 复制代码

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

C++常用函数合集

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

1.1cin

1.2cout

1.3 cerr (标准错误流)

1.4 clog (日志流)

2. 字符串处理函数

2.1 strlen

2.2 strcmp

2.3 strcpy

2.4 strcat

2.5 stoi、stol、stof、stod

3. 数学函数

3.1 abs

3.2 sqrt

3.3 pow

3.4 sin、cos、tan

3.5 exp

3.6 log

3.7 ceil、floor

4. 时间与日期函数

4.1 time

4.2clock

4.3localtime

4.4strftime

5. 内存管理函数

5.1 malloc、calloc

5.2 free

5.3 new、delete

6. 容器和算法

6.1 vector

主要特点：

常用操作：

6.2 map

主要特点：

常用操作：

6.3 set

6.4 sort

6.5 find

6.6 reverse

7. 文件操作函数

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

`1.1cin`

`1.2cout`

1.3 `cerr` (标准错误流)

1.4 `clog` (日志流)

`2.1 strlen`

`2.2 strcmp`

`2.3 strcpy`

`2.4 strcat`

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

`3.1 abs`

`3.2 sqrt`

`3.3 pow`

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

`3.5 exp`

`3.6 log`

`3.7 ceil`、`floor`

`4.1 time`

`4.2clock`

`4.3localtime`

`4.4strftime`

`5.1 malloc`、`calloc`

`5.2 free`

`5.3 new`、`delete`

`6.1 vector`

`6.2 map`

`6.3 set`

`6.4 sort`

`6.5 find`

`6.6 reverse`