Оглавление
stdlib.h #
Динамическая память #
malloc #
void* malloc(size_t size)
Выделить в динамической памяти
size байт. Вернёт отличный от нуля указатель, если память удалось выделить.calloc #
void* calloc(size_t num, size_t size)
Выделить в динамической памяти
num элементов размером size байт каждый и инициализировать нулями. Вернёт отличный от нуля указатель, если память удалось выделить.realloc #
void* realloc(void* ptr, size_t size)
Расширить блок памяти по указателю
ptr до размера size. Вернёт отличный от нуля указатель, если память удалось выделить или указан меньший размер.free #
void free(void* ptr)
Освободить память по указателю
ptr. При нулевом указателе ничего не произойдёт.Сортировка и поиск #
qsort #
void qsort(void* arr, size_t len, size_t size, int (*compare)(const void* a, const void* b))
Сортирует массив
arr, состоящий из len элементов любого типа размером size каждый. compare - внешняя функция сравнения вида int func(const void* a, const void* b), которая должна возвращать:
-1(любое отрицательное), еслиa < b0, еслиa == b1(любое положительное), еслиa > b
// внешняя функция сравнения
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b); // сортировка по возрастанию
}
int main() {
int arr[] = {51, 68, 23, 45, 18, 64, 72, 64, 26, 48}; // подопытный массив
// вариант с внешней функцией
qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compare); // sizeof(arr) / sizeof(int) - кол-во элементов
// arr == {18, 23, 26, 45, 48, 51, 64, 64, 68, 72}
// вариант с лямбда-функцией
qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), [](const void* a, const void* b) -> int {
return (*(int*)b - *(int*)a); // сортировка по убыванию
});
// arr == {72, 68, 64, 64, 51, 48, 45, 26, 23, 18}
}bsearch #
void* bsearch(const void* key, const void* arr, size_t num, size_t size, int (*compare)(const void* a, const void* b))
Быстрый поиск (бинарный, методом половинного деления) значения
key в отсортированном массиве arr, состоящем из len элементов любого типа размером size каждый. Вернёт указатель на найденный элемент в массиве (если их несколько - на один из них), либо нулевой указатель, если элемент не найден. compare - внешняя функция сравнения вида int func(const void* a, const void* b), которая должна возвращать:
-1(любое отрицательное), еслиa < b0, еслиa == b1(любое положительное), еслиa > b
// внешняя функция сравнения
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
int main() {
int arr[] = {18, 23, 26, 45, 48, 51, 64, 64, 68, 72}; // подопытный массив
// вариант с внешней функцией
int val1 = 51;
int* res1 = (int*)bsearch(&val1, arr, sizeof(arr) / sizeof(int), sizeof(int), compare);
// res1 != NULL
// *res1 == 51
// (res1 - arr) == 5 - индекс в массиве
// вариант с лямбда-функцией
int val2 = 41;
int* res2 = (int*)bsearch(&val2, arr, sizeof(arr) / sizeof(int), sizeof(int), [](const void* a, const void* b) -> int {
return (*(int*)a - *(int*)b);
});
// res2 == NULL
}string.h #
memset #
void* memset(void* arr, int value, size_t num)
Заполнить
num байт в массие arr байтовым значением value, вернёт arr:
uint8_t arr[6];
memset(arr, 123, sizeof(arr));
// arr == {123, 123, 123, 123, 123, 123}
memset(arr + 3, 100, sizeof(arr) - 3);
// arr == {123, 123, 123, 100, 100, 100}memcpy #
void* memcpy(void* dest, const void* src, size_t num)
Скопировать
num байт из src в dest, возвращает указатель dest. Указанные блоки не должны пересекаться:
int src[] = {1, 2, 3};
int dest[3];
memcpy(dest, src, sizeof(src));
// dest == {1, 2, 3}
//memcpy(src + 0, src + 1, sizeof(int) * 2); // пересекается!memccpy #
void *memccpy(void *dest, const void *src, int val, size_t len)
Копировать не более чем
len байт из src в dest, остановиться при достижении значения val в src (val копируется в dest). Возвращает указатель на следующий за val байт в dest или нулевой указатель, если val не был найден:
uint8_t arr1[5] = {0, 1, 2, 3, 4};
uint8_t arr2[5] = {5, 6, 7, 8, 9};
uint8_t* p = memccpy(arr2, arr1, 2, 5);
// arr2 == {0, 1, 2, 8, 9}
// *p == 8memmove #
void* memmove(void* dest, const void* src, size_t num)
Скопировать
num байт из src в dest, возвращает указатель dest. Указанные блоки могут пересекаться:
int src[] = {1, 2, 3};
// записать цифры 2 и 3 (индексы 1 и 2) начиная с индекса 0
memcpy(src + 0, src + 1, sizeof(int) * 2);
// src == {2, 3, 3}memcmp #
int memcmp(const void* p1, const void* p2, size_t num)
Сравнить
num байт между массивами p1 и p2. Вернёт:
0- массивы совпадают< 0- первый несовпадающий байт вp1имеет меньшее значение, чем вp2> 0- первый несовпадающий байт вp1имеет большее значение, чем вp2
int p1[] = {1, 2, 3};
int p2[] = {1, 2, 3};
memcmp(p1, p2, sizeof(int) * 3); // 0
int p3[] = {1, 1, 3};
memcmp(p1, p3, sizeof(int) * 3); // 1memchr, memrchr #
const void* memchr(const void* arr, int value, size_t num)void* memchr(void* arr, int value, size_t num)const void* memrchr(const void* arr, int value, size_t num)void* memrchr(void* arr, int value, size_t num)
Найти байт со значением
value в массиве arr размером num. Вернёт указатель на найденный элемент, иначе вернёт нулевой указатель. memchr ищет с начала массива (слева направо), memrchr ищет с конца (справа налево):
uint8_t arr[] = {1, 2, 3};
uint8_t* p = (uint8_t*)memchr(arr, 2, sizeof(uint8_t) * 3);
// *p == 2
// (p - arr) == 1, индекс 1
p = (uint8_t*)memchr(arr, 10, sizeof(uint8_t) * 3);
// p == NULLmemmem #
void* memmem(const void* arr, size_t arrsize, const void* sub, size_t subsize)
Найти в массиве
arr длиной arrsize совпадение с массивом sub длиной subsize, считай поиск подстроки в строке. Вернёт указатель на первое вхождение или нулевой указатель, если подстрока не найдена:
uint8_t arr[] = {1, 2, 3, 4, 5, 6};
uint8_t sub[] = {3, 4};
uint8_t* res = (uint8_t*)memmem(arr, sizeof(arr), sub, sizeof(sub));
// (res - arr) == 2, совпадение с индекса 2 (значение 3)