OpenSCADAWiki: Roman Savochenko/C Short All/part2 ...

2.1 Математические функции (math.h|cmath)

ceil, ceilf, ceill (POSIX)
double ceil(double x);
float ceilf(float x);
long double ceill(long double x);
Функции округления до наименьшего целого, не меньшего, чем аргумент.

cos (POSIX)
double cos(double x);
Возвращает значение косинуса x, где x – это значение в радианах.

exp (POSIX)
double exp(double x);
Возвращает значение числа 'e' возведенного в степень x.

fabs, fabsf, fabsl (POSIX)
double fabs(double x);
float fabsf(float x);
long double fabsl(long double x);
Абсолютное значение числа с плавающей точкой.

floor, floorf, floorl (POSIX)
double floor(double x);
float floorf(float x);
long double floorl(long double x);
Наибольшее целое значение, но не большее x.

fmod (POSIX)
double fmod(double x, double y);
Функция получения остатка от деления (с плавающей точкой).

log (POSIX)
double log(double x);
Возвращает натуральный логарифм x.

log10 (POSIX)
double log10(double x);
Возвращает десятичный логарифм x.

matherr (ANSI)
int matherr(struct expection *error_info);
Пользовательская функция обработки ошибок математических операций. Описание ошибки передается в указателе на структуру <error_info>

pow (POSIX)
double pow(double x, double y);
Возвращает значение x в степени y.

rand, srand <stdlib.h>
int rand(void);
void srand(unsigned int seed);
rand() – возвращает псевдослучайное число в диапазоне от нуля до RAND_MAX.
srand() – устанавливает свой аргумент как основу (seed) для новой последовательности псевдослучайных целых чисел, возвращаемых функцией rand().

sin (POSIX)
double sin(double x);
Возвращает значение синуса аргумента x, где x указан в радианах.

sqrt (POSIX)
double sqrt(double x);
Функция вычисления квадратного корня.

tan (POSIX)
double tan(double x);
Возвращает тангенс аргумента x, где x задан в радианах.

2.2 Функции для работы с дисками, директориями и файлами

2.2.1 Функции потокового ввода-вывода

fopen, fdopen, freopen (POSIX) <stdio.h>
FILE *fopen(const char *path, const char *mode);
FILE *fdopen(int fildes, const char *mode);
FILE *freopen(const char *path, const char *mode, FILE *stream);
fopen – открывает файл с именем path и связывает его с потоком.
fdopen – связывает поток с существующим описателем файла <fildes>.
freopen – открывает файл с именем path и связывает его с потоком stream. Исходный поток (если такой существовал) закрывается.

fclose (POSIX) <stdio.h>
int fclose( FILE *stream);
Закрывает поток <stream>.

feof (POSIX) <stdio.h>
int feof(FILE *stream);
Возвращает не ноль если достигнут конец файла (EOF) потока <stream>.

ferror (POSIX) <stdio.h>
int ferror(FILE *stream);
Возвращает не ноль если установлен признак ошибки чтение потока.

fgetc, getc, getchar (POSIX) <stdio.h>
int fgetc(FILE *stream);
int getc(FILE *stream);
int getchar(void);
Считывает символ из потока <stream> или из stdin.

fgets, gets (POSIX) <stdio.h>
char *fgets(char *restrict s, int n, FILE *restrict stream);
char *gets(char *s);
Чтение строки из потока <stream> или из STDIN в буфер <s> размером <n>.

fgetwc, getwc (POSIX) <stdio.h, wchar.h>
wint_t fgetwc(FILE *stream);
wint_t getwc(FILE *stream);
Считывает широкий символ из потока <stream>.

fgetws (POSIX) <wchar.h>
wchar_t *fgetws(wchar_t *ws, int n, FILE *stream);
Чтение строки широких символов из потока <stream> в буфер <ws> размером <n>.

fprintf (POSIX) <stdio.h>
int fprintf(FILE *stream, const char *format, ...);
Осуществляет форматированный вывод в поток <stream> (Табл.10).

fputc, putc (POSIX) <stdio.h>
int fputc(int c, FILE *stream);
int putc(int c, FILE *stream);
Помещает символ в поток <stream>.

fputs, puts (POSIX) <stdio.h>
int fputs(const char *restrict s, FILE *restrict stream);
int puts(const char *s);
Помещает строку <s> в поток <stream> или в STDOUT.

fputwc, putwc (POSIX) <stdio.h, wchar.h>
wint_t fputwc(wchar_t wc, FILE *stream);
wint_t putwc(wchar_t wc, FILE *stream);
Помещает широкий символ в поток <stream>.

fputws (POSIX) <wchar.h>
int fputws(const wchar_t *ws, FILE *stream);
Помещает строку широких символов <s> в поток <stream>.

fread (POSIX) <stdio.h>
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
Чтение блоков данных <nmemb> размером <size> каждый из потока <stream> в буфер <ptr>. Возвращается количество удачно прочитаных блоков.

fseek, fseeko, fsetpos (POSIX) <stdio.h>
int fseek(FILE *stream, long offset, int whence);
int fseeko(FILE *stream, off_t offset, int whence);
int fsetpos(FILE *stream, const fpos_t *pos);
Установка позиции в потоке <stream> в соответствии с правилом <whence> и смещением <offset>. В случае с fsetpos позиция устанавливается из структуры <pos>.

fflush (POSIX) <stdio.h>
int fflush(FILE *stream);
«Сбрасывает» буферы потока <stream>.

ftell, ftello, fgetpos (POSIX) <stdio.h>
long ftell(FILE *stream);
off_t ftello(FILE *stream);
int fgetpos(FILE *restrict stream, fpos_t *restrict pos);
Получение текущей позиции в потоке <stream>. В случае с fgetpos выполняется заполнение структуры <pos>.

fwrite (POSIX) <stdio.h>
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
Запись в поток <stream> блоков данных <nmemb> размером <size> каждый из буфера <ptr>. Возвращается количество удачно записанных блоков.

perror (POSIX) <stdio.h>
void perror(const char *s);
Выводит в стандартный поток ошибки сообщения, описывая ошибку, произошедшую при последнем системном вызове или вызове библиотечной функции.

rewind (POSIX) <stdio.h>
void rewind(FILE *stream);
Сброс указателя позиции потока <stream>.

setbuf, setvbuf (POSIX) <stdio.h>
void setbuf(FILE *restrict stream, char *restrict buf);
int setvbuf(FILE *restrict stream, char *restrict buf, int type, size_t size);
Установка правила буферизации потока <stream>. Если <buf> равно NULL, то буферизации отключается. Режим буферизации указывается в <type>: _IOFBF(полная буферизация), _IOLBF(построчная), _IONBF(отсутствие).

2.2.2 Работа с директориями

chdir, fchdir (POSIX) <unistd.h>
int chdir(const char *path);
int fchdir(int fd);
Установка текущей директории <path>, <fd>.

ftw, nftw <ftw.h>
int ftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag), int depth);
int nftw(const char *dir, int (*fn)(const char *file, const struct stat *sb, int flag, struct FTW *s), int depth, int flags);
Перемещается по дереву каталогов, начиная с указанного каталога <dir>. Для каждого найденного элемента дерева вызываются: <fn()> с указанием полного имени этого элемента, указатель на структуру элемента <stat> и целое число. Функция nftw() выполняет то же самое, что и ftw(), только имеет еще один параметр, flags, то есть вызывает свои функции еще с одним параметром.

getcwd (POSIX) <unistd.h>
char *getcwd(char *buf, size_t size);
Копирует абсолютный путь к текущему рабочему каталогу в массив <buf>, имеющий длину <size>.

mkdir (POSIX) <sys/stat.h, sys/types.h>
int mkdir(const char *pathname, mode_t mode);
Создаёт каталог <pathname> с режимом <mode>.

opendir, closedir (POSIX) <sys/types.h, dirent.h>
DIR *opendir(const char *name);
int closedir(DIR *dir);
Открывает/закрывает поток каталога, соответствующий каталогу <name>.

readdir (POSIX) <sys/types.h, dirent.h>
struct dirent *readdir(DIR *dir);
Возвращает указатель <dir> на следующую запись каталога.

rmdir (POSIX) <unistd.h>
int rmdir(const char *pathname);
Удаляет каталог <pathname>.

2.2.3 Доступ к файлам

access (POSIX) <unistd>
int access(const char *pathname, int mode);
Проверка, имеет ли процесс <pathname> права <mode> на чтение(R_OK), запись(W_OK), выполнение(X_OK) или существование файла(F_OK).

close (POSIX) <unistd.h>
int close(int fd);
Закрывает открытый описатель файла <fd>.

creat (POSIX) <sys/types.h, sys/stat.h, fcntl.h>
int creat(const char *pathname, mode_t mode);
Создаёт файл <pathname> и возвращает его описатель.

dup, dup2 (POSIX) <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd);
dup – предоставляет новому описателю наименьший свободный номер. dup2 – делает <newfd> копией <oldfd> (если это необходимо), закрывая newfd.

fcntl (POSIX) <unistd.h, fcntl.h>
int fcntl(int fildes, int cmd, ...);
Выполняет различные операции <cmd> над файловым дескриптором <fildes>.

flock (BSD) <sys/file.h>
int flock(int fd, int operation);
Устанавливает или снимает <operation> «мягкую» блокировку открытого файла <fd>.

fsync, fdatasync (POSIX) <unistd.h>
int fsync(int fd);
int fdatasync(int fd);
fsync – копирует все части файла, находящиеся в памяти, на устройство <fd>. fdatasync – тоже что и fsync, но без метаданных.

fileno (ANSI) <stdio.h>
int fileno(FILE *stream);
Возвращает описатель <stream>.

link (POSIX) <unistd.h>
int link(const char *oldpath, const char *newpath);
Создание ссылки <newpath> на файл <oldpath>.

lseek (POSIX) <sys/types.h, unistd.h>
off_t lseek(int fildes, off_t offset, int whence);
Устанавливает позицию чтения/записи информации в файле.

mknod (BSD) <sys/types.h, sys/stat.h, fcntl.h, unistd.h>
int mknod(const char *pathname, mode_t mode, dev_t dev);
Создаёт файл (обычный файл, файл устройства или именованный канал) <pathname>, с правами доступа <mode> и дополнительной информацией <dev>.

open (POSIX) <sys/types.h, sys/stat.h, fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
Открывает файл <pathname> и возвращает описатель файла.

pathconf, fpathconf (POSIX) <unistd.h>
long pathconf(char *path, int name);
long fpathconf(int filedes, int name);
Получение значения конфигурационной опции для указанного файла <path>, <filedes>. Конфигурационные опции:

read, readv (POSIX) <unistd.h, sys/uio.h>
ssize_t read(int fd, void *buf, size_t count);
int readv(int fd, const struct iovec * vector, int count);
Записывает <count> байтов файлового описателя <fd> в буфер <buf> или вектор <vector>.

readlink (POSIX) <unistd.h>
ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);
Помещает содержимое символьной ссылки <path> в буфер <buf> длиной <bufsiz>.

remove (ANSI,POSIX) <stdio.h>
int remove(const char *pathname);
Удаляет имя файла и, возможно, сам файл.

rename (ANSI) <unistd.h>
int rename(const char *oldpath, const char *newpath);
Изменяет имя или расположение файла <oldpath> на <newpath>.

select (POSIX) <sys/time.h, sys/types.h, unistd.h>
int select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
int pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, sigset_t *sigmask);
Ждут изменения статуса нескольких файловых описателей в течении <timeout>. n – на единицу больше самого большого номера описателей из всех наборов. Для манипуляции набором существуют 4 макроса:

• FD_ZERO – очищающий набор;
• FD_SET – Добавляет заданный описатель к набору;
• FD_CLR – Удаляет описатель из из набора;
• FD_ISSET – Проверяет, является ли описатель частью набора;

sendfile (*) <sys/sendfile.h>
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
Производит чтение данных из <in_fd> по смещению <offset> длиной <count> и запись их в <out_fd>.

stat, fstat, lstat (POSIX) <sys/types.h, sys/stat.h, unistd.h>
int stat(const char *file_name, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);
stat – возвращает информацию о файле <file_name> и заполняет буфер <buf>;
lstat – дополнительно информацию о ссылке;
fstat – информацию о <filedes>.

statvfs, fstatvfs (POSIX) <sys/statvfs.h>
int statvfs(const char *path, struct statvfs *buf);
int fstatvfs(int fd, struct statvfs *buf);
Получение информации о файловой системе на которой расположен файл <path>, <fd>.

symlink (POSIX) <unistd.h>
int symlink(const char *oldpath, const char *newpath);
Создание символьной ссылки <newpath> на файл <oldpath>.

write, writev (POSIX) <unistd.h, sys/uio.h>
ssize_t write(int fd, const void *buf, size_t count);
int writev(int fd, const struct iovec * vector, int count);
Записывает <count. байтов из буфера <buf> или вектора <vector> в файл <fd>.

unlink (POSIX) <unistd.h>
int unlink(const char *pathname);
Удаляет имя файла из файловой системы. Если это имя было последней ссылкой на файл и нет ни одного процесса, которые бы открыли этот файл, то файл удаляется.

Таблица 10. Стандартные потоки ввода-вывода

2.2.4 Функции работы с временными файлами

mkstemp (BSD) <stdlib.h>
int mkstemp(char *template);
Создает временный файл с уникальным именем определённым <template>. <template> должен иметь в конце символы “XXXXXX”. Возвращает описатель fd созданного файла и заполняет XXXXXX, в template, сгенерированными символами. Нуждается в удалении!

mktemp (POSIX) <stdlib.h>
char *mktemp(char *template);
Создает временный файл с уникальным именем определённым <template>. <template> должен иметь в конце символы “XXXXXX”. Возвращает имя созданного файла.

tmpfile (POSIX) <stdio.h>
FILE *tmpfile (void);
Создает уникальное имя временного файла с помощью префикса пути P_tmpdir, определенного в <stdio.h>. Файл автоматически удаляется при его закрытии или в случае завершения основной программы.

2.3 Функции поддержки переменного числа параметров <stdarg.h>

va_arg (ANSI)
type va_arg(va_list arg_ptr, type);
Значение параметра типа <type> выбирается из стека <arg_ptr>, по одному за каждое обращение к функции. Макрокоманда <va_arg> может использоваться любое число раз для отыскания параметров в списке.

va_end (ANSI)
void va_end(va_list arg_ptr);
Присваивает аргументу-указателю <arg_ptr> значение запрещающее его последующее использование (без повторной инициализации va_start).

va_start (ANSI)
void va_start(va_list arg_ptr, prev_param);
Назначает указателю <arg_ptr> адрес первого параметра в стеке входных параметров <prev_param>.

2.4 Функции/переменные работы со временем и временными интервалами

alarm (SVr4, SVID, POSIX, X/OPEN, BSD 4.3) <unistd.h>
unsigned int alarm(unsigned int seconds);
Настраивающая таймер на подачу сигнала ALARM.

asctime, ctime (POSIX) <time.h>
char *asctime(const struct tm *timeptr);
char *ctime(const time_t *timep);
Преобразует время <timep>, <timeptr> в строку в формате «Wed Jun 30 21:49:08 1993».

clock_gettime, clock_getres, clock_settime (POSIX) <time.h>
int clock_getres(clockid_t clock_id, struct timespec *res);
int clock_gettime(clockid_t clock_id, struct timespec *tp);
int clock_settime(clockid_t clock_id, const struct timespec *tp);
Функции манипуляции системными часами <clock_id>. В соответствии со стандартом POSIX должны поддерживаться часы: CLOCK_MONOTONIC, CLOCK_MONOTONIC_HR, CLOCK_REALTIME и CLOCK_REALTIME_HR.

daylight (POSIX) <time.h>
extern int daylight;
Переход на летнее время.

gmtime, localtime (POSIX) <time.h>
struct tm *gmtime(const time_t *timep);
struct tm *localtime(const time_t *timep);
Преобразуют календарное время <timep> во время по Гринвичу и локальное;

mktime (POSIX) <time.h>
time_t mktime(struct tm *timeptr);
Преобразует структуру локального представления <timeptr> времени в структуру календарного представления.

setitimer, getitimer (POSIX.1–2001) <sys/time.h>
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);
int getitimer(int which, struct itimerval *value);
Получить и установить значение value интервального таймера <which>. Старое значение таймера сохраняется в <ovalue>. Типы таймеров <which>:

• ITIMER_REAL – декремент в реальном времени(РВ) и вызывает SIGALARM;
• ITIMER_VIRTUAL – декремент только при выполнении процесса и вызывает SIGVTALRM;
• ITIMER_PROF – декремент при выполнении процесса и при выполнении системы на защите процесса, вызывает SIGPROF.

strftime (ANSI) <time.h>
size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);
Форматирует время <tm> в соответствии с указанным форматом <format> и помещает результат в символьный массив <s> размером <max>.

time (POSIX) <time.h>
time_t time(time_t *t);
Возвращает/устанавливает текущее время <t>

timer_create (POSIX) <time.h, signal.h>
int timer_create(clockid_t clockid, struct sigevent *restrict evp, timer_t *restrict timerid);
Создание таймера используя часы <clockid> (CLOCK_REALTIME, CLOCK_MONOTONIC) в соответствии со структурой уведомления <evp>. В результате успешного создания таймера возвращается идентификатор <timerid>.

timer_delete (POSIX) <time.h>
int timer_delete(timer_t timerid);
Удаление таймера ранее созданного функцией timer_create().

timer_gettime (POSIX) <time.h>
int timer_gettime(timer_t timerid, struct itimerspec *value);
Получение значения таймера, созданного функцией timer_create(), в <value>.

timer_settime (POSIX) <time.h>
//int timer_settime(timer_t timerid, int flags, const struct itimerspec *restrict value, struct itimerspec *restrict ovalue);
Установка таймера, созданного функцией timer_create(), в значение <value>, предварительно сохранив предыдущее значение в <ovalue>.

times (POSIX) <sys/times.h>
clock_t times(struct tms *buf);
Возвращает текущие состояние счетчика тиков, а также информации о времени выполнения процесса и его порожденных процессов в <buf>.

timezone (POSIX) <time.h>
long int timezone;
Содержит разницу, в секундах, между локальным временем и по Гринвичу.

tzname (POSIX) <time.h>
extern char *tzname[2];
Имя текущей временной зоны.

sleep, usleep, nanosleep (POSIX) <unistd.h, time.h>
unsigned int sleep(unsigned int seconds);
void usleep(unsigned long usec);
int nanosleep(const struct timespec *req, struct timespec *rem);
Функция задаёт интервал паузы: seconds – секунды, usec – микросекунды и req – наносекундах. В rem помещается реально прошедшее время.

2.5 Функции проверки и преобразования символов <ctype.h, cctype>

isalnum (ANSI)
int isalnum(int c);
Проверяет символ на принадлежность к текстовым символам.

isalpha (ANSI)
int isalpha(int c);
Проверяет символ на принадлежность к алфавитным символам (в стандартном окружении “C”).

isascii (ANSI)
int isascii(int c);
Проверяет, является ли <c> 7-битным unsigned char, значение которого попадает в таблицу символов ASCII.

iscntrl (ANSI)
int iscntrl(int c);
Проверяет, является ли символ управляющим.

isdigit (ANSI)
int isdigit(int c);
Проверяет, является ли символ цифрой.

isgraph (ANSI)
int isgraph(int c);
Проверяет, является ли символ печатаемым (не пробел).

islower (ANSI)
int islower(int c);
Проверяет, является ли символ символом нижнего регистра.

isprint (ANSI)
int isprint(int c);
Проверяет, является ли символ печатаемым (включая пробел).

ispunct (ANSI)
int ispunct(int c);
Проверяет, является ли символ печатаемым (не должен быть пробелом или текстовым символом).

isspace (ANSI)
int isspace(int c);
Проверяет, являются ли символы неотображаемыми.

isupper (ANSI)
int isupper(int c);
Проверяет, расположен ли символ в верхнем регистре.

isxdigit (ANSI)
int isxdigit(int c);
Проверяет, принадлежит ли символ к шестнадцатеричному числу.

toascii (ANSI)
int toascii(int c);
Преобразует <c> в 7-битное значение unsigned char, т.е. превращает его в ASCII-символ посредством «сбрасывания» старшего бита.

toupper, tolower (ANSI)
int toupper(int c);
int tolower(int c);
Преобразует символ <c> к верхнему или нижнему регистру.

2.6 Функции работы со строками

atof (POSIX) <stdlib.h, cstdlib>
double atof(const char *nptr);
Преобразует строку <nptr> в вещественное число типа double.

atoi, atol, atoll, atoq (POSIX) <stdlib.h, cstdlib>
int atoi(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);
long long atoq(const char *nptr);
Преобразуют строку в целое число.

bzero (BSD) <string.h>
void bzero(void * s, size_t n );
Заполняет нулями байты строки.

ecvt, fcvt, gcvt <stdlib.h, cstdlib>
char *ecvt(double number, int ndigits, int *decpt, int *sign);
char *fcvt(double number, int ndigits, int *decpt, int *sign);
char *gcvt(double number, size_t ndigit, char *buf);
Преобразует число с плавающей точкой в строку.

strcat, strncat (POSIX) <string.h>
char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
Добавляет строку <str> (n символов для strncat) к строке <dest>, перезаписывая символ окончания в конце <dest> и добавляя к строке символ окончания.

strchr,strrchr (POSIX) <string.h>
char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);
Определение местонахождения символа в строке.

strcmp, strncmp (POSIX) <string.h>
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
Сравнивает две (n символов для strncmp) строки: s1 и s2. Возвращая целое число, которое меньше, больше нуля или равно ему, если s1 соответственно меньше, больше или равно s2.

strcpy, strncpy (POSIX) <string.h>
char *strcpy(char *dest, const char *src);
char *strncpy(char *dest, const char *src, size_t n);
Копирует строку (n символов для strncpy), на которую указывает <src> (включая завершающий символ окончания), в массив, на который указывает <dest>.

strdup, strndup, strdupa, strndupa (BSD) <string.h>
char *strdup(const char *s);
char *strndup(const char *s, size_t n);
char *strdupa(const char *s);
char *strndupa(const char *s, size_t n);
Дублируют строку;

strerror (POSIX) <string.h>
char *strerror(int errnum);
Возвращает строку с описанием кода ошибки, переданного в аргументе errnum.

strlen (POSIX) <string.h>
size_t strlen(const char *s);
Вычисляет длину строки <s>. Завершающий символ окончания не учитывается.

strpbrk (POSIX) <string.h>
char *strpbrk(const char *s, const char *accept);
Ищет первое совпадение в строке <s> с любым символом из строки <accept>.

strspn, strcspn (POSIX) <string.h>
size_t strspn(const char *s, const char *accept);
size_t strcspn(const char *s, const char *reject);
поиск набора символов в строке.

strstr <string.h>
char *strstr(const char *haystack, const char *needle);
Находит первую встретившуюся подстроку <needle> в строке <haystack>.

strtok, strtok_r (POSIX) <string.h>
char *strtok(char *s, const char *delim);
char *strtok_r(char *s, const char *delim, char **ptrptr);
Разбивает строку <s> на «лексемы» логические куски, такие, как слова в строке текста – разделённые символами, содержащимися в <delim>. Последующие вызовы производить с <s> = NULL.

strtod, strtof, strtold (ANSI) <stdlib.h, cstdlib>
double strtod(const char *nptr, char **endptr);
float strtof(const char *nptr, char **endptr);
long double strtold(const char *nptr, char **endptr);
Конвертируют строки ASCII в число с плавающей запятой.

strtoul, strtoull (POSIX) <stdlib.h, cstdlib>
unsigned long int strtoul(const char *nptr, char **endptr, int base);
unsigned long long int strtoull(const char *nptr, char **endptr, int base);
Конвертирует строку в беззнаковое целое число.

strxfrm (BSD) <string.h>
size_t strxfrm(char *dest, const char *src, size_t n);
Преобразует строку <src> в такую форму, что выполнение strcmp() над двумя такими строками, преобразованными посредством strxfrm(), будет таким же, как и выполнение strcoll над исходными строками.

2.7 Потоковая обработка строк <string>

Для работы со строками в языке C++ предусмотрен шаблонный класс basic_string из которого определяется класс string:

Примеры инициализации строк:

Для потоковой обработки строк используются классы: <ostringstream>

2.7.1 Функции

operator==, !=, >, <, >=, <=
Операторы сравнения строк.

assign
basic_string& assign (const basic_string& str, size_type pos = 0, size_type n = npos);
basic_string& assign (const charT* s, size_type n);
basic_string& assign (const charT* s);
basic_string& assign (size_type n, charT c);
Создаёт новую строку из участка старой.

append
basic_string& append(const basic_string& str, size_type pos = 0, size_type n = npos);
basic_string& append (const charT* s, size_type n);
basic_string& append (const charT* s);
basic_string& append (size_type n, charT c);
basic_string& append(InputIterator first, InputIterator last);
Добавление к строке.

at
reference at(size_type pos);
const_reference at(size_type pos) const;
Получить символ по с индексом <POS>.

begin, end
iterator begin ();
iterator end ();
Возвращает итератор;

capacity
size_type capacity() const;
Максимальный размер строки без увеличения памяти под строку.

compare
int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const;
int compare (const charT* s, size_type pos, size_type n) const;
int compare (const charT* s, size_type pos = 0) const;
Сравнение строк.

copy
size_type copy (charT* s, size_type n, size_type pos = 0) const;
Копировать строку в адрес определённый указателем.

с_str
const charT* c_str() const;
Возвращает указатель на строку с нулём в конце.

data
charT* data()
Возвращает указатель на строку без нуля в конце.

empty
bool empty() const;
Проверка строки на пустоту.

erase
basic_string& erase(size_type pos = 0, size_type n = npos);
iterator erase(iterator p);
iterator erase(iterator f, iterator l);
Удаление всех символов начиная от указанной позиции.

begin, end
iterator begin();
iterator end();
Получение начального/конечного итератора.

find, rfind
size_type find(const basic_string& str, size_type pos = 0) const;
size_type rfind(const basic_string& str, size_type pos = npos) const;
Поиск сначала/конца строки.

find_first_of, find_last_of
size_type find_first_of(const basic_string& str, size_type pos = 0) const;
size_type find_last_of (const basic_string& str, size_type pos = npos) const;
Поиск сначала/конца строки одного из перечисленных символов.

find_first_not_of, find_last_not_of
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const;
size_type find_last_not_of (const basic_string& str, size_type pos = npos) const;
Поиск сначала/конца первого символа отсутствующего в списке.

insert
basic_string& insert(size_type pos1, const basic_string& str, size_type pos2 = 0, size_type n = npos);
Вставка в строку части другой строки.

length, size
size_type length() const;
size_type size() const;
Длина строки.

max_size
size_type max_size() const;
Максимальная длина строки.

replace
basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2 = 0, size_type n2 = npos);
Заменить участок строки.

resize
void resize (size_type n, charT c);
void resize (size_type n);
Изменить длину строки.

substr
basic_string substr(size_type pos = 0, size_type n = npos) const;
Получение части строки;

swap
void swap (basic_string &s)
Перестановка строк.

2.8 Стандартная библиотека шаблонов (STL)

STL представляет собой большую библиотеку шаблонов включающую в себя три ключевых компонента: контейнеры, итераторы, алгоритмы. Кроме того, STL является расширяемой библиотекой. STL избегает операторов new и delete и использует распределители памяти(allocators) для выделения и высвобождения памяти. Существует возможность создавать пользовательские распределители памяти. Типы исключений в STL:

• out_of_range – индекс находится вне диапазона;
• invalid_argument – передача недопустимого аргумента функции;
• length_error – создание слишком длинного контейнера;
• bad_alloc – неудачная попытка выделения области памяти.

2.8.1 Контейнеры

Контейнеры делятся на три основных категории: контейнеры последовательностей, ассоциативные контейнеры и адаптеры контейнеров. Контейнеры последовательностей (sequence containers) и Ассоциативные контейнеры имеют общее название – контейнеры первого класса (first-class containers). Существует ещё четыре типа контейнеров, которые считаются «почти контейнерами» («near-containers») – С-подобные массивы, string, bitset и valarray.

Контейнерные заголовочные файлы стандартной библиотеки:

• <vector>
• <list>
• <deque>
• <queue> – cодержит как queue, так и priority_queue;
• <stack>
• <map> – Содержит как map, так и multimap;
• <set> – Содержит как set, так и multiset;
• <bitset>

Общие имена типа typedef имеющиеся в контейнерах первого класса:

• value_type – тип элемента, хранимого в контейнере;
• reference – ссылка на тип элемента, хранимого в контейнере;
• const_reference – ссылка-константа на тип элемента, хранимого в контейнере;
• pointer – указатель на тип элемента, хранимого в контейнере;
• iterator – итератор; указывает на тип элемента, хранимого в контейнере;
• const_iterator – констатный итератор; указывает на тип элемента, хранимого в контейнере;
• reverse_iterator – обратный итератор; указывает на тип элемента, хранимого в контейнере;
• const_reverse_iterator – константный обратный итератор, который указывает на тип элемента, хранимого в контейнере;
• difference_type – тип результата вычитания двух итераторов, которые ссылаются на один и тот же контейнер;
• size_type – тип, используемый для подсчёта элементов в контейнере и для индексации в контейнере последовательности.

Контейнеры последовательностей

Классы vector и deque реализованы на базе массивов. Класс list реализует связанный список. Дополнительные операции характерные для контейнеров последовательностей:

front
front();
Возвращает ссылку на первый элемент в контейнере.

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

push_back
push_back();
Вставляет новый элемент в конец контейнера.

pop_back
pop_back();
Выталкивает последний элемент контейнера.

Контейнер vector обеспечивает структуру данных непрерывной областью памяти. Это позволяет обеспечивает эффективный прямой доступ к любому элементу контейнера vector посредством операции индексирования []. Все алгоритмы STL могут работать с контейнером vector. Итераторы для vector обычно реализуются как указатели на элементы контейнера vector.

Контейнер list предоставляет эффективную реализацию операции вставки и удаления в любую позицию контейнера. Класс list реализуется как двухсвязный список, то есть каждый узел в list содержит указатель на предыдущий и на следующий узел. Любой алгоритм, который требует итераторов для чтения и для записи, прямых и двунаправленных итераторов, может выполняться с list. Дополнительные функции класса list:

inplace_merge
void inplace_merge(_BidirectionalIter first, _BidirectionalIter middle, _BidirectionalIter last, _Compare comp);
Объединяет две возростающие последовательности в одном и том же контейнере.

splice
splice();
Вырезает элементы из одного контейнера и помещает их в другой.

push_front
push_front();
Вставить элемент в начало контейнера.

pop_front
pop_front();
Вытолкнуть элемент с начала контейнера.

remove
remove();
Удалить элемент из начала контейнера.

merge
_OutputIter merge(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2, _OutputIter result)
Объединяет две возростающие последовательности в одну.

sort
void sort(_RandomAccessIter first, _RandomAccessIter last);
Сортировка элементов в возрастающем порядке.

Контейнер deque объединяет многие возможности классов vector и list. Реализуется на основе очереди с двумя концами и обеспечивает эффективный индексный доступ с эффективной операцией вставки в начало и конец контейнера. Класс deque обеспечивает поддержку итераторов произвольного доступа. Наиболее часто deque используется в качестве очереди FIFO.

Ассоциативные контейнеры

Ассоциативные контейнеры STL предназначены для обеспечения прямого доступа с целью сохранения и выборки элементов с помощью ключей (ключи поиска). Имеется четыре ассоциативных контейнера: multiset, set, multimap, map. В каждом контейнере ключи сохраняются упорядоченными. Ассоциативные контейнеры поддерживают дополнительные функции:

equal_range
pair<_ForwardIter, _ForwardIter> equal_range(_ForwardIter first, _ForwardIter last, const _Tp& val);
Возвращает пару прямых итераторов, содержащих результаты lower_bound и upper_bound.

find
find();
Поиск ключа.

lower_bound
_ForwardIter __lower_bound(_ForwardIter first, _ForwardIter last, const _Tp& val, _Distance*)
Определения позиции первого вхождения указанного ключа.

upper_bound
_ForwardIter upper_bound(_ForwardIter first, _ForwardIter last, const _Tp& val)
Определения позиции за последним вхождением указанного ключа.

count
count();
Возвращает количество указанных ключей в контейнере.

Контейнеры multiset и set используются для быстрого сохранение и выборки ключей. Контейнер multiset допускает использование одинаковых ключей. Упорядочение элементов определяется компараторным объектом-функцией. Контейнеры поддерживает двунаправленные итераторы (но не итераторы произвольного доступа).

Контейнеры multimap и map используются для быстрого сохранения и нахождения ключей и ассоциированных значений (пара ключ/значение). При вставке в эти контейнеры используется объект pair. Контейнер multimap позволяет ассоциировать несколько значений с одним ключем. Упорядочение элементов определяется компараторным объектом-функцией. Контейнеры поддерживает двунаправленные итераторы (но не итераторы произвольного доступа).

Адаптеры контейнеров

STL предоставляет три адаптера контейнера – stack, queue, priority_queue. Адаптеры не являются контейнерами первого класса, поскольку они не предоставляют реализации фактической структуры данных в которой могут сохраняться элементы, и поскольку адаптеры не поддерживают итераторы. Все три класса адаптеров предоставляют функции-члены push и pop, которые реализуют соответствующий метод вставки элемента.

Адаптер stack обеспечивает структуру LIFO и может быть реализован с любым из контейнеров последовательности. Адаптер queue обеспечивает структуру FIFO и может быть реализован с контейнерами list и deque. Адаптер priority_queue обеспечивает очередь в которой наиболее приоритетное значение всегда будет удаляться первым. priority_queue может быть реализован с контейнерами vector и deque. Сравнение элементов выполняется с помощью функции-объекта less<T>.

2.8.2 Итераторы

Итераторы схожи с указателями и используются для указания на элементы контейнеров первого класса. STL контейнеры первого класса предоставляют функции-члены begin() и end(), которые возвращают итератор указывающий соответственно на первый и последний элемент контейнера. Если итератор i указывает на определённый элемент, то ++i указывает на «следующий» элемент, а *i ссылается на элемент, на который указывает i. Итератор, полученый из функции end(), может использоваться в сравнении на равенство и неравенство для определения окончания «движущегося итератора». Для ссылки на элемент контейнера используется объект типа iterator или const_iterator.

Категории итераторов:

• input – Используется для чтения элементов из контейнера. Итератор для чтения может перемещаться только по направлению вперёд и поддерживает только однопроходные алгоритмы.
• output – Используется для записи элемента в контейнер. Итератор для записи может перемещаться только по направлению вперёд и поддерживает только однопроходные алгоритмы.
• forward – Объединяет возможности итераторов для чтения и для записи и сохраняет их позицию в контейнере.
• bidirectional – Объединяет возможности однонаправленного итератора с возможностью перемещаться в обратном направлении.
• random access – Объединяет возможности двунаправленного итератора с возможностью прямого доступа к любому элементу контейнера.

Категория итератора, поддерживаемая каждым контейнером, определяет, может ли этот контейнер использоваться со специфическими алгоритмами в STL.

2.8.3 Алгоритмы

Контейнеры инкапсулируют некоторые базовые операции, но STL-алгоритмы реализуются независимо от контейнеров. Алгоритмы оперируют элементами контейнеров только с помощью итераторов. Можно создавать собственные алгоритмы.

Алгоритмы, модифицирующие последовательности

copy
copy();
Копирование.

copy_backward
_BidirectionalIter2 __copy_backward(_BidirectionalIter1 first, _BidirectionalIter1 last, _BidirectionalIter2 result, bidirectional_iterator_tag, _Distance*)
Обратное копирование части одного контейнера в другой контейнер.

fill
void fill(_ForwardIter first, _ForwardIter last, const _Tp& value);
Заполняет все элементы контейнера значением <value>.

fill_n
_OutputIter fill_n(_OutputIter first, _Size n, const _Tp& value);
Заполняет указанные элементы контейнера значением <value>.

generate
void generate(_ForwardIter first, _ForwardIter last, _Generator gen)
Заполняет все элементы контейнера значением возвращаемым функцией <gen>.

generate_n
generate_n();
Заполняет указанные элементы контейнера значением возвращаемым функцией <gen>.

iter_swap
void iter_swap(_ForwardIter1 a, _ForwardIter2 b);
Перестановка значений контейнера (по ссылке).

includes
bool includes(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2);
Проверяет находятся ли элементы второго множества в первом.

next_permutation
bool next_permutation(_BidirectionalIter first, _BidirectionalIter last);
Следующая перестановка в лексикографическом порядке.

prev_permutation
bool prev_permutation(_BidirectionalIter first, _BidirectionalIter last);
Предыдущая перестановка в лексикографическом порядке.

partition
_ForwardIter partition(_ForwardIter first, _ForwardIter last, _Predicate pred);
Разделение диапазонов элементов.

remove
_ForwardIter remove(_ForwardIter first, _ForwardIter last, const _Tp& value);
Удаление из указанного участка контейнера всех указанных объектов <value>

remove_copy
_OutputIter remove_copy(_InputIter first, _InputIter last, _OutputIter result, const _Tp& value);
Перенос из указанного участка контейнера в другой контейнер всех указанных объектов <value>.

remove_copy_if
remove_copy_if();
Перенос из указанного участка контейнера в другой контейнер объектов выбранных функцией сравнения <pred>.

remove_if
_ForwardIter remove_if(_ForwardIter first, _ForwardIter last, _Predicate pred);
Удаление из указанного участка контейнера объектов выбранных функцией сравнения <pred>

replace
void replace(_ForwardIter first, _ForwardIter last, const _Tp& old_value, const _Tp& new_value);
Производит замену объекта <old_value> на <new_value> по указанному участку контейнера.

replace_copy
_OutputIter replace_copy(_InputIter first, _InputIter last, _OutputIter result, const _Tp& old_value, const _Tp& new_value);
Производит замену объекта <old_value> на <new_value> по указанному участку контейнера и помещений старых значений в контейнер <result>.

replace_copy_if
_OutputIter replace_copy_if(Iterator first, Iterator last, _OutputIter result, _Predicate pred, const _Tp& new_value);
Производит замену объекта выбраного функцией <pred> на <new_value> по указанному участку контейнера и помещений старых значений в контейнер <result>.

replace_if
void replace_if(_ForwardIter __first, _ForwardIter last, _Predicate pred, const _Tp& new_value);
Производит замену объекта выбраного функцией <pred> на <new_value> по указанному участку контейнера.

reverse
void reverse(_BidirectionalIter first, _BidirectionalIter last, bidirectional_iterator_tag);
Инвертирование последовательности указанных элементов контейнера./

reverse_copy
_OutputIter reverse_copy(_BidirectionalIter first, _BidirectionalIter last, _OutputIter result);
Копирует указанные элементы в обратном порядке.

rotate
_ForwardIter rotate(_ForwardIter first, _ForwardIter middle, _ForwardIter last);
Ротация элементов.

rotate_copy
_OutputIter rotate_copy(_ForwardIter first, _ForwardIter middle, _ForwardIter last, _OutputIter result);
Ротация элементов с копированием.

set_difference
_OutputIter set_difference(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2, _OutputIter result);
Определение элементов из первого множества отсутствующих во втором.

set_intersection
_OutputIter set_intersection(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2, _OutputIter result);
Определение элементов из первого множества присутствующих во втором.

set_symmetric_difference
_OutputIter set_symmetric_difference(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2, _OutputIter result);
Определение элементов из первого множества отсутствующих во втором и элементов второго отсутствующих в первом.

set_union
_OutputIter set_union(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2, _OutputIter result);
Создаёт множество отсортированных элементов их двух контейнеров в третьем.

stable_partition
_ForwardIter stable_partition(_ForwardIter first, _ForwardIter last, _Predicate pred);
Подобна partition.

swap
void swap(_Tp& a, _Tp& b);
Перестановка значений контейнера.

swap_ranges
_ForwardIter2 swap_ranges(_ForwardIter1 first1, _ForwardIter1 last1, _ForwardIter2 first2);
Перестановка группы элементов контейнера.

transform
transform();
-//-

unique
_ForwardIter unique(_ForwardIter first, _ForwardIter last);
Удаляет из контейнера одинаковые элементы

unique_copy
_OutputIter unique_copy(_InputIter first, _InputIter last, _OutputIter result, _Tp*);
Копирует все уникальные элементы в другой контейнер.

Алгоритмы, не модифицирующие последовательности

adjacent_find
_ForwardIter adjacent_find(_ForwardIter first, _ForwardIter last, _BinaryPredicate binary_pred);
Возвращает итератор для чтения, указывающий на первый из двух идентичных смежных элементов в последовательности.

equal
inline bool equal(_InputIter1 first1, _InputIter1 last1,_InputIter2 first2);
Сравнение указанных участков двух контейнеров.

find
_InputIter find(_InputIter first, _InputIter last, const _Tp& val, input_iterator_tag);
Возвращает положение искомого значения <val>

find_each
find_each();
-//-

find_end
find_end();
-//-

find_first_of
find_first_of();
-//-

find_if
InputIter find_if(_InputIter first, _InputIter last, _Predicate pred, input_iterator_tag);
Возвращает положение значения определённого функцией <pred>.

lexicographical_compare
bool lexicographical_compare(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2, _InputIter2 last2);
Используется для лексикографического сравнения двух массивов символов.

max
const _Tp& max(const _Tp& a, const _Tp& b);
Определение максимального значения.

min
const _Tp& min(const _Tp& a, const _Tp& b);
Определения минимального значения.

mismatch
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 first1, _InputIter1 last1, _InputIter2 first2);
Выполняет сравнение указанных участков двух контейнеров и возвращает пару итераторов указывающих различные позиции контейнеров.

search
search();
-//-

search_n
search_n();
-//-

Числовые алгоритмы <numeric>

accumulate
_Tp accumulate(_InputIterator first, _InputIterator last, _Tp init);
Суммирование значений указанной области контейнера.

adjacent_difference
_OutputIterator adjacent_difference(_InputIterator first, _InputIterator last, _OutputIterator result);
Вычисление разницы между парой смежных элементов

count
void count(_InputIter first, _InputIter last, const _Tp& value,_Size& n);
Выполняет подсчет количества объектов <value> в указанной области контейнера.

count_if
void count_if(_InputIter first, _InputIter last, _Predicate pred, _Size& n);
Выполняет подсчет количества объектов выбранных функцией <pred> в указанной области контейнера.

for_each
_Function for_each(_InputIter first, _InputIter last, _Function f);
Применение функции <f> к указанным элементам контейнера. Общая функция должна принимать текущий элемент в качестве аргумента и не должна модифицировать этот элемент.

inner_product
_Tp inner_product(_InputIterator1 first1, _InputIterator1 last1, _InputIterator2 first2, _Tp init);
Вычисление суммы произведений двух последовательностей.

max_element
_ForwardIter max_element(_ForwardIter first, _ForwardIter last);
Возвращает указатель на максимальный элемент в контейнере.

min_element
_ForwardIter min_element(_ForwardIter first, _ForwardIter last);
Возвращает указатель на минимальный элемент в контейнере.

nth_element
void nth_element(_RandomAccessIter first, _RandomAccessIter nth, _RandomAccessIter last);
Разделение диапазонов элементов.

partial_sum
_OutputIterator partial_sum(_InputIterator first, _InputIterator last, _OutputIterator result);
Вычисление суммы элементов двух контейнеров с накоплением.

partial_sort
void partial_sort(_RandomAccessIter first, _RandomAccessIter middle, _RandomAccessIter last);
Сортировка части последовательности.

partial_sort_copy
_RandomAccessIter partial_sort_copy(_InputIter first, _InputIter last, _RandomAccessIter result_first, _RandomAccessIter result_last);
Сортировка части последовательности с копированием результата.

random_shuffle
inline void random_shuffle(_RandomAccessIter first, _RandomAccessIter last);
Располагает элементы указанного участка контейнера в произвольном порядке.

stable_sort
void stable_sort(_RandomAccessIter first, _RandomAccessIter last);
Сортировка (аналогично sort)

transform
_OutputIter transform(_InputIter first, _InputIter last, _OutputIter result, _UnaryOperation oper);
Применение функции <f> к указанным элементам контейнера. Общая функция должна принимать текущий элемент в качестве аргумента, не должна модифицировать этот элемент и должна возвращать трансформированное значение.

Алгоритмы, сортировки кучи

make_heap
make_heap(_RandomAccessIterator first, _RandomAccessIterator last);
Создание и инициализация кучи.

pop_heap
void pop_heap(_RandomAccessIterator first, _RandomAccessIterator last);
Удаление элемента с вершины кучи.

push_heap
void push_heap(_RandomAccessIterator first, _RandomAccessIterator last);
Добавление нового элемента в кучу.

sort_heap
sort_heap(_RandomAccessIterator first, _RandomAccessIterator last, _Compare comp);
Сортировка последовательности значений.

2.8.4 Класс <bitset>

Класс bitset обеспечивает операции для создания и манипуляции наборами битов. Наборы битов имеют фиксированный размер: bitset<size> b;. Операции:

set
Установка указанного бита.

reset
Сброс указанного бита.

flip
Переключает бит.

at
Получить бит.

test
Проверка бита.

size
Возвращает число битов в наборе.

count
Возвращает число установленных битов.

any
Возвращает true если хоть один бит в наборе установлен.

none
Возвращает true если не один бит в наборе неустановлен.

==, !=
Сравнение наборов битов.

&=, |=, ^ =, >>=, <<=
Битовые операции над наборами битов.

to_string
Преобразует набор битов в строку.

to_ulong
Преобразует набор битов в unsigned long.

2.8.5 Объекты-функции

Объекты-функции и адаптеры-функций предназначены для того чтобы сделать STL более гибкой. Объект-функция содержит функцию, которая может быть интерпретирована с синтаксической и семантической точки зрения как функция, использующая operator(). Объекты-функции STL:

divides<T> – арифметический;
equal_to<T> – реляционный;
greater<T> – реляционный;
greater_equal<T> – реляционный;
less<T> – реляционный;
less_equal<T> – реляционный;
logical_and<T> – логический;
logical_not<T> – логический;
logical_or<T> – логический;
minus<T> – арифметический;
moduls<T> – арифметический;
negate<T> – арифметический;
not_equal_to<T> – реляционный;
plus<T> – арифметический;
multiplies<T> – арифметический;

2.9 функции работы с памятью

calloc, malloc, free, realloc (ANSI) <stdlib.c, cstdlib>
void *calloc(size_t nmemb, size_t size);
void *malloc(size_t size);
void free(void *ptr);
void *realloc(void *ptr, size_t size);
Распределяют и освобождают динамическую память.
calloc – выделяет блок памяти с очисткой;
malloc – выделяет блок памяти;
free – освобождает блок памяти;
realloc – меняет размер блока памяти;

delete (C++)
delete terget;
Освобождает динамическую память, выделенную с помощью оператора new. Кроме того оператор delete активизирует деструктор объекта:

memchr, memrchr (POSIX) <string.h>
void *memchr(const void *s, int c, size_t n);
void *memrchr(const void *s, int c, size_t n);
Ищет символ <c> в первых/последних <n> байтах той области памяти, на которую указывает <s>. Совпадение первого байта с <c> (представленным как беззнаковый символ) останавливает выполнение операции.

memcmp (BSD) <string.h>
int memcmp(const void *s1, const void *s2, size_t n);
Сравнивает первые <n> байтов областей памяти <s1> и <s2>. Возвращается целое число, меньшее, большее нуля или равное ему, если определено, что <s1> меньше, больше, или равно <s2>.

memcpy (BSD) <string.h>
void *memcpy(void *dest, const void *src, size_t n);
Копирует <n> байтов из области памяти <src> в область памяти <dest>.

memmove (BSD) <string.h>
void *memmove(void *dest, const void *src, size_t n);
Копирует <n> байтов из области памяти <src> в область памяти <dest>. Области памяти могут перекрываться.

memset (BSD) <string.h>
void *memset(void *s, int c, size_t n);
Заполняет первые <n> байтов области памяти <s> байтом <c>.

mlock, munlock (POSIX) <sys/mman.h>
int mlock(const void *addr, size_t len);
int munlock(const void *addr, size_t len);
Запрещает/разрешает страничный обмен памяти в области, начинающейся с адреса <addr> длиной <len> байтов.

mlockall, munlockall (POSIX) <sys/mman.h>
int mlockall(int flags);
int munlockall(void);
Запрещает/разрешает страничный обмен для всех страниц в области памяти вызывающего процесса.

mmap, munmap (POSIX) <unistd.h, sys/mman.h>
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *start, size_t length);
mmap – возвращает адрес отражённых <length> байтов, начиная со смещения <offset> файла (или другого объекта), определённого файловым описателем <fd>, в память, начиная с адреса <start>. munmap – удаляет все отражения из заданной области памяти.

mprotect (POSIX) <sys/mman.h>
int mprotect(const void *addr, size_t len, int prot);
Контролирует доступ <prot> к области памяти <addr> <len>.

msync (POSIX) <unistd.h, sys/mman.h>
int msync(const void *start, size_t length, int flags);
Записывает на диск изменения, внесенные в файл, отраженный в память при помощи функции mmap.

new (C++)
Type *array = new Type[256];
Используется для динамического выделения памяти (для размещения объекта в свободной памяти). Указателю array присваивается адрес выделенной памяти или присваивается NULL при её отсутствии. Оператор new автоматически активизирует конструктор объекта. Если определена функция _new_handler то она вызывается при отсутствии памяти. Способы применения оператора new:

set_new_handler (C++) <new.h | new>
void set_new_handler(void (*VFP)());
Присваивает адресу глобальной переменной _new_handler адрес функции <VFP> обработки ошибок оператора new.

2.10 Работа с терминалом

isatty (SVID, AT&T, X/OPEN, BSD 4.3) <unistd.h>
int isatty(int desc);
Определяет, ссылается ли данный описатель на терминал.

tcgetattr, tcsetattr <termios.h, unistd.h>
int tcgetattr(int fd, struct termios *termios_p);
int tcsetattr(int fd, int optional_actions, struct termios *termios_p);
Получить/установить атрибуты терминала.

ttyname (POSIX.1) <unistd.h>
char *ttyname(int desc);
Возвращает название терминала.

2.11 Работа с динамическими библиотеками

dlopen (*NIX) <dlfcn.h>
void *dlopen (const char *filename, int flag);
Открывает и возвращает адрес динамической библиотеки <filename> с флагами <flag>.

dlerror (*NIX) <dlfcn.h>
char *dlerror()
Возвращает текстовую строку ошибки возникшей при работе с динамической библиотекой.

dlsym (*NIX) <dlfcn.h>
void *dlsym(void *handle, char *symbol);
Получить адрес функции с именем <symbol> которая ищется в библиотеке <handle>

mycomdlclose (*NIX) <dlfcn.h>
int dlclose(void *handle);
Закрытие, ранее открытой динамической библиотеки

_init() (*NIX)
Выполняется при открытии динамической библиотеки

_fini() (*NIX)
Выполняется при закрытии динамической библиотеки

2.12 Лимитирование

getrlimit (*NIX) <sys/resource.h>
Получение различных лимитов для пользователя.

setrlimit (*NIX) <sys/resource.h>
Устанавливает различные лимиты для пользователя.

getrusage (*NIX) <sys/resource.h>
Получение различных лимитов и статистики использования ресурсов для пользователя.

ulimit (SVID) <ulimit.h>
long ulimit(int cmd, long newlimit);
Установка или определение ограничений пользователя.

2.13 Документирование и ведение логов

openlog (BSD) <syslog.h>
void openlog(char *ident, int option, int facility);
Связывает с программой <facility>, ведущей системный журнал с опциями <option>. <indent> указывает на строку идентифицирующую программу генерирующую логи.

closelog (BSD) <syslog.h>
void closelog(void);
Закрывает описатель, используемый для записи данных в журнал.

syslog (BSD) <syslog.h>
void syslog(int priority, char *format, ...);
Создает сообщение для журнала из <format>, c приоритетом <priority>.

2.14 Функции управления безопасностью

chmod, fchmod (POSIX) <sys/types.h, sys/stat.h>
int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);
Изменяют режим доступа к файлу, заданному параметром <path> или описателем файла <fildes>.

chown, fchown, lchown (POSIX) <sys/types.h, unistd.h>
int chown(const char *path, uid_t owner, gid_t group);
int fchown(int fd, uid_t owner, gid_t group);
int lchown(const char *path, uid_t owner, gid_t group);
Смена владельца файла, или ссылки (lchown) на <owner> и группу <group>.

getgrnam, getgrnam_r (POSIX) <sys/types.h, pwd.h>
struct group *getgrnam(const char *name);
int getgrnam_r(const char *name, struct group *gbuf, char *buf, size_t buflen, struct group **gbufp);
Запрос записи про группу пользователей по её имени.

getgrgid, getgrgid_r (POSIX) <sys/types.h, pwd.h>
struct group *getgrgid(gid_t gid);
int getgrgid_r(gid_t gid, struct group *gbuf, char *buf, size_t buflen, struct group **gbufp);
Запрос записи про группу пользователей по её идентификатору.

getlogin, getlogin_r (POSIX) <unistd.h>
char *getlogin(void);
int getlogin_r(char *buf, size_t bufsize);
Получение имени пользователя управляющим терминалом (текущего пользователя).

getpwnam, getpwnam_r (POSIX) <sys/types.h, pwd.h>
struct passwd *getpwnam(const char *name);
int getpwnam_r(const char *name, struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
Запрос записи про пользователя по его имени.

getpwuid, getpwuid_r (POSIX) <sys/types.h, pwd.h>
struct passwd *getpwuid(uid_t uid);
int getpwuid_r(uid_t uid, struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
Запрос записи про пользователя по его идентификатору.

getuid, geteuid (POSIX) <unistd.h, sys/types.h>
uid_t getuid(void);
uid_t geteuid(void);
Возвращает идентификатор действительного/эффективного пользователя текущего процесса.

getgid, getegid (POSIX) <unistd.h, sys/types.h>
gid_t getgid(void);
gid_t getegid(void);
Возвращает идентификатор действительной/эффективной группы текущего процесса.

setreuid, setregid (BSD) <sys/types.h, unistd.h>
int setreuid(uid_t ruid, uid_t euid);
int setregid(gid_t rgid, gid_t egid);
Устанавливает действительный и действующий идентификатор пользователя/группы текущего процесса

setgid (SVID) <sys/types.h, unistd.h>
int setgid(gid_t gid);
Устанавливает идентификатор эффективной группы текущего процесса.

setuid (POSIX) <sys/types.h, unistd.h>
int setuid(uid_t uid);
Устанавливает фактический идентификатор владельца текущего процесса.

2.15 Специальные функции

asm (*NIX)
asm(asm_kod,output,input,modifi);
Позволяет выполнять встроенные инструкции языка asm <asm_kod> с входными параметрами <input>, выходными <output>, и модифицируемыми <modifi>.

assert (ANSI) <assert.h|cassert>
void assert (int expression);
Выводит на стандартный выход сообщение об ошибке и прекращает работу программы, если утверждение <expression> ложно (т.е., равно нулю). Происходит только в случае, если не определена переменная NDEBUG.

chroot (BSD)
int chroot(const char *path);
Функция установки нового корневого каталога.

getopt (POSIX) <unistd.h, getopt.h >
int getopt(int argc, char * const argv[], const char *optstring);
Обрабатывает параметры <argc> <argv> команды, на предмет поиска коротких опций <optstring>.

getopt_long (POSIX) <unistd.h, getopt.h>
int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);
Обрабатывает параметры <argc> <argv> команды на предмет поиска коротких <optstring> и длинных <longopts> опций.

getenv (POSIX) <stdlib.h>
char *getenv(const char *name);
Получает значения переменной окружения <name>;

getpagesize (BSD) <unistd.h>
size_t getpagesize(void);
Возвращает количество байтов в странице.

longjmp (POSIX) <setjmp.h>
void longjmp(jmp_buf env, int value);
Передает управление по адресу <env> с порядковым номером <value>.

main (ANSI)
main(int argc, char *argv[], char *envp[]);
Основная функция (точка входа). Переопределяется для выполнения в ней пользовательской программы. Переменной <argc> присваивается общее число параметров разделенных пробелами. Переменной <argv> присваиваются отдельные параметры командной строки. Переменной <envp> присваиваются переменные среды вызываемой программы.

mtrace (*) <mcheck.h>
void mtrace(void);
Запуск трассировки – используемой программой памяти. Лог помещается в файл на который указывает переменная окружения MALLOC_TRACE. Для обработки лога вызывается команда: «mtrace my_prog $MALLOC_TRACE.

optarg (POSIX) <unistd.h>
extern char *optarg;
Содержит текстовый аргумент параметра.

optind, opterr, optopt (POSIX) <unistd.h>
extern int optind, opterr, optopt;
optind – индекс аргумента;
opterr – ошибка опции;
optopt – необработанная опция;

pathconf, fpathconf (POSIX) <unistd.h>
long pathconf(char *path, int name);
long fpathconf(int filedes, int name);
Возвращает ограничение параметра <name> для файловой системы на которой находится файл <path>,<filedes>.

putenv (POSIX) <stdlib.h>
int putenv(char *string);
Добавляет или изменяет переменную окружения.

setjmp (POSIX) <setjmp.h>
int setjmp(jmp_buf env);
Запоминает в <env> адрес текущего места в программе для дальнейшего возврата к нему посредством longjmp. Функция возвращает порядковый номер сохраненного адреса начиная с “0”.

setenv, unsetenv (BSD) <stdlib.h>
int setenv(const char *имя, const char *значение, int overwrite);
void unsetenv(const char *name);
Изменение, добавление или удаление переменной окружения <имя> на <значение>.

sysconf (POSIX.1) <unistd.h>
long sysconf(int name);
Предоставляет приложениям информацию о соответствии OC стандарту POSIX. Также, предоставляется информация о всех POSIX параметрах.

sysinfo (Linux) <sys/sysinfo.h>
int sysinfo(struct sysinfo *info);
Возвращает общесистемную статистику.

uname (POSIX) <sys/utsname.h>
int uname(struct utsname *buf);
Возвращает информацию о системе в структуру с адресом <buf>.

2.16 Потоковые функции языка C++

Потоковые функции языка C++ представляют собой подборку классов предоставляющих функции для работы с основными потоковыми устройствами системы. Для подключения потоковых функций (классов) необходимо включать следующие заголовочные файлы:
<iostream> — Включает описание классов: cin, cout, cerr, clog.
<iomanip> — Включает информацию для обработки форматированного ввода-вывода;
<fstream> — Включает информацию для выполнения операций с файлами;
<strstream> — Включает информацию для выполнения операций со строкой.

Потоковые классы имеют следующую иерархию:

• istream ==> ios;
• ostream ==> ios;
• iostream ==> istream, ostream;
• ifstream ==> istream;
• ofstream ==> ostream;
• fstream ==> iostream;
• strstream ==> iostream;

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

Операции взятия из потока возвращают “false” при вводе признака конца файла. Для расширенной манипуляций с потоками допускается определение манипуляторов пользователя в виде ostream &tab(ostream &output) { return output << \t; }

2.16.1 Манипуляторы потока

endl <iostream>
ostream& endl(ostream& outs);
Перевод курсора на следующую строку;

ends <iostream>
ostream& ends(ostream& outs);
Вывести нулевой байт (символ конца строки);

2.16.2 Компонентные функции класса ios <iostream>

bad
int bad();
При ошибке возвращает ненулевое значение.

bitalloc
static long bitalloc();
Возвращает установки флагов. Полученное значение может быть использовано для очистки, установки или проверки флагов.

clear
void clear(int = 0);
Устанавливает состояние потока (обнулить или установить указанные биты).
eofbit – признак конца файла;
failbit – ошибка форматирования, но символы не утеряны;
badbit – потеря данных;
goodbit – ошибок нет.

eof
int eof();
Возвращает ненулевое значение, если имеет место условие конца файла (EOF).

fail
int fail();
Возвращает ненулевое значение, если операция обмена с потоком терпит неудачу.

fill
char fill();
char fill(char);
Устанавливает символ заполнения потока. Возвращает старое значение символа заполнения.

flags
long flags();
long flags(long);
Устанавливает флаги форматирования. Возвращает ранее установленное значение флагов.

good
int good();
Возвращает ненулевое значение если не установлен ни один флаг состояния (ошибок нет).

init
void init(streambuf *);
Связывает ios с указанным <streambuf>.

precision
int precision();
int precision(int);
Устанавливает точность вещественных чисел. Возвращает предыдущее значение точности.

rdbuf
streambuf* rdbuf();
Возвращает указатель на буфер (объект класса <bufstream>), связанный с потоком.

rdstate
int rdstate();
Возвращает текущее состояние потока.

setf
long setf(long);
long setf(long setbits, long field);
Устанавливает флаги по значению параметра или сбрасывает те биты состояния, которые отмечены в <field>, и устанавливает указанные в <setbits>. Возвращает предыдущие значения флагов.

setstate
void setstate(int);
Устанавливает указанные биты состояния.

tie
ostream* tie();
ostream* tie(ostream *);
Организует поток, взаимосвязанный с потоком, на который указывает <ostream*>. Возвращает указатель на взаимосвязанный предыдущий поток, если такой есть.

unself
long unself(long);
Очищает указанные биты состояния потока. Возвращает предыдущее значение.

width
int width();
int width(int);
Устанавливает ширину. Возвращает предыдущее значение.

xalloc
static int xalloc();
????

2.16.3 Компонентные функции класса ostream <iostream>

flush
ostream& flush(ostream& outs);
Сброс строки из буферов в поток;

put
cout.put(char c);
ostream& put(char c);
Вставить в поток символ <c>

seekp
ostream& seekp(long beg);
ostream& seekp(long beg, seek_dir);
Перемещает указатель текущей позиции выходного потока.

tellp
long tellp();
Возвращает текущую позицию указателя записи для выходного потока.

write
oatream& write(const signed char *string, int n);
ostream& write(const unsigned char *string, int n);
Помещает в выходной поток <n> символов из массива, на который указывает <string>. Нуль-символы включаются в число переносимых символов.

2.16.4 Компонентные функции класса istream <iostream>

gcount
int gcount;
Возвращает число символов, извлеченных из потока последним обращением.

get
istream& get(char& c);
istream& get(char* ptr, int len, char delim = '$\backslash $n');
istream& get(streambuf& sb, char delim = '$\backslash $n');
Извлекает из входного потока символы.

getline
istream& getline(signed char, int sizeof(char), '$\backslash $n');
Тоже что и get, но символ-разделителя, также, помещается в принятую строку символов.

ignore
istream& ignore(int n = 1,int delim = EOF);
Пропускает до n символов входного потока. Останавливается, если встретился разделитель (второй параметр), по умолчанию равный EOF.

peek
int peek();
Извлекает следующий символ из входного потока не удаляя его в потоке.

putback
istream& putback(char);
Помещает символ назад во входной поток.

read
istream& read(signed char *string, int n);
istream& read(unsigned char *string, int n);
Извлекает из входного потока группу символов <n> и помещает их в массив <string>.

seekg
istream& seekg(long beg);
istream& seekg(long beg, seek_dir);
Перемещает указатель чтения входного потока.

tellg
long tellg();
Возвращает текущую позицию указателя чтения входного потока.

Таблица 14. Флаги класса ios, управляющие форматированием ввода/вывода (манипуляторы потока)

2.17 Процессы.

atexit (BSD) <stdlib.h, cstdlib>
int atexit(void (*function)(void));
Регистрирует функцию, вызываемую при обычном завершении программы/процесса. Регистрация происходит цепочкой что позволяет регистрировать несколько функций.

clone (LINUX) <sched.h>
int clone(int (*fn) (void *arg), void *child_stack, int flags, void *arg);
Клонирует новую задачу на базе функции <fn> со стеком <child_stack> флагами <flags> и аргументами <arg>.

exec[c,l,e,p,v] (POSIX) <unistd.h>
int execl( const char *path, const char *arg, ...);
int execlp( const char *file, const char *arg, ...);
int execle( const char *path, const char *arg, ..., char * const envp[]);
int execv( const char *path, char *const argv[]);
int execvp( const char *file, char *const argv[]);
int execve(const char *filename, char *const argv[], char *const envp[]);
Заменяет выполняющуюся программу другой программой. Отличия функций:

• p – Производить поиск программы в каталогах описанных в PATH;
• v – Принимать список аргументов программы в виде массива строковых указателей оканчивающихся NULL-указателем;
• l – Принимает список аргументов переменного размера;
• e – Принимать в дополнительном аргументе массив переменных сред.

exit, _exit, _exit (POSIX) <stdlib.h, unistd.h>
void exit(int status);
void _exit(int status);
exit – обычное завершение работы программы/процесса. _exit – немедленное завершение работы программы/процесса.

fork (POSIX) <sys/types.h; unistd.h>
int fork();
Порождает дочерний процесс. Родительскому процессу возвращается ID дочернего процесса, а дочернему 0.

getpid, getppid (POSIX) <sys/types.h, unistd.h>
pid_t getpid(void);
pid_t getppid(void);
getpid – возвращает идентификатор текущего процесса (PID). getppid – возвращает идентификатор родительского процесса(PPID).

nice (BSD) <unistd.h>
int nice(int inc);
Устанавливает фактор уступчивости вызывающего процесса в величину <inc> (-39..39). Чем фактор больше, тем ниже приоритет процесса.

sched_setaffinity, sched_getaffinity (Linux) <sched.h>
int sched_setaffinity(pid_t pid, unsigned int len, unsigned long *mask);
int sched_getaffinity(pid_t pid, unsigned int len, unsigned long *mask);
Установить/получить привязку процесса к конкретному процессору многопроцессорной системы.

sched_setparam, sched_getparam (POSIX) <sched.h>
int sched_setparam(pid_t pid, const struct sched_param *p);
int sched_getparam(pid_t pid, struct sched_param *p);
Установка/получение параметров диспетчеризации процесса.

sched_setscheduler, sched_getscheduler (POSIX) <sched.h>
int sched_setscheduler(pid_t pid, int policy, const struct sched_param *p);
int sched_getscheduler(pid_t pid);
Установка/получение политики диспетчеризации процесса.

sched_get_priority_max, sched_get_priority_min (POSIX) <sched.h>
int sched_get_priority_max(int policy);
int sched_get_priority_min(int policy);
Получение максимального/минимального значения приоритета реального времени.

sched_rr_get_interval (POSIX) <sched.h>
int sched_rr_get_interval(pid_t pid, struct timespec *tp);
Получить продолжительность кванта времени для SCHED_RR планирования.

sched_yield (POSIX) <sched.h>
int sched_yield(void);
Отдать процессорное время другим процессам.

setsid (POSIX) <unistd.h>
pid_t setsid(void);
Вызывающий процесс становится ведущим в группе, ведущим процессом нового сеанса и не имеет контролирующего терминала.

setpgid, getpgid, setpgrp, getpgrp (POSIX, BSD) <unistd.h>
int setpgid(pid_t pid, pid_t pgid);
pid_t getpgid(pid_t pid);
int setpgrp(void);
pid_t getpgrp(void);
Устанавливает/получает идентификатор группы процессов

system (ANSI,POSIX) <stdlib.h>
int system (const char * string);
Выполняет, указанные в string, системные команды.

wait, waitpid, wait3, wait4 (POSIX) <sys/types.h, sys/wait.h, sys/resource.h>
pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);
pid_t wait3(int *status, int options, struct rusage *rusage);
pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);
Приостанавливают выполнение процесса до тех пор, пока дочерний процесс не завершится, или до появления сигнала, который либо завершает текущий процесс, либо требует вызвать функцию-обработчик. Если дочерний процесс к моменту вызова функции уже завершился (так называемый «зомби» («zombie»)), то функция немедленно возвращается. Параметр pid:

• < -1 — нужно ждать любого дочернего процесса, идентификатор группы процессов которого равен абсолютному значению <pid>;
• -1 — ожидание любого дочернего процесса;
• 0 — означает ожидание любого дочернего процесса, идентификатор группы процессов которого равен идентификатору текущего процесса;
• > 0 — ожидание дочернего процесса, чей идентификатор равен pid;

В <rusage> записывается структура struct rusage, заданная в <sys/resource.h>, заполненная соответствующей информацией.

2.18 Сигналы.

kill (POSIX) <sys/types.h, signal.h>
int kill(pid_t pid, int sig);
Системный вызов kill используется для того, чтобы послать сигнал процессу или группе процессов. Если:

• pid > 0 – сигнал sig посылается процессу pid.
• pid = 0 – сигнал sig посылается всем процессам текущей группы.
• pid = -1 – сигнал sig посылается всем процессам текущей группы, кроме первого.

pause (SVr4, SVID, POSIX, X/OPEN, BSD 4.3) <unistd.h>
int pause(void);
Ожидание сигнала.

raise (ANSI) <signal.h>
int raise(int sig);
Посылает сигнал <sig> текущему процессу.

sigaction (POSIX) <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
Используется для изменения действий процесса при получении соответствующего сигнала <signum>.

signal (ANSI) <signal.h>
void (*signal(int signum, void (*sighandler)(int)))(int);
Устанавливает функцию <sighandler> обработки сигнала <signum>. Таблица 15.

sigpending (POSIX) <signal.h>
int sigpending(sigset_t *set);
Определяет наличие ожидающих сигналов.

sigprocmask (POSIX) <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
Изменяет список блокированных в данный момент сигналов.

sigsuspend (POSIX) <signal.h>
int sigsuspend(const sigset_t *mask);
Временно изменяет значение маски блокировки сигналов процесса на указанное в mask, и затем приостанавливает работу процесса до получения соответствующего сигнала.

sigwait (POSIX) <signal.h, pthread.h>
int sigwait(const sigset_t *set, int *sig);
Блокирует поток до генерации сигналов указанных в <set>. Номер сгенерированного сигнала помещается в <sig>.

Таблица 15. Стандартные сигналы

2.19 Потоки.

pthread_attr_init (POSIX) <pthread.h>
int pthread_attr_init(pthread_attr_t *attr);
Инициализация атрибутов <attr> канала, стандартными значениями.

pthread_kill (POSIX) <pthread.h, signal.h>
int pthread_kill(pthread_t thread, int signo);
Послать сигнал <signo> потоку <thread>.

pthread_attr_destroy (POSIX) <pthread.h>
int pthread_attr_destroy(pthread_attr_t *attr);
Удаление из памяти атрибутов <attr> ранее инициализированных.

pthread_attr_setschedpolicy, pthread_attr_getschedpolicy (POSIX) <pthread.h>
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
Получить, установить тактику <policy> управления потоком в соответствии с <attr>. Тактика может быть:

• SCHED_OTHER – регулярное, не РВ разделение;
• SCHED_RR – РВ, (round-robin);
• SCHED_FIFO – РВ, (first in first out).

pthread_attr_setschedparam, pthread_attr_getschedparam (POSIX) <pthread.h>
int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
Установка/получение параметров(приоритета) <param> разделения времени для РВ тактик.

pthread_attr_setdetachstate, pthread_attr_getdetachstate (POSIX) <pthread.h>
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
Установка/получение статуса отсоединения потока.

pthread_create (POSIX) <pthread.h>
int pthread_create(pthread_t * thread, pthread_attr_t *attr, void * (*start_routine)(void *), void * arg);
Создает новый поток <thread> с атрибутами <attr> и запускает в потоке функцию <start_routine> с аргументами <arg>. Созданная задача разделяет код и память с родителем;

pthread_detach (POSIX) <pthread.h>
int pthread_detach(pthread_t th);
Делает указанный <th> поток в отсоединенное состояние.

pthread_equal (POSIX) <pthread.h>
int pthread_equal(pthread_t thread1, pthread_t thread2);
Сравнивает два потока на эквивалентность.

pthread_exit (POSIX) <pthread.h>
void pthread_exit(void *retval);
Прекращает выполнение вызвавшего функцию потока с кодом возврата в <retval>

pthread_join (POSIX) <pthread.h>.
int pthread_join(pthread_t *th, void **thread_return);
Ожидает завершение потока <th>. После завершения код возврата помещается в <thread_return>.

pthread_self (POSIX) <pthread.h>
pthread_t pthread_self(void);
Возвращает идентификатор текущего потока.

pthread_sigprocmask (POSIX) <signal.h, pthread.h>
int pthread_sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
Изменяет список блокированных в данный момент сигналов для текущего потока.

2.19.1 Отмена потоков

pthread_cancel (POSIX) <pthread.h>
int pthread_cancel(pthread_t thread);
Отмена указанного <thread> потока.

pthread_setcanceltype (POSIX) <pthread.h>
int pthread_setcanceltype(int type, int *oldtype);
Установка типа отмены в <type> и сохранение текущего в <oldtype>.

pthread_testcancel (POSIX) <pthread.h>
void pthread_testcancel(void);
Установка точки отмена.

pthread_setcancelstate (POSIX) <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);
Установка состояния отмены потока в <state> и сохранение текущего в <oldstate>.

2.19.2 Глобальные данные потоков

pthread_key_create (POSIX) <pthread.h>
int pthread_key_create(pthread_key_t *key, void (*destr_function)(void *));
Создание ключа <key>, новой глобальной переменной. Можно указать функцию очистки ключа <destr_function> при уничтожении потока.

pthread_key_delete (POSIX) <pthread.h>
int pthread_key_delete(pthread_key_t key);
Удаление ключа <key>.

pthread_setspecific, pthread_getspecific (POSIX) <pthread.h>
int pthread_setspecific(pthread_key_t key, const void *pointer);
void *pthread_getspecific(pthread_key_t key);
Запись/чтение глобальных потоковых переменных по ключу <key>.

2.19.3 Обычные потоковые семафоры

sem_init, sem_destroy (POSIX) <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_destroy(sem_t * sem);
Инициализация/удаление семафора <sem>. <pshared> должен быть равен нулю. <value> – Стартовое значение семафора.

sem_getvalue (POSIX) <semaphore.h>
int sem_getvalue(sem_t * sem, int * sval);
Получить текущее состояние <sval> семафора <sem>.

sem_post (POSIX) <semaphore.h>
int sem_post(sem_t * sem);
Установка семафора (+1).

sem_wait (POSIX) <semaphore.h>
int sem_wait(sem_t * sem);
Ожидает ненулевого значения семафора. При вызове функции значение семафора уменьшается на единицу.

sem_trywait (POSIX) <semaphore.h>
int sem_trywait(sem_t * sem);
Неблокирующие ожидания ненулевого значения семафора.

2.19.4 Исключающие семафоры

thread_mutex_init, pthread_mutex_destroy (POSIX) <pthread.h>
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
Инициализация/удаление исключающего семафора <mutex> с атрибутами <mutexattr>.

int pthread_mutex_lock, pthread_mutex_unlock (POSIX) <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
Захват/освобождение исключающего семафора <mutex>. Если семафор занят поток блокируется до освобождения.

pthread_mutex_trylock (POSIX) <pthread.h>
int pthread_mutex_trylock(pthread_mutex_t *mutex);
Попытка захвата исключающего семафора <mutex>. Если семафор занят возвращается BUSY.

pthread_mutexattr_init, pthread_mutexattr_destroy (POSIX) <pthread.h>
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
Создание/удаление атрибутов для <attr> исключающего семафора.

pthread_mutexattr_setkind_np, pthread_mutexattr_getkind_np (POSIX) <pthread.h>
int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);
int pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind);
Установка/получение типа исключающего семафора <kind>.

2.19.5 Сигнальные переменные

pthread_cond_init, pthread_cond_destroy (POSIX) <pthread.h>
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
int pthread_cond_destroy(pthread_cond_t *cond);
сохранение/удалении сигнальной переменной <cond>. <cond_attr> должна быть NULL.

pthread_cond_signal, pthread_cond_broadcast (POSIX) <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
Разблокирует один/все потоки ожидающие сигнальной переменной <cond>;

pthread_cond_wait (POSIX) <pthread.h>
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
Блокирует текущий поток на базе исключающего семафора <mutex> до изменения сигнальной переменной <cond> с таймаутом <abstime>.

2.20 IPC (Inter Process Communication)

ftok <sys/types.h, sys/ipc.h>
key_t ftok(char *pathname, char proj);
Преобразует имя файла и идентификатор проекта в ключ для системных вызовов.

2.20.1 Сообщения

msgctl (SVr4, SVID) <sys/types.h, sys/ipc.h, sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
Послать команду <cmd> сообщению <msqid> с параметрами <buf>;

msgget (SVr4, SVID) <sys/types.h, sys/ipc.h, sys/msg.h>
int msgget(key_t key, int msgflg);
Возвращает дескриптор очереди сообщений для ключа <key> с правами доступа <msgflg>.

msgsnd (SVr4, SVID) <sys/types.h, sys/ipc.h, sys/msg.h>
int msgsnd(int msqid, struct msgbuf *msgp, size_t msgsz, int msgflg);
Отправить сообщение <msgp> длиной <msgsz> и с флагами <msgflg>, по дескриптору сообщения <msqid>.

msgrcv (SVr4, SVID) <sys/types.h, sys/ipc.h, sys/msg.h>
ssize_t msgrcv(int msqid, struct msgbuf *msgp, size_t msgsz, long msgtyp, int msgflg);
Получить сообщение из дескриптора сообщения msqid, в буфер <msgp> размером <msgsz> с типом <msgtyp> и флагами <msgflg>. Если <msgtyp>=0 – читать первое сообщение из очереди, если < 0 – получить сообщение с минимальным типом не менее msgtyp.

2.20.2 Семафоры

semget (SVID) <sys/types.h, sys/ipc.h, sys/sem.h>
int semget(key_t key, int nsems, int semflg);
Возвращает идентификатор семафора в соответствии с ключом <key>, опциями <semflg> и количеством семафором <nsems> (Табл [*]).

semctl (SVID) <sys/types.h, sys/ipc.h, sys/sem.h>
int semctl(int semid, int semnum, int cmd, union semun arg);
Производит операции <cmd> (Табл [*]) по управлению семафорами.

semop (SVID) <sys/types.h, sys/ipc.h, sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);
Производит операции над выбранными элементами из набора семафоров <semid>. Каждый из элементов <nsops> в массиве <sops> определяет операцию, производимую над семафором в структуре <struct sembuf>.

2.20.3 Разделяемая память

shm_open (POSIX.1–2001) <sys/types.h, sys/mman.h, fcntl.h>
int shm_open(const char *name, int oflag, mode_t mode);
Создание/открытие разделяемого объекта памяти под именем <name>.

shm_unlink (POSIX.1–2001) <sys/types.h, sys/mman.h, fcntl.h>
int shm_unlink(const char *name);
Удаление /отключение разделяемого объекта памяти с именем <name>.

shmget (SVID) <sys/ipc.h, sys/shm.h>
int shmget(key_t key, int size, int shmflg);
Возвращает идентификатор разделяемой памяти в соответствии с ключом <key>, размером <size> и опциями <shmflg> (Табл.16).

shmat, shmdt (SVID) <sys/types.h, sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);
<shmat> – присоединяет сегмент разделяемой памяти <shmid> к сегменту данных вызывающего процесса. Адрес присоединяемого сегмента определяется функцией <shmaddr>.
<shmdt> – отстыковывает от сегмента данных вызывающего процесса сегмент разделяемой памяти, находящийся по адресу <shmaddr>.

shmctl (SVID) <sys/ipc.h, sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
Производит операции <cmd> (Табл.17) по управлению разделяемыми сегментами памяти.

Таблица 16. Флаги доступа к IPC

Таблица 17. Операции над IPC

2.21 Каналы

mkfifo (POSIX) <sys/types.h, sys/stat.h>
int mkfifo ( const char *pathname, mode_t mode );
Создает FIFO-файл <pathname> (именованный канал). Размер атомарного буфера составляет PIPE_BUF.

pipe (POSIX) <unistd.h>
int pipe(int filedes[2]);
Создает два файловых описателя, указывающих на неименнованый канал, и помещает их в массив filedes. filedes[0] – для чтения, filedes[1] – для записи.

popen, pclose (POSIX) <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
Открывает/закрывает канал с запускаемым процессом <command>.

2.22 Сокеты

accept (BSD) <sys/types.h, sys/socket.h>
int accept(int s, struct sockaddr *addr, socklen_t *addrlen);
Возвращает описатель сокета клиента пославшего запрос на сокет <s> с адресом <addr, addrlen>.

bind (BSD) <sys/types.h, sys/socket.h>
int bind(int sockfd, struct sockaddr *my_addr, socklen_t addrlen);
Связывает открытый сокет <sockfd> с именем длиной <addrlen> в <my_addr>.

listen (POSIX) <sys/socket.h>
int listen(int s, int backlog);
Прослушивает соединения на сокете <s> с длиной очереди полностью установленных сокетов <backlog>

recv, recvfrom, recvmsg (BSD) <sys/uio.h sys/types.h sys/socket.h>
int recv(int s, void *buf, size_t len, int flags);
int recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);
int recvmsg(int s, struct msghdr *msg, int flags);
Системные вызовы recvfrom и recvmsg используются для получения сообщений из сокета независимо от того, является ли сокет ориентированным на соединения или нет. Вызов recv обычно делается только через соединенный сокет.

send, sendto, sendmsg (BSD, POSIX) <sys/types.h, sys/socket.h>
int send(int s, const void *msg, size_t len, int flags);
int sendto(int s, const void *msg, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
int sendmsg(int s, const struct msghdr *msg, int flags);
send, sendto, и sendmsg используются для пересылки сообщений в другой сокет. send можно использовать, только если сокет находится в состоянии соединения, тогда как sendto и sendmsg можно использовать в любое время.

socket (BSD) <sys/types.h, sys/socket.h>
int socket(int domain, int type, int protocol);
Возвращает описатель нового сокета <socket>. <domain> – задает домен соединения (Табл.18).
<type> – задающий семантику коммуникации (Табл.19).
<protocol> – задает конкретный протокол, который работает с сокетом.

shutdown (BSD) <sys/socket.h>
int shutdown(int s, int how);
Приводит к закрытию всего полнодуплексного соединения или его части в сокете, связанном с описателем <s>.

socketpair (BSD) <sys/types.h, sys/socket.h>
int socketpair(int d, int type, int protocol, int sv[2]);
Функция создает пару неименнованых связанных сокетов в заданном домене <d> типа <type>, используя заданный протокол <protocol>. Описатели заданных сокетов возвращаются в sv[0] и sv[1].

gethostbyname (BSD) <sys/socket.h>
struct hostent *gethostbyname(const char *name);
Возвращает структуру типа hostent машине с именем name.

htonl, htons, ntohl, ntohs (BSD)uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
Переводят данные из хостового порядка расположения байтов в сетевой и наоборот

inet_pton (BSD) <sys/types.h, sys/socket.h, arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
Преобразует строку символов <src> в сетевой адрес (типа <af>), затем копирует полученную структуру с адресом в <dst>.

inet_aton (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
Преобразует обычный вид IP-адреса cp (из номеров и точек) в двоичный код inp.

inet_addr (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
in_addr_t inet_addr(const char *cp);
Преобразует обычный вид IP-адреса cp (из номеров и точек) в двоичный код в сетевом порядке расположения байтов.

inet_network (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
in_addr_t inet_network(const char *cp);
Извлекает сетевой номер в хостовом порядке расположения байтов из адреса cp, записанном в виде номеров и точек.

inet_ntoa (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
char *inet_ntoa(struct in_addr in);
Преобразует IP-адрес in, заданный в сетевом порядке расположения байтов, в стандартный строчный вид, из номеров и точек.

inet_makeaddr (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
struct in_addr inet_makeaddr(int net, int host);
Создает IP-адрес в сетевом порядке расположения байтов, комбинируя номер сети net с локальным адресом host в сети net (оба в хостовом порядке расположения байтов).

inet_lnaof (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
in_addr_t inet_lnaof(struct in_addr in);
Возвращает часть адреса для локального хоста из IP-адреса in. Адрес локального хоста возвращается в хостовом порядке размещения байтов.

inet_netof (BSD) <sys/socket.h, netinet/in.h, arpa/inet.h>
in_addr_t inet_netof(struct in_addr in);
Возвращает сетевую часть IP-адреса in. Сетевой номер возвращается в виде байтов, порядок которых определяется системой локального хоста.

Таблица 18. Домены соединений

Таблица 19. Типы сокетов