<iostream>
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| cin | istream& cin(istream& is); | 从标准输入读取数据 |
| cout | ostream& cout(ostream& os); | 向标准输出写入数据 |
| cerr | ostream& cerr(ostream& os); | 向标准错误输出写入数据 |
| istream | 用于从输入流读取数据 | |
| ostream | 用于向输出流写入数据 | |
| fstream | 用于读写文件流 | |
| strstream | 用于处理字符串流 | |
| stringstream | 用于处理字符串流，提供了方便的字符串操作 | |
| wistream | 用于从宽字符输入流读取数据 | |
| wostream | 用于向宽字符输出流写入数据 | |
| wfstream | 用于读写宽字符文件流 | |
| wstringstream | 用于处理宽字符字符串流，提供了方便的宽字符字符串操作 |
<string>
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| size() | size_type size() const; | 获取字符串长度 |
| substr() | string substr(size_type pos = 0, size_type len = npos) const; | 获取字符串子串 |
| find() | size_type find(const string& str, size_type pos = 0) const; size_type find(const char* s, size_type pos = 0) const; size_type find(char c, size_type pos = 0) const; |
查找子串或字符的位置 |
| append() | string& append(const string& str); string& append(const char* s); string& append(size_type n, char c); |
向字符串追加内容 |
| replace() | string& replace(size_type pos, size_type len, const string& str); string& replace(size_type pos, size_type len, const char* s); string& replace(size_type pos, size_type len, size_type n, char c); |
替换字符串中的子串或字符 |
| erase() | string& erase(size_type pos = 0, size_type len = npos); | 删除字符串中的子串或字符 |
| insert() | string& insert(size_type pos, const string& str); string& insert(size_type pos, const char* s); string& insert(size_type pos, size_type n, char c); |
在指定位置插入子串或字符 |
| operator+ | string operator+(const string& str); string operator+(const char* s); |
连接两个字符串 |
| operator+= | string& operator+=(const string& str); string& operator+=(const char* s); |
将字符串追加到当前字符串 |
<vector>
在C++98标准库中，vector是一个动态数组类模板，用于存储同类型的元素集合。以下是vector库中一些常用函数和类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| push_back() | void push_back(const value_type& val); void push_back(value_type&& val); |
向容器末尾添加元素 |
| pop_back() | void pop_back(); | 删除容器末尾的元素 |
| insert() | iterator insert(iterator pos, const value_type& val); iterator insert(iterator pos, value_type&& val); |
在指定位置插入元素 |
| erase() | iterator erase(iterator pos); iterator erase(iterator first, iterator last); |
删除指定位置的元素 |
| resize() | void resize(size_type n); void resize(size_type n, const value_type& val); |
调整容器大小 |
| clear() | void clear(); | 清空容器 |
| swap() | void swap (vector& other); | 与另一个vector交换内容 |
| resize() | void resize (size_type n, const T& val = T()); | 调整vector的大小为n个元素，并用指定值填充新元素 |
// 构造函数
vector<T> () : vector() {
} // 默认构造函数
vector<T> (size_type n) : vector(n) {
} // 大小为n的构造函数
vector<T> (size_type n, const T& val) : vector(n, val) {
} // 大小为n，值为val的构造函数
template <class InputIterator> vector (InputIterator first, InputIterator last) : vector (first, last - first) {
} // 从迭代器范围构造的构造函数
// 成员函数
void push_back (const T& val); // 向vector末尾添加一个元素
void pop_back (); // 删除vector末尾的元素
void clear () ; // 清空vector
void resize (size_type n, const T& val = T()); // 调整vector的大小为n个元素，并用指定值填充新元素
void insert (iterator pos, const T& val); // 在指定位置插入一个元素
void erase (iterator pos); // 删除指定位置的元素
void erase (iterator first, iterator last); // 删除指定范围内的元素
void swap (vector& other); // 与另一个vector交换内容
T& operator[] (size_type pos); // 通过索引访问元素，读写操作都可以用
T& at (size_type pos); // 通过索引访问元素，但增加了越界检查，读写操作都可以用
T* data (); // 返回指向vector内部数据的指针
size_type：表示元素数量的类型。
difference_type：表示迭代器之间的差值的类型。
value_type：表示存储在vector中的元素类型。
iterator：指向vector中元素的迭代器类型。
const_iterator：指向const vector中元素的常量迭代器类型。
reverse_iterator：指向vector中元素的反向迭代器类型。
const_reverse_iterator：指向const vector中元素的常量反向迭代器类型。
allocator_type：表示分配器的类型。
pointer：指向元素的指针类型。
reference：指向元素的引用类型。
bool：表示是否为空的布尔类型。
size()：返回vector中元素的数量。
capacity()：返回vector的容量（即可以容纳的元素数量）。
empty()：检查vector是否为空。
front()：返回指向vector第一个元素的指针。
back()：返回指向vector最后一个元素的指针。
data()：返回指向vector内部数据的指针。
<list>
在C++98标准库中，list是一个双向链表类模板，用于存储同类型的元素集合。以下是list库中一些常用函数和类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| push_back() | void push_back(const T& val); | 向list末尾添加一个元素 |
| pop_back() | void pop_back(); | 删除list末尾的元素 |
| clear() | void clear () ; | 清空list |
| resize() | void resize (size_type n, const T& val = T()); | 调整list的大小为n个元素，并用指定值填充新元素 |
| insert() | void insert (iterator pos, const T& val); | 在指定位置插入一个元素 |
| erase() | void erase (iterator pos); | 删除指定位置的元素 |
| erase() | void erase (iterator first, iterator last); | 删除指定范围内的元素 |
| swap() | void swap(list& other); | 与另一个list交换内容 |
| T& operator[] (size_type pos); | 通过索引访问元素，读写操作都可以用 |
// 构造函数
list<T> () : list() {
} // 默认构造函数
list<T> (size_type n) : list(n) {
} // 大小为n的构造函数
list<T> (size_type n, const T& val) : list(n, val) {
} // 大小为n，值为val的构造函数
template <class InputIterator> list (InputIterator first, InputIterator last) : list (first, last - first) {
} // 从迭代器范围构造的构造函数
// 成员函数
void push_back (const T& val); // 向list末尾添加一个元素
void pop_back (); // 删除list末尾的元素
void clear () ; // 清空list
void resize (size_type n, const T& val = T()); // 调整list的大小为n个元素，并用指定值填充新元素
void insert (iterator pos, const T& val); // 在指定位置插入一个元素
void erase (iterator pos); // 删除指定位置的元素
void erase (iterator first, iterator last); // 删除指定范围内的元素
void swap (list& other); // 与另一个list交换内容
T& front(); // 返回指向list第一个元素的引用
T& back(); // 返回指向list最后一个元素的引用
const T& front() const; // 返回指向list第一个元素的常量引用（const版本）
const T& back() const; // 返回指向list最后一个元素的常量引用（const版本）
T& at (size_type pos); // 通过索引访问元素，读写操作都可以用
T& operator[] (size_type pos); // 通过索引访问元素，读写操作都可以用
// 迭代器函数
iterator begin(); // 返回指向list第一个元素的迭代器
iterator end(); // 返回指向list末尾的迭代器
const_iterator begin() const; // 返回指向list第一个元素的常量迭代器（const版本）
const_iterator end() const; // 返回指向list末尾的常量迭代器（const版本）
reverse_iterator rbegin(); // 返回指向list最后一个元素的反向迭代器
reverse_iterator rend(); // 返回指向list末尾的反向迭代器
const_reverse_iterator rbegin() const; // 返回指向list最后一个元素的常量反向迭代器（const版本）
const_reverse_iterator rend() const; // 返回指向list末尾的常量反向迭代器（const版本）
size_type：表示元素数量的类型。
difference_type：表示迭代器之间的差值的类型。
value_type：表示存储在list中的元素类型。
iterator：指向list中元素的迭代器类型。
const_iterator：指向const list中元素的常量迭代器类型。
reverse_iterator：指向list中元素的反向迭代器类型。
const_reverse_iterator：指向const list中元素的常量反向迭代器类型。
allocator_type：表示分配器的类型。
pointer：指向元素的指针类型。
reference：指向元素的引用类型。
bool：表示是否为空的布尔类型。
size()：返回list中元素的数量。
capacity()：返回list的容量（即可以容纳的元素数量）。
empty()：检查list是否为空。
<deque>
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| push_front() | void push_front(const T& val); | 在deque前端添加一个元素 |
| push_back() | void push_back (const T& val); | 在deque后端添加一个元素 |
| pop_front() | void pop_front (); | 删除deque前端的最前元素 |
| pop_back() | void pop_back (); | 删除deque后端的最后元素 |
| clear() | void clear () ; | 清空deque |
| resize() | void resize (size_type n, const T& val = T()); | 调整deque的大小为n个元素，并用指定值填充新元素 |
| insert() | void insert (iterator pos, const T& val); | 在指定位置插入一个元素 |
| erase() | void erase (iterator pos); | 删除指定位置的元素 |
| erase() | void erase (iterator first, iterator last); | 删除指定范围内的元素 |
| swap() | void swap (deque& other); | 与另一个deque交换内容 |
// 构造函数
deque<T> () : deque() {
} // 默认构造函数
deque<T> (size_type n) : deque(n) {
} // 大小为n的构造函数
deque<T> (size_type n, const T& val) : deque(n, val) {
} // 大小为n，值为val的构造函数
template <class InputIterator> deque (InputIterator first, InputIterator last) : deque (first, last - first) {
} // 从迭代器范围构造的构造函数
// 成员函数
void push_front (const T& val); // 在deque前端添加一个元素
void push_back (const T& val); // 在deque后端添加一个元素
void pop_front (); // 删除deque前端的最前元素
void pop_back (); // 删除deque后端的最后元素
void clear () ; // 清空deque
void resize (size_type n, const T& val = T()); // 调整deque的大小为n个元素，并用指定值填充新元素
void insert (iterator pos, const T& val); // 在指定位置插入一个元素
void erase (iterator pos); // 删除指定位置的元素
void erase (iterator first, iterator last); // 删除指定范围内的元素
void swap (deque& other); // 与另一个deque交换内容
T& at (size_type pos); // 通过索引访问元素，读写操作都可以用
T& operator[] (size_type pos); // 通过索引访问元素，读写操作都可以用
| 类成员变量 |
size_type：表示元素数量的类型。
difference_type：表示迭代器之间的差值的类型。
value_type：表示存储在deque中的元素类型。
iterator：指向deque中元素的迭代器类型。
const_iterator：指向const deque中元素的常量迭代器类型。
reverse_iterator：指向deque中元素的反向迭代器类型。
const_reverse_iterator：指向const deque中元素的常量反向迭代器类型。
allocator_type：表示分配器的类型。
pointer：指向元素的指针类型。
reference：指向元素的引用类型。
bool：表示是否为空的布尔类型。
size()：返回deque中元素的数量。
capacity()：返回deque的容量（即可以容纳的元素数量）。
empty()：检查deque是否为空。
<set>
在C++98标准库中，set是一个集合类模板，用于存储唯一元素的集合。以下是set库中一些常用函数和类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
// 构造函数
set<T> () : set() {
} // 默认构造函数
set<T> (const set<T>& other) : set(other) {
} // 复制构造函数
set<T> (const vector<T>& vec) : set(vec.begin(), vec.end()) {
} // 从vector构造的构造函数
// 成员函数
void insert (const T& val); // 在set中插入一个元素
void remove (const T& val); // 从set中删除一个元素
void clear () ; // 清空set
bool contains (const T& val) const; // 检查set中是否包含指定元素
size_type count (const T& val) const; // 返回set中指定元素的个数
bool empty () const; // 检查set是否为空
size_type size () const; // 返回set中元素的数量
| 类成员变量 |
size_type：表示元素数量的类型。
difference_type：表示迭代器之间的差值的类型。
value_type：表示存储在set中的元素类型。
iterator：指向set中元素的迭代器类型。
const_iterator：指向const set中元素的常量迭代器类型。
reverse_iterator：指向set中元素的反向迭代器类型。
const_reverse_iterator：指向const set中元素的常量反向迭代器类型。
allocator_type：表示分配器的类型。
pointer：指向元素的指针类型。
reference：指向元素的引用类型。
bool：表示是否为空的布尔类型。
size()：返回set中元素的数量。
empty()：检查set是否为空。
注意：在C++98标准库中，set类的成员函数相对较少，主要是插入、删除和检查元素的操作。另外，C++98标准库中的set类不允许使用下标运算符([])来访问元素，只能使用迭代器来访问。
<map>
在C++98标准库中，map是一个关联容器，它存储了键值对（key-value pairs），其中每个键都唯一对应一个值。以下是map库中一些常用函数和类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
#include <map>
// 类型声明
template <class Key, class T, class Compare = std::less<Key>,
class Allocator = std::allocator<std::pair<const Key, T> > >
class map;
// 类模板特化
template <class Key, class T, class Compare, class Allocator>
bool operator==(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
template <class Key, class T, class Compare, class Allocator>
bool operator<(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
template <class Key, class T, class Compare, class Allocator>
bool operator!=(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
template <class Key, class T, class Compare, class Allocator>
bool operator>(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
template <class Key, class T, class Compare, class Allocator>
bool operator>=(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
template <class Key, class T, class Compare, class Allocator>
bool operator<=(const map<Key, T, Compare, Allocator>& x,
const map<Key, T, Compare, Allocator>& y);
// 函数
template <class Key, class T, class Compare, class Allocator>
void swap(map<Key, T, Compare, Allocator>& x,
map<Key, T, Compare, Allocator>& y);
// 类成员函数
template <class Key, class T, class Compare, class Allocator>
class map {
public:
// 类型定义
typedef Key key_type;
typedef T mapped_type;
typedef std::pair<const Key, T> value_type;
typedef Compare key_compare;
typedef Allocator allocator_type;
typedef typename Allocator::reference reference;
typedef typename Allocator::const_reference const_reference;
typedef typename Allocator::pointer pointer;
typedef typename Allocator::const_pointer const_pointer;
typedef typename Allocator::size_type size_type;
typedef typename Allocator::difference_type difference_type;
typedef typename Allocator::template rebind<value_type>::other
pair_allocator_type;
typedef typename std::allocator_traits<Allocator>::
template rebind_alloc<value_type> allocator_type;
class value_compare;
// 构造函数
explicit map(const Compare& comp = Compare(),
const Allocator& alloc = Allocator());
template <class InputIterator>
map(InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Allocator& alloc = Allocator());
map(const map& x);
// 析构函数
~map();
// 赋值运算符
map& operator=(const map& x);
// 迭代器
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
// 容量
bool empty() const;
size_type size() const;
size_type max_size() const;
// 修改容器
std::pair<iterator,bool> insert(const value_type& x);
iterator insert(iterator position, const value_type& x);
template <class InputIterator>
void insert(InputIterator first, InputIterator last);
void erase(iterator position);
size_type erase(const key_type& x);
void erase(iterator first, iterator last);
void swap(map& x);
void clear();
// 查找
iterator find(const key_type& x);
const_iterator find(const key_type& x) const;
size_type count(const key_type& x) const;
iterator lower_bound(const key_type& x);
const_iterator lower_bound(const key_type& x) const;
iterator upper_bound(const key_type& x);
const_iterator upper_bound(const key_type& x) const;
std::pair<iterator, iterator> equal_range(const key_type& x);
std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
// 运算符
T& operator[](const key_type& x);
// 观察器
key_compare key_comp() const;
value_compare value_comp() const;
allocator_type get_allocator() const;
private:
// 内部类和函数声明
// 节点
struct _Rb_tree_node;
typedef typename Allocator::template rebind<_Rb_tree_node>::other
_Node_allocator_type;
typedef typename _Node_allocator_type::pointer _Node_ptr;
typedef typename _Node_allocator_type::const_pointer
_Const_node_ptr;
enum _Rb_tree_color {
_S_rb_tree_red = false, _S_rb_tree_black = true };
// 红黑树节点
struct _Rb_tree_node {
typedef _Rb_tree_color _Color_type;
typedef _Rb_tree_node* _Base_ptr;
typedef _Rb_tree_node* _Link_type;
_Color_type _M_color;
_Link_type _M_parent;
_Link_type _M_left; // 左子节点或父节点
_Link_type _M_right; // 右子节点或父节点
value_type _M_value_field;
};
typedef simple_allocator<_Rb_tree_node, _Node_allocator_type>
_M_node_allocator_type;
typedef _Rb_tree_node* _Base_ptr;
typedef const _Rb_tree_node* _Const_Base_ptr;
// 红黑树
class _Rb_tree;
// 迭代器
class iterator;
class const_iterator;
class reverse_iterator;
class const_reverse_iterator;
};
这些是C++98标准中 std::map库的所有函数和类的原型声明。其中包括了类的类型定义、构造函数、析构函数、赋值运算符、迭代器、容量、修改容器、查找、运算符和观察器等函数。同时还有类模板特化、全局函数比较运算符和 swap函数等。
在C++98标准中，std::multimap是存在于<map>库中的。<map>库提供了关联式容器，允许存储键值对，并能够通过键进行快速查找。
std::multimap是一个多重映射容器，它允许存储多个具有相同键的键值对。以下是一些常用的成员函数和成员变量：
class multimap {
public:
// 构造函数
multimap();
explicit multimap(const Compare& comp = Compare(),
const Allocator& = Allocator());
template <class InputIterator>
multimap(InputIterator first, InputIterator last);
template <class InputIterator>
multimap(InputIterator first, InputIterator last,
const Compare& comp,
const Allocator& = Allocator());
// 复制构造函数
multimap(const multimap& x);
// 析构函数
~multimap();
// 赋值运算符
multimap& operator=(const multimap& x);
// 迭代器
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
// 容量
bool empty() const;
size_type size() const;
size_type max_size() const;
// 修改容器
void insert(const value_type& x);
iterator insert(iterator position, const value_type& x);
template <class InputIterator>
void insert(InputIterator first, InputIterator last);
void erase(iterator position);
size_type erase(const key_type& x);
void erase(iterator first, iterator last);
void swap(multimap& x);
void clear();
// 查找
iterator find(const key_type& x);
const_iterator find(const key_type& x) const;
size_type count(const key_type& x) const;
iterator lower_bound(const key_type& x);
const_iterator lower_bound(const key_type& x) const;
iterator upper_bound(const key_type& x);
const_iterator upper_bound(const key_type& x) const;
std::pair<iterator, iterator> equal_range(const key_type& x);
std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
// 运算符
compare_key key_comp() const;
value_compare value_comp() const;
// 其他
allocator_type get_allocator() const;
};
这些是C++98标准中 std::multimap类的所有成员函数声明。其中包括了容器的构造函数、复制构造函数、析构函数、赋值运算符、迭代器、容量、修改容器、查找、运算符和其他函数。
<algorithm>
在C++98标准库中，algorithm库提供了许多常用的算法函数，用于对数据进行各种操作。由于algorithm库中的函数数量庞大，这里只列举其中一些常用的函数原型声明，以及一些关键的类和成员函数的原型。
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| find() | template <class InputIterator, class T> InputIterator find (InputIterator first, InputIterator last, const T& value); |
用于在容器中查找特定元素，返回指向找到的元素的迭代器 |
| sort() | template <class RandomIt> void sort (RandomIt first, RandomIt last); |
对容器中的元素进行排序 |
| reverse() | template <class BidirectionalIt> void reverse (BidirectionalIt first, BidirectionalIt last); |
反转容器中的元素 |
| replace() | template <class OutputIt, class InputIt1, class InputIt2> OutputIt replace (OutputIt d_first, OutputIt d_last, const InputIt1& s_first, const InputIt2& s_last); |
替换容器中特定元素为另一值 |
| find_if() | template <class InputIt, class UnaryPredicate> InputIt find_if (InputIt first, InputIt last, UnaryPredicate p); |
在容器中查找满足特定条件的第一个元素 |
| copy() | template <class InputIt, class OutputIt> OutputIt copy (InputIt first, InputIt last, OutputIt d_first); |
将一个容器中的元素复制到另一个容器中 |
| transfrom() | template <class InputIt1, class InputIt2, class OutputIt> OutputIt transform (InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first); |
对容器中的元素进行转换操作 |
| binary_search() | template <class BidirectionalIt, class T> bool binary_search (BidirectionalIt first, BidirectionalIt last, const T& value); |
在已排序的容器中执行二分查找 |
| next_permutation() | template <class BidirectionalIt> bool next_permutation (BidirectionalIt first, BidirectionalIt last); |
生成容器的下一个排列 |
| prev_permutation() | template bool prev_permutation (BidirectionalIt first, BidirectionalIt last); | 生成容器的上一个排列 |
| make_heap() | template <class RandomIt> void make_heap (RandomIt first, RandomIt last); |
将容器转换为堆 |
| sort_heap() | template <class RandomIt> void sort_heap (RandomIt first, RandomIt last); |
对堆进行排序 |
| pop_heap() | template <class RandomIt> void pop_heap (RandomIt first, RandomIt last); |
弹出堆顶元素 |
| remove() | template <class InputIt, class T> InputIt remove (InputIt first, InputIt last, const T& value); |
从容器中删除指定元素 |
| remove_if() | template <class InputIt, class UnaryPredicate> InputIt remove_if (InputIt first, InputIt last, UnaryPredicate p); |
从容器中删除满足特定条件的元素 |
这只是algorithm库中的一部分函数，还有许多其他函数可用于执行各种算法操作，如合并、排序、查找等。请注意，C++98标准库中的函数与C++11标准库中的函数之间存在一些差异，例如std::sort和std::find等函数在C++11中得到了改进和优化。
注意：C++98标准库中，并没有单独为algorithm库定义类或内部成员函数。上述函数主要依赖于模板编程技术，这些函数可以应用于各种不同的容器类型（如vector、list等）以及自定义的数据结构。函数的参数通常是迭代器，它们提供了对容器内部元素的间接访问。因此，没有特定的“引用类”或“内部成员函数”与algorithm库相关联。
<cmath>
在C++98标准库中，头文件提供了许多数学函数，用于执行各种数学运算。以下是一些常用函数的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| abs() | template <class T> T abs (T arg); |
返回参数的绝对值 |
| exp() | template <class T> T exp (T arg); |
计算参数的指数值 |
| log() | template <class T> T log (T arg); | 计算参数的自然对数值 |
| sin() | template <class T> T sin (T arg); |
计算参数的正弦值 |
| cos() | template <class T> T cos (T arg); |
计算参数的余弦值 |
| tan() | template <class T> T tan (T arg); |
计算参数的正切值 |
| ceil() | template <class T> T ceil (T arg); |
返回不小于参数的最小整数 |
| floor() | template <class T> T floor (T arg); |
返回不大于参数的最大整数 |
| sqrt() | template <class T> T sqrt (T arg); |
计算参数的平方根 |
| pow() | template <class T> T pow (T base, T exponent); |
计算参数的幂 |
| log10() | template <class T> T log10 (T arg); |
计算参数的以10为底的对数 |
| modf() | template <class T> pair<T, T> modf (T arg, T* iptr); |
将参数分解为整数和浮点数部分 |
| fmod() | template <class T> T fmod (T x, T y); |
计算参数的余数 |
| remainder() | template <class T> T remainder (T x, T y); |
计算参数的余数 |
| hypot() | template <class T> T hypot (T x, T y); |
计算参数的斜边的平方根 |
| acos() | template <class T> T acos (T arg); |
计算参数的反余弦值 |
| asin() | template <class T> T asin (T arg); |
计算参数的反正弦值 |
| atan() | template <class T> T atan (T arg); |
计算参数的反正切值 |
| atan2() | template <class T> atan2 (T y, T x); |
计算参数的四个象限反正切值 |
| trunc() | template <class T> T trunc (T arg); |
将参数截断为整数部分 |
<fstream>
在C++98标准库中，库提供了文件输入输出流的功能。以下是一些常用函数的原型声明和类：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| ifstream | 输入文件流 | |
| ofstream | 输出文件流 | |
| fstream | 输入/输出文件流 | |
| fopen() | FILE* fopen (const char* filename, const char* mode); | 打开一个文件 |
| fclose() | int fclose (FILE* stream); | 关闭一个文件 |
| fread() | size_t fread (void* ptr, size_t size, size_t count, FILE* stream); | 从文件中读取数据 |
| fwrite() | size_t fwrite (const void* ptr, size_t size, size_t count, FILE* stream); | 向文件中写入数据 |
| fflush() | int fflush (FILE* stream); | 刷新一个文件 |
| fseek() | int fseek (FILE* stream, long offset, int whence); | 设置文件的读取/写入位置 |
| ftell() | long ftell (FILE* stream); | 获取当前文件的读取/写入位置 |
| rewind() | void rewind (FILE* stream); | 重置文件的读取/写入位置到文件的开头 |
| fgetc() | int fgetc (FILE* stream); | 从文件中读取一个字符 |
| fgets() | char* fgets (char* str, int num, FILE* stream); | 从文件中读取一行数据 |
| fputc() | int fputc (int c, FILE* stream); | 向文件中写入一个字符 |
| fputs() | int fputs (int c, FILE* stream); | 向文件中写入一行数据 |
| feof() | int feof (FILE* stream); | 检查是否到达文件的末尾 |
| ferror() | int ferror (FILE* stream); | 检查文件是否发生错误 |
| clearerr() | void clearerr (FILE* stream); | 清除文件的状态标志 |
| std::ifstream::open() | void open (const char* filename, ios_base::openmode mode = ios_base::in); | 打开一个输入文件 |
| std::ofstream::open() | void open (const char* filename, ios_base::openmode mode = ios_base::out); | 打开一个输出文件 |
| std::fstream::open() | void open (const char* filename, ios_base::openmode mode = ios_base::in | ios_base::out); | 打开一个输入/输出文件 |
| 9 | ||
| std::ifstream::read() | template <class T> streamsize read (T* s, streamsize n); |
从输入文件读取数据 |
| std::ofstream::write() | template <class T> streamsize write (const T* s, streamsize n); |
向输出文件写入数据 |
| std::ifstream::close（） | void std::ifstream::close(); | 关闭输入文件流 |
| std::ofstream::close（） | void std::ofstream::close(); | 关闭输出文件流 |
| std::fstream::close（） | void std::fstream::close(); | 关闭输入/输出文件流 |
std::fstream::seekg: 设置输入文件流的读取位置。
std::fstream::seekp: 设置输出文件流的写入位置。
std::ifstream::eof: 检查是否到达输入文件的末尾。
std::ofstream::eof: 检查是否到达输出文件的末尾。
std::fstream::eof: 检查是否到达输入/输出文件的末尾。
std::ifstream::fail: 检查输入操作是否失败。
std::ofstream::fail: 检查输出操作是否失败。
std::fstream::fail: 检查输入/输出操作是否失败。
std::ifstream::clear: 清除输入错误的标志位。
std::ofstream::clear: 清除输出错误的标志位。
std::fstream::clear: 清除输入/输出错误的标志位。
std::ifstream::width: 设置或获取字段宽度。
std::ofstream::width: 设置或获取字段宽度。
std::fstream::width: 设置或获取字段宽度。
std::ifstream::setprecision: 设置或获取精度值。
std::ofstream::setprecision: 设置或获取精度值。
std::fstream::setprecision: 设置或获取精度值。
<bitset>
在C++98标准库中，bitset是标准库中的一部分，包含在头文件中。bitset是一个特殊的容器类，用于处理固定大小的位序列。以下是bitset类的部分成员函数和成员变量：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| bitset() | explicit bitset(size_t num_bits = 0); | |
| bitset() | bitset(); | 默认构造函数 |
| bitset() | bitset(size_t n, unsigned long val = 0); | 创建一个n位的bitset，并将所有位初始化为val的构造函数 |
| bitset(const bitset& other); | 拷贝构造函数 | |
| ~bitset(); | 析构函数 | |
| size() | size_t size() const; | 返回bitset的大小 |
| num_bits() | size_t num_bits() const; | 返回bitset中位的数量 |
| any() | bool any() const; | 如果bitset中至少有一个位为1，则返回true |
| none() | bool none() const; | 如果bitset中所有位都为0，则返回true |
| count() | size_t count() const; | 返回bitset中为1的位的数量 |
| max() | size_t max() const; | 返回bitset中可以设置的最大位值 |
| reset() | void reset(); | 将bitset的所有位重置为0 |
| filp() | void flip(); | 翻转bitset的所有位 |
| size_t& operator[](size_t i); | 访问或修改bitset中的特定位，下标从0开始。例如，bitset[i] = val 或者 val = bitset[i] | |
| test() | bool test(size_t i) const; | 检查bitset中的特定位是否为1，下标从0开始。例如，if (bitset[i]) ... 或者 if (!bitset[i]) ... |
| void set(size_t i); | 设置bitset中的特定位为1，下标从0开始。例如，bitset[i] = true 或者 bitset[i] = val | |
| reset() | void reset(size_t i); | 设置bitset中的特定位为0，下标从0开始。例如，bitset[i] = false 或者 bitset[i] = val (val为0) |
| filp() | void flip(size_t i); | 翻转bitset中的特定位，下标从0开始。例如，bitset[i] = ~bitset[i] 或者 bitset[i] = val (val为1或0) |
| bitset<N>& set(); | 返回一个对当前bitset对象的引用 | |
| bitset<N>& set(size_t pos, bool value = true); | 设置bitset中索引为pos的位为给定的bool值（默认为true） | |
| bitset<N>& reset(); | 将bitset中的所有位重置为0 | |
| bitset<N>& reset(size_t pos); | 将bitset中索引为pos的位重置为0 | |
| bitset<N>& flip(); | 翻转bitset中的所有位 | |
| bitset<N>& flip(size_t pos); | 翻转bitset中索引为pos的位 | |
| unsigned long to_ulong() const; | 将bitset的内容转换为一个无符号长整型值。如果bitset的大小超过无符号长整型的位数，则结果可能不正确 | |
| std::string to_string() const; | 将bitset的内容转换为一个字符串表示形式 | |
| bitset<N>& operator=(const bitset& other); | 将一个bitset对象赋值给另一个bitset对象 | |
| bool operator[](size_t pos) const; | 用于访问bitset中索引为pos的位。如果该位为1，则返回true；否则返回false | |
| bitset<N>& operator&=(const bitset& other); | 按位与操作符的重载，用于对两个bitset对象进行按位与操作 | |
| bitset<N>& operator|=(const bitset& other); | 按位或操作符的重载，用于对两个bitset对象进行按位或操作 | |
| bitset<N>& operator^=(const bitset& other); | 按位异或操作符的重载，用于对两个bitset对象进行按位异或操作 | |
| bitset<N> operator~() const; | 按位求反操作符的重载，用于对一个bitset对象进行按位求反操作 | |
| 其中，N表示 bitset的大小（位数） | ||
| 吾近染风寒，力不从心，此篇文章暂停更新 [24.01.17 15:58] |
<exception>
在C++98标准库中，exception库是标准库的一部分，用于处理异常。以下是exception库中一些重要函数和类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<stdexcept>
在C++98标准库中，<stdexcept>头文件提供了标准异常类，这些类位于std命名空间中。以下是库中一些常用异常类的原型声明：
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<locale>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<numeric>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<functional>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<iterator>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<utility>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<ctime>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<iomanip>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<limits>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<random>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |
<bit>
在C++98标准库中，
| 类Or函数 | 原型 | 含义 |
|---|---|---|
| 1 | ||
| 2 | ||
| 3 | ||
| 4 | ||
| 5 | ||
| 6 | ||
| 7 | ||
| 8 | ||
| 9 |