template <typename T>
struct allocator;

allocator();
allocator(const allocator& other);
~allocator();

// Выделяет память для массива из n объектов типа T, возвращает указатель на первый элемент.
T* allocate(size_t n);

// Освобождает выделенную память для массива, указанный указатель p должен быть получен с помощью вызова allocate, а n — параметром этого вызова.
void deallocate(T* p, size_t n);

// Конструирует объект типа T в указанной памяти, которая ещё не была инициализирована.
void construct(T* p, const T& val);

// Разрушает объект, хранящийся по адресу p.
void destroy(T* p);

class Ctemp {
public:
    int a;
    char ch;
};
``````markdown
## `<iostream.h>`
Содержимое переадресовано на STL `iostream`.

## `c3::reverse_iterator` @ `<iterator.h>`
Переадресовано на `std::reverse_iterator`.

## `c3::basic_string` @ `<string.h>`

Шаблон:
```cpp
template <
    typename CharT,   // тип символов строки
    typename Allocator = c3::allocator<CharT> // используемый тип аллокатора
> class basic_string;

iterator( CharT* p = nullptr );
CharT operator*() const;
CharT* operator->() const;
iterator& operator++();
iterator operator++(int);
bool operator==(const iterator &arg) const;
bool operator!=(const iterator &arg) const;

const_iterator( CharT* p = nullptr );
const CharT operator*() const;
const CharT* operator->() const;
const_iterator& operator++();
const_iterator operator++(int);
bool operator==(const const_iterator &arg) const;
bool operator!=(const const_iterator &arg) const;

typedef c3::string     c3::basic_string<char>
typedef c3::wstring    c3::basic_string<wchar_t>
typedef c3::u16string  c3::basic_string<char16_t>
typedef c3::u32string  c3::basic_string<char32_t>
typedef reverse_iterator c3::reverse_iterator<iterator>
typedef const_reverse_iterator c3::reverse_iterator<const_iterator>

// Возвращает максимальное значение типа size_t. Точное значение зависит от контекста.
static const size_t npos = -1;

#include <iostream>
using namespace std;

class Ctemp {
public:
    int a;
    char ch;

    Ctemp() {}
    Ctemp(const Ctemp& src) : a(src.a), ch(src.ch) {}
    Ctemp(int _a, char _ch) : a(_a), ch(_ch) {}
};

int main(void) {
    c3::allocator<Ctemp> alloc;
    // Выделяет память для 5 объектов типа Ctemp
    Ctemp* pCtemp = alloc.allocate(5);
    // Конструирует каждый объект
    for(int i = 0; i < 5; ++i) {
        alloc.construct(pCtemp + i, Ctemp(i, '0' + static_cast<char>(i)));
    }

    // Использует pCtemp как массив из 5 элементов типа Ctemp

    // Разрушает каждый объект
    for(int i = 0; i < 5; ++i) {
        alloc.destroy(pCtemp + i);
    }
    // Освобождает выделенную память
    alloc.deallocate(pCtemp, 5);
    return 0;
}

basic_string();
// Конструктор пустой строки с использованием alloc в качестве аллокатора памяти
explicit basic_string(const Allocator& alloc);
// Копирующий конструктор
basic_string(const basic_string& other);
// Копирующий конструктор с использованием alloc в качестве аллокатора памяти
basic_string(const basic_string& other, const Allocator& alloc);
// (Необязательный) Перемещающий конструктор
// basic_string(basic_string&& other);
// (Необязательный) Перемещающий конструктор с использованием alloc в качестве аллокатора памяти
// basic_string(basic_string&& other, const Allocator& alloc);
// Конструктор строки, содержащей count символов ch, используя alloc в качестве аллокатора памяти
basic_string(size_t count, CharT ch, const Allocator& alloc = Allocator());
// Конструктор строки, созданной из подстроки other[pos, pos+count). Если count == npos или не указано count или выходит за границы строки, создается подстрока [pos, other.size()).
basic_string(const basic_string& other, size_t pos, size_t count = c3::basic_string::npos, const Allocator& alloc = Allocator());
// Конструктор строки, созданной из первых count символов s. s может содержать '\0'. Длина строки равна count. Если [s, s + count) не является допустимым диапазоном, поведение не определено.
basic_string(const CharT* s, size_t count, const Allocator& alloc = Allocator());
// Конструктор строки, инициализированной массивом CharT, завершающимся '\0'. (Обычно используется для инициализации string строками, заключенными в двойные кавычки)
basic_string(const CharT* s, const Allocator& alloc = Allocator());

```## Замена строки
```cpp
basic_string& assign(size_t count, CharT ch);
// Аналогично assign(1, ch)
``````markdown
basic_string& operator=(CharT ch);
basic_string& assign(const basic_string& str);
basic_string& operator=(const basic_string& str);
basic_string& assign(const basic_string& str, size_t pos, size_t count);
basic_string& assign(const CharT* s, size_t count);
basic_string& assign(const CharT* s);
basic_string& operator=(const CharT* s);
```// (Необязательный метод)
// basic_string& assign(basic_string&& str);
// basic_string& operator=(basic_string&& str);

```cpp

Allocator get_allocator() const;

CharT& at(size_t pos);
CharT& operator[](size_t pos);
const CharT& at(size_t pos) const;
const CharT& operator[](size_t pos) const;

CharT& front();
const CharT& front() const;

CharT& back();
const CharT& back() const;

const CharT* data() const;
const CharT* c_str() const;

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;

void reserve(size_t new_cap = 0);// Производит запрос на удаление невостребованного зарезервированного пространства (не обязательно выполняется).
void shrink_to_fit();

// Очищает строку.
void clear();

// Вставляет count копий символа ch в позицию index. Возвращает *this
basic_string& insert(size_t index, size_t count, CharT ch);
// Вставляет строку, завершающуюся символом '\0', указанную s, в позицию index. Возвращает *this
basic_string& insert(size_t index, const CharT* s);
// Вставляет диапазон символов [s, s + count) в позицию index. Диапазон может содержать символ '\0'. Возвращает *this
basic_string& insert(size_t index, const CharT* s, size_t count);
// Вставляет строку str в позицию index. Возвращает *this
basic_string& insert(size_t index, const basic_string& str);
// Вставляет подстроку str.substr(index_str, count) в позицию index. Возвращает *this
basic_string& insert(size_t index, const basic_string& str, size_t index_str, size_t count);
// Вставляет символ ch перед символом, на который указывает итератор pos. Возвращает итератор после вставки.
iterator insert(iterator pos, CharT ch);
// Вставляет count копий символа ch перед элементом, на который указывает итератор pos.
void insert(iterator pos, size_t count, CharT ch);

// Удаляет минимальное количество символов min(count, size() - index), начиная с позиции index. Возвращает *this
basic_string& erase(size_t index = 0, size_t count = npos);
// Удаляет символ, на который указывает итератор position. Возвращает итератор после удаления
iterator erase(iterator position);
// Удаляет символы в диапазоне [first, last). Возвращает итератор после последнего удаленного символа
iterator erase(iterator first, iterator last);// Добавляет указанный символ ch в конец строки.
void push_back(CharT ch);```cpp
// Удаляет последний символ из строки.
void pop_back();

/*
Возвращает ссылку на текущий объект (*this)
*/
// Добавляет count повторений символа ch
basic_string& append(size_t count, CharT ch);
// Эквивалентно append(1, ch). Возвращает ссылку на текущий объект (*this)
basic_string& operator+=(CharT ch);
// Добавляет строку str
basic_string& append(const basic_string& str);
basic_string& operator+=(const basic_string& str);
// Добавляет подстроку строки str, начиная с позиции pos и заканчивая pos+count. Если запрошенная подстрока выходит за конец строки или count == npos, то добавляется подстрока от pos до конца строки.
basic_string& append(const basic_string& str, size_t pos, size_t count);
// Добавляет последовательность символов из диапазона [s, s + count). Этот диапазон может содержать '\0'.
basic_string& append(const CharT* s, size_t count);
// Добавляет строку, которую указывает s, завершённую символом '\0'
basic_string& append(const CharT* s);
basic_string& operator+=(const CharT* s);

/*
Если *this находится раньше в лексикографическом порядке, чем указанный параметром символьный ряд, то возвращается положительное значение.
Если два ряда эквивалентны, то возвращается нуль.
Если *this следует за указанным параметром символьным рядом в лексикографическом порядке, то возвращается отрицательное значение.
*/
// Сравнение текущей строки со строкой str.
int compare(const basic_string& str) const;
// Сравнение подстроки [pos1, pos1 + count1) текущей строки с строкой str. Если count1 больше размера строки минус позиция pos1, то подстрока будет [pos1, размер строки).
``````cpp
int compare(size_t pos1, size_t count1, const basic_string& str) const;
// Сравнение подстроки [pos1, pos1 + count1) текущей строки с подстрокой [pos2, pos2 + count2) строки str. Если count1 больше размера строки минус позиция pos1, то первая подстрока будет [pos1, размер строки]. Аналогично, если count2 больше размера строки str минус позиция pos2, то вторая подстрока будет [pos2, размер строки str].
int compare(size_t pos1, size_t count1, const basic_string& str, size_t pos2, size_t count2) const;
// Сравнение текущей строки со строкой s.
int compare(const CharT* s) const;
// См. перегрузку №2
int compare(size_t pos1, size_t count1, const CharT* s) const;
// См. перегрузку №3
int compare(size_t pos1, size_t count1, const CharT* s, size_t count2) const;

/*
Возвращает *this
*/
// Заменяет часть строки [pos, pos + count) на str.
basic_string& replace(size_t pos, size_t count, const basic_string& str);
// Заменяет часть строки [first, last) на str.
basic_string& replace(const_iterator first, const_iterator last, const basic_string& str);
// Заменяет часть строки [pos, pos + count) на подстроку str[pos2, pos2 + count2). Если count2 == npos или она может выйти за границы str.size(), то используется [pos2, str.size()).
basic_string& replace(size_t pos, size_t count, const basic_string& str, size_t pos2, size_t count2 = npos);
// Заменяет часть строки [pos, pos + count) на последовательность символов [cstr, cstr + count2).
basic_string& replace(size_t pos, size_t count, const CharT* cstr, size_t count2);
// Заменяет часть строки [first, last) на последовательность символов [cstr, cstr + count2).
basic_string& replace(const_iterator first, const_iterator last, const CharT* cstr, size_t count2);
// Заменяет часть строки [pos, pos + count) на последовательность символов cstr.
basic_string& replace(size_t pos, size_t count, const CharT* cstr);
```// Заменяет часть строки [first, last) на последовательность символов cstr.
basic_string& replace(const_iterator first, const_iterator last, const CharT* cstr);
// Заменяет часть строки [pos, pos + count) на count2 символов ch.
basic_string& replace(size_t pos, size_t count, size_t count2, CharT ch);
// Заменяет часть строки [first, last) на count2 символов ch.
basic_string& replace(const_iterator first, const_iterator last, size_t count2, CharT ch);

```// Возвращает подстроку [pos, pos + count). Если запрошенная подстрока выходит за конец или count равно npos, то возвращаемая подстрока будет [pos, size()).
basic_string substr(size_t pos = 0, size_t count = npos) const;
```// Копирует подстроку [pos, pos + count) в указанный строкой dest. Если запрошенная подстрока выходит за конец или count == npos, то копируемая подстрока будет [pos, size()). Производимая строка не завершается символом '\0'.
size_t copy(CharT* dest, size_t count, size_t pos = 0) const;

// Изменяет размер строки до count символов. Если текущий размер меньше count, то дополняются дополнительные символы. Если текущий размер больше count, то сокращает строку до её первых count элементов. Новые символы инициализируются CharT(), а старые - ch.
void resize(size_t count);
void resize(size_t count, CharT ch);

// Обменивает содержимое string с содержимым other.
void swap(basic_string& other);

/*
Возвращает позицию первого символа найденной подстроки, или npos, если такая подстрока не найдена.
*/
// Находит первую подстроку, равную str. Поиск начинается с pos назад.
size_t find(const basic_string& str, size_t pos = 0) const;
// Находит первую подстроку, равную диапазону [s, s + count), который может содержать '\0'. Поиск начинается с pos назад.
size_t find(const CharT* s, size_t pos, size_t count) const;
// Находит первую подстроку, равную s. Поиск начинается с pos назад.
size_t find(const CharT* s, size_t pos = 0) const;
// Находит первый символ ch. Поиск начинается с pos назад.
size_t find(CharT ch, size_t pos = 0) const;```
/*
Возвращает позицию последнего символа найденной подстроки, или npos, если такая подстрока не найдена.
*/
// Находит последнюю подстроку, равную str. Поиск начинается с pos вперед.
size_t rfind(const basic_string& str, size_t pos = npos) const;
// Находит последнюю подстроку, равную диапазону [s, s + count), который может содержать '\\0'. Поиск начинается с pos вперед.
size_t rfind(const CharT* s, size_t pos, size_t count) const;
// Находит последнюю подстроку, равную диапазону [s, s + count), который может содержать '\\0'. Поиск начинается с pos вперед.
size_t rfind(const CharT* s, size_t pos = npos) const;
// Находит последний символ ch. Поиск начинается с pos вперед.
size_t rfind(CharT ch, size_t pos = npos) const;

/*
Возвращает позицию найденного символа, или значение npos, если такой символ не был найден.
*/
// Находит первый символ, который совпадает с одним из символов в строке str. Поиск начинается с позиции pos и продолжается вперед.
size_t find_first_of(const basic_string& str, size_t pos = 0) const;
// Находит первый символ, который совпадает с одним из символов в диапазоне [s, s+count). Этот диапазон может содержать '\\0'. Поиск начинается с позиции pos и продолжается вперед.
size_t find_first_of(const CharT* s, size_t pos, size_t count) const;
// Находит первый символ, который совпадает с одним из символов в строке s. Поиск начинается с позиции pos и продолжается вперед.
size_t find_first_of(const CharT* s, size_t pos = 0) const;
// Находит первый символ, который совпадает с символом ch. Поиск начинается с позиции pos и продолжается вперед.
size_t find_first_of(CharT ch, size_t pos = 0) const;

Возвращает позицию найденного символа или `npos`, если такой символ не найден.

```cpp
// Найти последний символ, равный одному из символов в строке `str`. Поиск начинается с позиции `pos` и продолжается до конца.
size_t find_last_of(const basic_string& str, size_t pos = npos) const;
// Найти последний символ, равный одному из символов в диапазоне `[s, s + count)`. Диапазон может содержать `\0`. Поиск начинается с позиции `pos`.
size_t find_last_of(const CharT* s, size_t pos, size_t count) const;
// Найти последний символ, равный одному из символов в строке `s`. Поиск начинается с позиции `pos`.
size_t find_last_of(const CharT* s, size_t pos = npos) const;
// Найти последний символ, равный символу `ch`. Поиск начинается с позиции `pos`.
size_t find_last_of(CharT ch, size_t pos = npos) const;

size_t find_last_not_of(const basic_string& str, size_t pos = npos) const;
size_t find_last_not_of(const CharT* s, size_t pos, size_t count) const;
size_t find_last_not_of(const CharT* s, size_t pos = npos) const;
size_t find_last_not_of(CharT ch, size_t pos = npos) const;

template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(const c3::basic_string<CharT, Alloc>& lhs, const c3::basic_string<CharT, Alloc>& rhs);

template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(const c3::basic_string<CharT, Alloc>& lhs, const CharT* rhs);
```## Оператор сложения строк

```cpp
template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(const c3::basic_string<CharT, Alloc>& lhs, CharT rhs);

template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(const CharT* lhs, const c3::basic_string<CharT, Alloc>& rhs);

template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(CharT lhs, const c3::basic_string<CharT, Alloc>& rhs);

template<typename CharT, typename Alloc>
c3::basic_string<CharT, Alloc> operator+(c3::basic_string<CharT, Alloc>&& lhs, c3::basic_string<CharT, Alloc>&& rhs);

template<typename CharT, typename Alloc>
bool operator==(const c3::basic_string<CharT, Alloc>& lhs, const c3::basic_string<CharT, Alloc>& rhs);

template<typename CharT, typename Alloc>
bool operator==(const c3::basic_string<CharT, Alloc>& lhs, const CharT* rhs);

template<typename CharT, typename Alloc>
bool operator!=(const c3::basic_string<CharT, Alloc>& lhs, const c3::basic_string<CharT, Alloc>& rhs);

template<typename CharT, typename Alloc>
bool operator!=(const c3::basic_string<CharT, Alloc>& lhs, const CharT* rhs);

template<typename CharT, typename Alloc>
bool operator<(const c3::basic_string<CharT, Alloc>& lhs, const c3::basic_string<CharT, Alloc>& rhs);
``````markdown
template< class CharT, class Alloc >
bool operator>=(const c3::basic_string<CharT, Alloc>& lhs, const CharT* rhs);

template< class CharT, class Allocator >
c3::basic_ostream<CharT>& operator<<(c3::basic_ostream<CharT>& os, const c3::basic_string<CharT, Allocator>& str);

template< class CharT, class Traits, class Allocator >
c3::basic_istream<CharT>& operator>>(c3::basic_istream<CharT>& is, c3::basic_string<CharT, Allocator>& str);

template< class CharT, class Allocator >
c3::basic_istream<CharT>& getline(c3::basic_istream<CharT>& input, c3::basic_string<CharT, Allocator>& str, CharT delim);
```// Преобразует строку `str` в знаковый целочисленный тип.
// Пропускает все пробелы (определённые вызовом `isspace()`), до тех пор пока не встретится первый непробельный символ, затем берёт максимальное количество символов для представления числа с основанием `n` (где `n`=base) и преобразует их в целое число. Допустимый формат целого числа состоит из следующих частей:
// (необязательно) знак плюса или минуса
// (необязательно) префикс, указывающий на основание восьмеричной системы (0) (только применимо при основании 8 или 0)
// (необязательно) префикс, указывающий на основание шестнадцатеричной системы (0x или 0X) (только применимо при основании 16 или 0)
// последовательность цифр
// Набор допустимых значений основания — это {0, 2, 3, ..., 36}. Набор допустимых цифр для целых чисел с основанием 2 — это {0, 1}, для основания 3 — это {0, 1, 2}, и так далее. Для оснований больше 10 допустимыми цифрами являются буквы от Aa до Zz для основания 11 до основания 36 соответственно. Буквы игнорируют регистр.
// Если значение `base` равно 0, то система автоматически определяет систему счисления числа: если префикс равен 0, то основание равно 8, если префикс равен 0x или 0X, то основание равно 16, в противном случае основание равно 10.
// Если `pos` не является указателем null, то внутренний указатель `ptr`, который указывает на адрес первого невыполненного символа в `str`.```c_str()`, вычисляет индекс этого символа и сохраняет его в `*pos`, что позволяет получить количество прочитанных символов.
int stoi(const c3::string& str, size_t* pos = 0, int base = 10);
int stoi(const c3::wstring& str, size_t* pos = 0, int base = 10);
long stol(const c3::string& str, size_t* pos = 0, int base = 10);
long stol(const c3::wstring& str, size_t* pos = 0, int base = 10);
long long stoll(const c3::string& str, size_t* pos = 0, int base = 10);
long long stoll(const c3::wstring& str, size_t* pos = 0, int base = 10);

// Преобразует строковое представление в беззнаковое целое число с длинной арифметикой.
unsigned long stoul(const c3::string& str, c3::size_t* pos = 0, int base = 10);
unsigned long stoul(const c3::wstring& str, c3::size_t* pos = 0, int base = 10);
unsigned long long stoull(const c3::string& str, c3::size_t* pos = 0, int base = 10);
unsigned long long stoull(const c3::wstring& str, c3::size_t* pos = 0, int base = 10);

## Преобразование строки `str` в число с плавающей запятой.
### Функция игнорирует все пробелы (определённые через `c3::isspace()`), пока не встретит первый непробельный символ. Затем она использует максимальное количество символов для создания легального представления числа с плавающей запятой и преобразует его в число с плавающей запятой. Легальные представления числа с плавающей запятой могут быть следующими:
- **Десятичное представление:** состоит из следующих частей:
    - *(необязательно)* знак "+" или "-"
    - Непустая последовательность десятичных цифр, содержащая *(необязательно)* символ точки (определённый текущим локальным окружением C)
```    - *(необязательно)* буква "e" или "E", за которой следует *(необязательно)* знак "+" или "-", а также непустая последовательность десятичных цифр (определяющая степень числа основанием 10)
 - **Двоичное представление:** состоит из следующих частей:
     - *(необязательно)* знак "+" или "-"
     - "0x" или "0X"
     - Непустая последовательность шестнадцатеричных цифр, содержащая *(необязательно)* символ точки (определенный текущим локальным окружением C)
     - *(необязательно)* букву "p" или "P", за которой следует *(необязательно)* знак "+" или "-", а также непустую последовательность десятичных цифр (определяющая степень числа основанием 2)
 - **Представление бесконечности:** состоит из следующих частей:
     - *(необязательно)* знак "+" или "-"
     - "INF" или "INFINITY", регистр не важен
 - **Представление нечисловой величины (NaN):** состоит из следующих частей:
     - *(необязательно)* знак "+" или "-"
     - "NAN" или "NAN(char_sequence)", где "NAN" игнорирует регистр, а `char_sequence` может содержать цифры, латинские буквы и нижние подчеркивания. Результат — тихое значение NaN типа float.Если указатель `pos` не является пустым указателем, то внутренний указатель `ptr`, принявший адрес первого невыполненного символа в `str.c_str()`, вычисляет индекс этого символа и сохраняет его в `*pos`, что позволяет получить количество обработанных символов.

```cpp
float stof(const c3::string& str, size_t* pos = 0);
float stof(const c3::wstring& str, size_t* pos = 0);
double stod(const c3::string& str, size_t* pos = 0);
double stod(const c3::wstring& str, size_t* pos = 0);
long double stold(const c3::string& str, size_t* pos = 0);
long double stold(const c3::wstring& str, size_t* pos = 0);

c3::string to_string(int value);
c3::string to_string(long value);
c3::string to_string(long long value);
c3::string to_string(unsigned value);
c3::string to_string(unsigned long value);
c3::string to_string(unsigned long long value);
c3::string to_string(float value);
c3::string to_string(double value);
c3::string to_string(long double value);

c3::wstring to_wstring(int value);
c3::wstring to_wstring(long value);
c3::wstring to_wstring(long long value);
c3::wstring to_wstring(unsigned value);
c3::wstring to_wstring(unsigned long value);
c3::wstring to_wstring(unsigned long long value);
c3::wstring to_wstring(float value);
c3::wstring to_wstring(double value);
c3::wstring to_wstring(long double value);

template<
    class T,
    class Allocator = c3::allocator<T>
> class vector;
```### API:
```cpp
// Constructor for an empty vector
vector();
// Constructor for an empty vector using `alloc` as the memory allocator
explicit vector(const Allocator& alloc);
// Copy constructor
vector(const vector& other);
// Copy constructor using `alloc` as the memory allocator
vector(const vector& other, const Allocator& alloc);
// Constructor that creates a container with `count` elements of type T by default. The elements are not copied. Uses `alloc` as the memory allocator
explicit vector(size_t count, const Allocator& alloc = Allocator());
// Constructor that creates a container with `count` elements set to `value`. Uses `alloc` as the memory allocator
vector(size_t count, const T& value, const Allocator& alloc = Allocator());
```// Деструктор вектора. Вызывает деструктор каждого элемента, а затем освобождает используемое пространство. Обратите внимание, что если элементы являются указателями, то сами объекты, на которые они указывают, не будут уничтожены.
~vector();

// Оператор присваивания. Заменяет содержимое текущего вектора копией other.
vector& operator=(const vector& other);

// Оператор перемещающего присваивания.
// (не обязательно) vector& operator=(vector&& other);

// Устанавливает содержимое вектора равным count элементам значения value.
void assign(size_t count, const T& value);

// Возвращает связанного с контейнером аллокатора.
Allocator get_allocator() const;

// Возвращает ссылку на элемент, находящийся по указанному положению pos. Есть проверка границ.
T& at(size_t pos);
T& operator[](size_t pos);
const T& at(size_t pos) const;
const T& operator[](size_t pos) const;

// Возвращает ссылку на первый элемент контейнера. Вызов front для пустого контейнера неопределен.
T& front();
const T& front() const;

// Возвращает ссылку на последний элемент контейнера. Вызов back для пустого контейнера неопределен.
T& back();
const T& back() const;

```// Возвращает указатель на нижележащий массив, используемый для хранения элементов. Указатель удовлетворяет диапазону [data(), data() + size()], который всегда является допустимым диапазоном, даже если контейнер пуст (в этом случае data() нельзя декодировать).
T* data() noexcept;
const T* data() const noexcept;```// Возвращает изменяемый или константный итератор в зависимости от того, является ли *this константой.
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;

// Возвращает true, если контейнер пуст, иначе возвращает false.
bool empty() const;

// Возвращает размер контейнера.
size_t size() const;

// Возвращает максимальный размер контейнера, который может быть сохранён из-за ограничений операционной системы или реализации библиотеки.
size_t max_size() const;

// Возвращает количество элементов, которое было зарезервировано для текущего контейнера.
size_t capacity() const;

// Переопределяет зарезервированное пространство контейнера. Если new_cap больше текущего значения capacity(), то выделяется новое хранилище, а значение capacity() становится больше или равно new_cap. Если new_cap меньше или равно текущему значению capacity(), то ничего не происходит.
void reserve(size_t new_cap = 0);// Прошу освободить незадействованное зарезервированное пространство. (не обязательно)
void shrink_to_fit();

// Очищает контейнер.
void clear();

// Вставляет значение `value` перед `pos`.
iterator insert(const_iterator pos, const T& value);
// (не обязательно) iterator insert(const_iterator pos, T&& value);
// Вставляет `count` значений `value` перед `pos`.
iterator insert(const_iterator pos, size_t count, const T& value);

// Удаляет элемент, расположенный в `pos`.
iterator erase(const_iterator pos);
// Удаляет элементы в диапазоне `[first; last)`.
iterator erase(const_iterator first, const_iterator last);

// Добавляет элемент `value` в конец контейнера.
void push_back(const T& value);
// (не обязательно) void push_back(T&& value);

// Удаляет последний элемент контейнера. Вызов `pop_back` для пустого контейнера приводит к неопределенному поведению.
void pop_back();
// Если текущий размер больше `count`, то уменьшаем контейнер до его первых `count` элементов. Если текущий размер меньше `count`, то добавляем дополнительные элементы со значением по умолчанию.
void resize(size_t count);

// Если текущий размер больше `count`, то уменьшаем контейнер до его первых `count` элементов. Если текущий размер меньше `count`, то добавляем дополнительные элементы, являющиеся копиями значения `value`.
void resize(size_t count, const T& value);

// Обменивает содержимое с `other`. Не вызывает никаких операций перемещения, копирования или обмена для отдельных элементов.
void swap(vector& other);Дружественные функции:
```cpp
// Проверяет, равны ли содержимое lhs и rhs, то есть имеют ли они одинаковое количество элементов и каждый элемент lhs равен соответствующему элементу rhs.
template<class T, class Alloc>
bool operator==(const c3::vector<T, Alloc>& lhs, const c3::vector<T, Alloc>& rhs);
``````markdown


## `c3::deque` @ `<deque.h>`


**Примечание:** `deque` — это двунаправленный список, который поддерживает операции вставки и удаления как с начала, так и с конца списка. Это позволяет использовать `deque` как для работы с очередями FIFO, так и для работы со стеками LIFO. В STL эти возможности реализованы через шаблоны классов `stack` и `queue`.
```Шаблонное определение:
```cpp
template<
    class T,
    class Allocator = c3::allocator<T>
> class deque;

// Создает пустой deque
deque();
// Создает пустой deque с использованием alloc в качестве аллокатора памяти
explicit deque(const Allocator& alloc);
// Копирующий конструктор
deque(const deque& other);
// Конструктор с копированием, использующий alloc в качестве аллокатора памяти
deque(const deque& other, const Allocator& alloc);
// Создает контейнер, содержащий count значений типа T по умолчанию. Без копирования. Использует alloc в качестве аллокатора памяти
explicit deque(size_t count, const Allocator& alloc = Allocator());
// Создает контейнер, содержащий count элементов со значением value. Использует alloc в качестве аллокатора памяти
deque(size_t count, const T& value, const Allocator& alloc = Allocator());
// (необязательный) deque(deque&& other);
// (необязательный) deque(deque&& other, const Allocator& alloc);

Дружественные функции:
```cpp
// Проверяет, равны ли содержимое lhs и rhs, то есть имеют ли они одинаковое количество элементов и каждый элемент lhs равен соответствующему элементу rhs.
template<class T, class Alloc>
bool operator==(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);
template<class T, class Alloc>
bool operator!=(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);

// Сравнивает содержимое lhs и rhs по алфавитному порядку.
template<class T, class Alloc>
bool operator<(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);
template<class T, class Alloc>
bool operator<=(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);
template<class T, class Alloc>
bool operator>(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);
template<class T, class Alloc>
bool operator>=(const c3::deque<T, Alloc>& lhs, const c3::deque<T, Alloc>& rhs);

template<
    class T,
    class Container = std::deque<T>
> class stack;

protected:
    Container c;    // Подлежащий контейнер, по умолчанию это `deque`

~stack();

// Оператор присваивания копирования. Возвращает *this
stack& operator=(const stack& other);
// Оператор присваивания перемещения. Возвращает *this
// (необязательный) stack& operator=(stack&& other);

// Возвращает ссылку на верхний элемент стека. Это последний добавленный элемент. Этот элемент будет удален при вызове pop(). Эквивалентно вызову c.back().
T& top();
const T& top() const;

// Возвращает true, если стек пустой. Эквивалентно вызову c.empty()
bool empty() const;

// Возвращает количество элементов в стеке. Эквивалентно вызову c.size()
size_t size() const;

// Добавляет элемент value в конец стека. Эквивалентно вызову c.push_back(value)
void push(const T& value);
// (необязательный) void push(T&& value)

// Удаляет последний элемент из стека. Эквивалентно вызову c.pop_back()
void pop();

// Обменивается содержимым с другим объектом other
void swap(stack& other);

// Проверяет, равны ли lhs и rhs содержимыми, то есть имеют ли они одинаковое количество элементов и каждый элемент lhs эквивалентен соответствующему элементу rhs.
template<class T, class Alloc>
bool operator==(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);
template<class T, class Alloc>
bool operator!=(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);
```// Сравнивает содержимое lhs и rhs в лексикографическом порядке.
template<class T, class Alloc>
bool operator<(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator<=(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);

template<class T, class Alloc>
bool operator>=(const c3::stack<T, Alloc>& lhs, const c3::stack<T, Alloc>& rhs);

```## `<algorithm.h>`

API:
```cpp
// Сортирует элементы в диапазоне [first, last) в порядке неубывания.
// Элементы сравниваются с помощью оператора <.
template< class RandomIt >
void sort( RandomIt first, RandomIt last );

// Сортирует элементы в диапазоне [first, last) с использованием двоичной функции сравнения comp.
template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

// Упорядочивает элементы так, чтобы диапазон [first, middle) содержал минимальные middle - first элементов из диапазона [first, last).
// Элементы сравниваются с помощью оператора <.
template< class RandomIt >
void partial_sort( RandomIt first, RandomIt middle, RandomIt last );

// Упорядочивает элементы с использованием двоичной функции сравнения comp.
template< class RandomIt, class Compare >
void partial_sort( RandomIt first, RandomIt middle, RandomIt last, Compare comp );


// Сортирует некоторые элементы в диапазоне [first, last) в порядке возрастания и хранит результат в диапазоне [d_first, d_last).
template< class InputIt, class RandomIt >
RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last );

template< class InputIt, class RandomIt, class Compare >
RandomIt partial_sort_copy( InputIt first, InputIt last, RandomIt d_first, RandomIt d_last, Compare comp );
```// Проверяет, отсортирован ли диапазон [first, last) в порядке неубывания.
// Элементы сравниваются с помощью оператора <.
template< class ForwardIt >
bool is_sorted( ForwardIt first, ForwardIt last );

// Проверяет, отсортирован ли диапазон [first, last) с использованием двоичной функции сравнения comp.
template< class ForwardIt, class Compare >
bool is_sorted( ForwardIt first, ForwardIt last, Compare comp );


// Проверяет диапазон [first, last) и возвращает последний итератор, который указывает на максимальный диапазон, начинающийся с first и содержащий элементы, отсортированные в порядке возрастания.
// Элементы сравниваются с помощью оператора <.
template< class ForwardIt >
ForwardIt is_sorted_until( ForwardIt first, ForwardIt last );

// Проверяет диапазон [first, last) с использованием двоичной функции сравнения comp.
template< class ForwardIt, class Compare >
ForwardIt is_sorted_until( ForwardIt first, ForwardIt last, Compare comp );// Бинарный поиск, возвращающий итератор, указывающий на первый элемент в диапазоне [first, last), который не меньше (то есть больше или равен) значению value.
// Элементы сравниваются с помощью оператора <.
template< class ForwardIt, class T >
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value );

// Бинарный поиск с использованием двоичной функции сравнения comp.
template< class ForwardIt, class T, class Compare >
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value, Compare comp );

```# Бинарный поиск, возвращает итератор, указывающий на первый элемент в диапазоне [first, last), который больше значения value. Если такого элемента нет, возвращается итератор last.
# Элементы сравниваются с помощью оператора <
```cpp
template<class ForwardIt, class T>
ForwardIt upper_bound(ForwardIt first, ForwardIt last, const T& value);

template<class ForwardIt, class T, class Compare>
ForwardIt upper_bound(ForwardIt first, ForwardIt last, const T& value, Compare comp);
```# Бинарный поиск, если в диапазоне [first, last) есть хотя бы один элемент, равный значению value, то возвращает true, иначе false.
# Элементы сравниваются с помощью оператора <
```cpp
template<class ForwardIt, class T>
bool binary_search(ForwardIt first, ForwardIt last, const T& value);

template<class ForwardIt, class T, class Compare>
bool binary_search(ForwardIt first, ForwardIt last, const T& value, Compare comp);

template<class InputIt1, class InputIt2, class OutputIt>
OutputIt merge(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first);

template<class InputIt1, class InputIt2, class OutputIt, class Compare>
OutputIt merge(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first, Compare comp);

template<class BidirIt>
void inplace_merge(BidirIt first, BidirIt middle, BidirIt last);

template<class BidirIt, class Compare>
void inplace_merge(BidirIt first, BidirIt middle, BidirIt last, Compare comp);
```# Возвращает максимальное значение из двух переданных.
# Элементы сравниваются с помощью оператора <
```cpp
template<class T>
const T& max(const T& a, const T& b);

template<class T, class Compare>
const T& max(const T& a, const T& b, Compare comp);
```# Возвращает меньшее значение из двух переданных.
# Элементы сравниваются с помощью оператора <

```cpp
template<class T>
const T& min(const T& a, const T& b);

template<class T, class Compare>
const T& min(const T& a, const T& b, Compare comp);

template< class ForwardIt >
ForwardIt max_element(ForwardIt first, ForwardIt last );

template< class ForwardIt, class Compare >
ForwardIt max_element(ForwardIt first, ForwardIt last, Compare comp );

template< class ForwardIt >
ForwardIt min_element(ForwardIt first, ForwardIt last );

template< class ForwardIt, class Compare >
ForwardIt min_element(ForwardIt first, ForwardIt last, Compare comp );

template< class InputIt1, class InputIt2 >
bool lexicographical_compare( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );

template< class InputIt1, class InputIt2, class Compare >
bool lexicographical_compare( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp );
```# Преобразование диапазона [first, last) в следующее по отношению к оператору < или компаратору comp лексикографическое расположение. Возвращает true, если такое расположение существует, иначе преобразует диапазон в начальное расположение и возвращает false.
template< class BidirIt >
bool next_permutation( BidirIt first, BidirIt last );

# Преобразование диапазона [first, last) в следующее по отношению к компаратору comp лексикографическое расположение. Возвращает true, если такое расположение существует, иначе преобразует диапазон в начальное расположение и возвращает false.
template< class BidirIt, class Compare >
bool next_permutation( BidirIt first, BidirIt last, Compare comp );


# Преобразование диапазона [first, last) в предыдущее по отношению к оператору < или компаратору comp лексикографическое расположение. Возвращает true, если такое расположение существует, иначе преобразует диапазон в конечное расположение и возвращает false.
template< class BidirIt >
bool prev_permutation( BidirIt first, BidirIt last );

# Преобразование диапазона [first, last) в предыдущее по отношению к компаратору comp лексикографическое расположение. Возвращает true, если такое расположение существует, иначе преобразует диапазон в конечное расположение и возвращает false.
template< class BidirIt, class Compare >
bool prev_permutation( BidirIt first, BidirIt last, Compare comp );


### Пример использования:

#### `sort` и `binary_search`:
```cpp
#include <algorithm>

bool comp (int a, int b)
{
    return a > b; // Убывающий порядок, если поменять на return a < b, то будет возрастание
}
``````cpp
int main() 
{ 
    int a[10]; 
    for (int i = 0; i < 10; ++i) 
        std::cin >> a[i]; 

    std::sort(a, a + 10);  // возрастающий порядок 
    std::cout << "Найдено число 5? " << std::binary_search(a, a + 10, 5) << std::endl; 

    for (int i = 0; i < 10; ++i) 
        std::cout << a[i] << ' '; 
    std::cout << std::endl; 
} 

c3::sort(a, a + 10, comp); // Упорядочивание в порядке убывания 
std::cout << "Найдено ли число 5? " << c3::binary_search(a, a + 10, 5, comp); // Используется тот же компаратор, что и в sort 

for (int i = 0; i < 10; ++i) 
    std::cout << a[i] << ' '; 
std::cout << std::endl; 
return 0; 
}