c++常用库及函数

正在努力zhong

已于 2024-07-08 17:27:58 修改

阅读量1k

点赞数 20

文章标签： c++

于 2024-07-08 17:08:44 首次发布

本文链接：https://blog.csdn.net/jia6464/article/details/140273620

版权

c++常用库及函数

本文整理了一些作者认为c++比较常用的库及函数，整理的有点杂乱，请各位读者见谅，后续会继续更新本文

<cmath>

序号	函数 & 描述
1	double cos(double); 该函数返回弧度角（double 型）的余弦。
2	double sin(double); 该函数返回弧度角（double 型）的正弦。
3	double tan(double); 该函数返回弧度角（double 型）的正切。
4	double log(double); 该函数返回参数的自然对数。
5	double pow(double, double); 假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。
6	double hypot(double, double); 该函数返回两个参数的平方总和的平方根，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。
7	double sqrt(double); 该函数返回参数的平方根。
8	int abs(int); 该函数返回整数的绝对值。
9	double fabs(double); 该函数返回任意一个浮点数的绝对值。
10	double floor(double); 该函数返回一个小于或等于传入参数的最大整数。

<vector>

基本特性:

动态大小：vector 的大小可以根据需要自动增长和缩小。
连续存储：vector 中的元素在内存中是连续存储的，这使得访问元素非常快速。
可迭代：vector 可以被迭代，你可以使用循环（如 for 循环）来访问它的元素。
元素类型：vector 可以存储任何类型的元素，包括内置类型、对象、指针等。

创建 Vector

创建一个 vector 可以像创建其他变量一样简单：

std::vector<int> myVector; // 创建一个存储整数的空 vector

这将创建一个空的整数向量,也可以在创建时指定初始大小和初始值：

std::vector<int> myVector(5); // 创建一个包含 5 个整数的 vector，每个值都为默认值（0）
std::vector<int> myVector(5, 10); // 创建一个包含 5 个整数的 vector，每个值都为 10

或：

std::vector<int> vec; // 默认初始化一个空的 vector
std::vector<int> vec2 = {1, 2, 3, 4}; // 初始化一个包含元素的 vector

添加元素

可以使用 push_back 方法向 vector 中添加元素：

myVector.push_back(7); // 将整数 7 添加到 vector 的末尾

访问元素

可以使用下标操作符 [] 或 at() 方法访问 vector 中的元素：

int x = myVector[0]; // 获取第一个元素
int y = myVector.at(1); // 获取第二个元素

v.back() 返回 v 中最后一个元素的引用

v.front() 返回 v 中第一个元素的引用

获取大小

可以使用 size() 方法获取 vector 中元素的数量：

int size = myVector.size(); // 获取 vector 中的元素数量

迭代访问

可以使用迭代器遍历 vector 中的元素：

for (auto it = myVector.begin(); it != myVector.end(); ++it) {
    std::cout << *it << " ";
}

或者使用范围循环：

for (int element : myVector) {
    std::cout << element << " ";
}

删除元素

可以使用 erase() 方法删除 vector 中的元素：

myVector.erase(myVector.begin() + 2); // 删除第三个元素

pop_back()删除尾元素

清空 Vector

可以使用 clear() 方法清空 vector 中的所有元素：

myVector.clear(); // 清空 vector

<iostream>

标准的输入输出操作如cin或cout就不再这里赘述了

主要类

std::istream：用于输入操作的抽象基类。
std::ostream：用于输出操作的抽象基类。
std::iostream：继承自std::istream和std::ostream，用于同时进行输入和输出操作。
std::cin：标准输入流对象，通常与键盘关联。
std::cout：标准输出流对象，通常与屏幕关联。
std::cerr：标准错误输出流对象，不带缓冲，通常与屏幕关联。
std::clog：标准日志流对象，带缓冲，通常与屏幕关联。

常用操作符

>>：输入操作符，从输入流读取数据。
<<：输出操作符，将数据写入输出流。

流的状态检查:

可以检查输入输出流的状态，以确定操作是否成功。

#include <iostream>

int main() {
  int num;
  std::cout << "Enter a number: ";
  std::cin >> num;

  // 检查输入操作是否成功
  if (std::cin.fail()) {
    std::cerr << "Invalid input!" << std::endl;
  } else {
    std::cout << "You entered: " << num << std::endl;
  }

  return 0;
}

处理字符串输入

使用std::getline函数可以读取包含空格的整行输入。

#include <iostream>
#include <string>

int main() {
  std::string fullName;
  std::cout << "Enter your full name: ";
  std::getline(std::cin, fullName);
  std::cout << "Hello, " << fullName << "!" << std::endl;

  return 0;
}

<sstream>

sstream 是 C++ 标准库中的一个组件，它提供了一种方便的方式来处理字符串流（可以像处理流一样处理字符串）。

<sstream> 允许你将字符串当作输入/输出流来使用，这使得从字符串中读取数据或将数据写入字符串变得非常简单。

定义

sstream是 C++ 标准库中的一个命名空间，它包含了几个类，用于处理字符串流，这些类包括：

istringstream：用于从字符串中读取数据。
ostringstream：用于将数据写入字符串。
stringstream：是istringstream和ostringstream的组合，可以同时进行读取和写入操作。

从字符串读取数据

下面是一个使用 istringstream 从字符串中读取整数和浮点数的例子：

#include <iostream>
#include <sstream>

int main() {
  std::string data = "10 20.5";
  std::istringstream iss(data);

  int i;
  double d;

  iss >> i >> d;

  std::cout << "Integer: " << i << std::endl;
  std::cout << "Double: " << d << std::endl;

  return 0;
}

输出结果：

Integer: 10
Double: 20.5

向字符串写入数据

下面是一个使用 ostringstream 将数据写入字符串的例子：

#include <iostream>
#include <sstream>

int main() {
  std::ostringstream oss;
  int i = 100;
  double d = 200.5;

  oss << i << " " << d;

  std::string result = oss.str();
  std::cout << "Resulting string: " << result << std::endl;

  return 0;
}

输出结果：

Resulting string: 100 200.5

使用stringstream进行读写操作

下面是一个使用 stringstream 同时进行读取和写入操作的例子：

#include <iostream>
#include <sstream>

int main() {
  std::string data = "30 40.5";
  std::stringstream ss(data);

  int i;
  double d;

  // 从stringstream读取数据
  ss >> i >> d;

  std::cout << "Read Integer: " << i << ", Double: " << d << std::endl;

  // 向stringstream写入数据
  ss.str(""); // 清空stringstream
  ss << "New data: " << 50 << " " << 60.7;

  std::string newData = ss.str();
  std::cout << "New data string: " << newData << std::endl;

  return 0;
}

输出结果：

Read Integer: 30, Double: 40.5
New data string: New data: 50 60.7

<list>

C++ 标准库提供了丰富的功能，其中 <list> 是一个非常重要的容器类，用于存储元素集合，支持双向迭代器。

<list> 是 C++ 标准模板库（STL）中的一个序列容器，它允许在容器的任意位置快速插入和删除元素。与数组或向量（<vector>）不同，<list> 不需要在创建时指定大小，并且可以在任何位置添加或删除元素，而不需要重新分配内存。

语法

以下是 <list> 容器的一些基本操作：

包含头文件：#include <list>
声明列表：std::list<T> mylist;，其中 T 是存储在列表中的元素类型。
插入元素：mylist.push_back(value);
删除元素：mylist.pop_back(); 或 mylist.erase(iterator);
访问元素：mylist.front(); 和 mylist.back();
遍历列表：使用迭代器 for (auto it = mylist.begin(); it != mylist.end(); ++it)

<stack>

在 C++ 中，标准库提供了多种容器和算法来帮助开发者更高效地编写程序。

<stack> 是 C++ 标准模板库（STL）的一部分，它实现了一个后进先出（LIFO，Last In First Out）的数据结构。这种数据结构非常适合于需要"最后添加的元素最先被移除"的场景。

<stack> 容器适配器提供了一个栈的接口，它基于其他容器（如 deque 或 vector）来实现。栈的元素是线性排列的，但只允许在一端（栈顶）进行添加和移除操作。

基本操作

push(): 在栈顶添加一个元素。
pop(): 移除栈顶元素。
top(): 返回栈顶元素的引用，但不移除它。
empty(): 检查栈是否为空。
size(): 返回栈中元素的数量。

<queue>

C++ 标准库中的 <queue> 头文件提供了队列（Queue）数据结构的实现。队列是一种先进先出（FIFO, First In First Out）的数据结构，它允许在一端添加元素（称为队尾），并在另一端移除元素（称为队首）。

队列是一种线性数据结构，它遵循以下规则：

元素只能从队尾添加。
元素只能从队首移除。

语法

在 C++ 中，队列的语法如下：

#include <queue>

// 声明队列
std::queue<Type> q;

这里 Type 是队列中存储元素的数据类型。

常用操作

队列提供了以下常用操作：

empty(): 检查队列是否为空。
size(): 返回队列中的元素数量。
front(): 返回队首元素的引用。
back(): 返回队尾元素的引用。
push(): 在队尾添加一个元素。
pop(): 移除队首元素。

<deque>

在 C++中，<deque> 是标准模板库（STL）的一部分，它提供了双端队列（double-ended queue）的实现。双端队列是一种允许在两端进行插入和删除操作的线性数据结构。<deque> 的全称是 “double-ended queue”，它在C++中以模板类的形式存在，允许存储任意类型的数据。

<deque> 是一个动态数组，它提供了快速的随机访问能力，同时允许在两端进行高效的插入和删除操作。这使得 <deque> 成为处理需要频繁插入和删除元素的场景的理想选择。

语法

在 C++ 中，使用 <deque> 需要包含头文件 #include <deque>。以下是 <deque> 的基本语法：

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque; // 创建一个整数类型的双端队列
    // 接下来可以进行插入、删除等操作
    return 0;
}

插入元素

push_back(): 在队列尾部添加一个元素。
push_front(): 在队列头部添加一个元素。

删除元素

pop_back(): 删除队列尾部的元素。
pop_front(): 删除队列头部的元素。

访问元素

使用下标运算符 [] 可以访问队列中的元素，例如 myDeque[0] 访问第一个元素。

其他操作

size(): 返回队列中的元素数量。
empty(): 检查队列是否为空。

<map>

在 C++ 中，<map> 是标准模板库（STL）的一部分，它提供了一种关联容器，用于存储键值对（key-value pairs）。

map 容器中的元素是按照键的顺序自动排序的，这使得它非常适合需要快速查找和有序数据的场景。

定义和特性

键值对：map 存储的是键值对，其中每个键都是唯一的。
排序：map 中的元素按照键的顺序自动排序，通常是升序。
唯一性：每个键在 map 中只能出现一次。
双向迭代器：map 提供了双向迭代器，可以向前和向后遍历元素。

基本语法

包含头文件:

#include <map>

声明 map 容器:

std::map<key_type, value_type> myMap;

key_type 是键的类型。
value_type 是值的类型。

插入元素:

myMap[key] = value;

访问元素:

value = myMap[key];

遍历 map:

for (std::map<key_type, value_type>::iterator it = myMap.begin(); it != myMap.end(); ++it) {
    std::cout << it->first << " => " << it->second << std::endl;
}

<unordered_map>

在 C++ 中，<unordered_map> 是标准模板库（STL）的一部分，提供了一种基于哈希表的键值对容器。

与 std::map 不同，unordered_map 不保证元素的排序，但通常提供更快的查找速度。

unordered_map 是一个关联容器，它存储了键值对（key-value pairs），其中每个键（key）都是唯一的。unordered_map 使用哈希表来存储元素，这使得它在查找、插入和删除操作中具有平均常数时间复杂度。

语法

以下是 unordered_map 的基本语法：

#include <unordered_map>

std::unordered_map<key_type, value_type> map_name;

key_type 是键的类型。
value_type 是值的类型。

构造函数

unordered_map 可以以多种方式构造：

// 默认构造
std::unordered_map<int, std::string> myMap;

// 构造并初始化
std::unordered_map<int, std::string> myMap = {{1, "one"}, {2, "two"}};

// 构造并指定初始容量
std::unordered_map<int, std::string> myMap(10);

// 构造并复制另一个 unordered_map
std::unordered_map<int, std::string> anotherMap = myMap;

基本操作

插入元素:

myMap.insert({3, "three"});

访问元素:

std::string value = myMap[1]; // 获取键为1的值

删除元素:

myMap.erase(1); // 删除键为1的元素

查找元素:

auto it = myMap.find(2); // 查找键为2的元素
if (it != myMap.end()) {
    std::cout << "Found: " << it->second << std::endl;
}

<set>

C++ 标准库中的 <set> 是一个关联容器，它存储了一组唯一的元素，并按照一定的顺序进行排序。

<set> 提供了高效的元素查找、插入和删除操作。它是基于红黑树实现的，因此具有对数时间复杂度的查找、插入和删除性能。

<set> 容器中存储的元素类型必须满足以下条件：

元素类型必须可以比较大小。
元素类型必须可以被复制和赋值。

语法

包含头文件:

#include <set>

声明 set 容器

std::set<元素类型> 容器名;

常用操作

insert(元素): 插入一个元素。
erase(元素): 删除一个元素。
find(元素): 查找一个元素。
size(): 返回容器中元素的数量。
empty(): 检查容器是否为空。

<string>

C++ 标准库（Standard Template Library, STL）是 C++ 的核心组成部分之一，提供了丰富的数据结构和算法。

<string> 是 C++ 标准库中用于处理字符串的头文件。

在 C++ 中，字符串是由字符组成的序列。<string> 头文件提供了 std::string 类，它是对 C 风格字符串的封装，提供了更安全、更易用的字符串操作功能。

要在 C++ 程序中使用 <string> 库，首先需要包含这个头文件：

#include <iostream>
#include <string>

基本语法

std::string 类的基本语法如下：

声明字符串变量：
```
std::string str;
```
初始化字符串：
```
std::string str = "Hello, World!";
```

使用 + 连接字符串：

std::string str1 = "Hello, ";
std::string str2 = "World!";
std::string result = str1 + str2;

常用成员函数

std::string 类提供了许多成员函数来操作字符串，以下是一些常用的成员函数：

size()：返回字符串的长度。
empty()：检查字符串是否为空。
operator[]：通过索引访问字符串中的字符。
substr()：获取子字符串。
find()：查找子字符串在主字符串中的位置。
replace()：替换字符串中的某些字符。

<algorithm>

C++ 标准库中的 <algorithm> 头文件提供了一组用于操作容器（如数组、向量、列表等）的算法。这些算法包括排序、搜索、复制、比较等，它们是编写高效、可重用代码的重要工具。

<algorithm> 头文件定义了一组模板函数，这些函数可以应用于任何类型的容器，只要容器支持迭代器。这些算法通常接受两个或更多的迭代器作为参数，表示操作的起始和结束位置。

语法

大多数 <algorithm> 中的函数都遵循以下基本语法：

algorithm_name(container.begin(), container.end(), ...);

这里的 container 是一个容器对象，begin() 和 end() 是容器的成员函数，返回指向容器开始和结束的迭代器。

1. 排序算法

函数：sort

定义：对容器中的元素进行排序。

语法：

sort(container.begin(), container.end(), compare_function);

其中 compare_function 是一个可选的比较函数，用于自定义排序方式。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {5, 2, 9, 1, 5, 6};
    std::sort(numbers.begin(), numbers.end());

    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;

}

2. 搜索算法

函数：find

定义：在容器中查找与给定值匹配的第一个元素。

语法：

auto it = find(container.begin(), container.end(), value);

如果找到，it 将指向匹配的元素；如果没有找到，it 将等于 container.end()。

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5};
  auto it = std::find(numbers.begin(), numbers.end(), 3);

  if (it != numbers.end()) {
    std::cout << "Found: " << *it << std::endl;
  } else {
    std::cout << "Value not found." << std::endl;
  }

  return 0;
}

3. 复制算法

函数：copy

定义：将一个范围内的元素复制到另一个容器或数组。

语法：

copy(source_begin, source_end, destination_begin);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> source = {1, 2, 3, 4, 5};
  int destination[5];
  std::copy(source.begin(), source.end(), destination);

  for (int i = 0; i < 5; ++i) {
    std::cout << destination[i] << " ";
  }
  std::cout << std::endl;

  return 0;
}

4. 比较算法

函数：equal

定义：比较两个容器或两个范围内的元素是否相等。

语法：

bool result = equal(first1, last1, first2);

或

bool result = equal(first1, last1, first2, compare_function);

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
  std::vector<int> v1 = {1, 2, 3, 4, 5};
  std::vector<int> v2 = {1, 2, 3, 4, 5};

  bool are_equal = std::equal(v1.begin(), v1.end(), v2.begin());
  std::cout << (are_equal ? "Vectors are equal." : "Vectors are not equal.") << std::endl;

  return 0;
}