Основы информатики и программирования.
План лекций

• практика программирования
• требования
  • результат соответствует требованиям задачи
  • соблюдены сроки
  • код соответствует установленным стандартам
• технические задания для каждой задачи сформулированы на странице курса
• для каждой задачи определена стоимость в баллах
  • за каждую неделю просрочки стоимость уменьшается в два раза
• успешная защита работы, если разработанная программа соответствует всем установленным требованиям

• изучение материалов, документации, чтение дополнительной литературы
• удаленная работа над заданиями

• support@cs.petrsu.ru
• Вадим Анатольевич Пономарев (vadim@cs.petrsu.ru)
• Михаил Александрович Крышень (kryshen@cs.petrsu.ru)

Результат вычисления выражения последовательно сравнивается с константами в case, при совпадении выполнение начинается с инструкции после двоеточия (до конца switch или break).

В case допускаются константные выражения простых (скалярных) целочисленных типов: char, int, … В case не допускаются числа с плавающей точкой, составные объекты: массивы, строки

switch (выражение) {
case конст1 : инструкции
case конст2 : инструкции
...
default : инструкции
}

/* При x = 1 будут выведены строки 1 и 2. */
switch (x) {
case 1:
    fprintf(stdout, "1\n");
case 2:
    fprintf(stdout, "2\n");
    break;
case 3:
    fprintf(stdout, "3\n");
}

/* Можно группировать варианты. */
switch (x) {
case 1:
case 2:
    fprintf(stdout, "1+2\n");
    break;
case 3:
    fprintf(stdout, "3\n");
    break; /* не обязательно, но лучше оставить */
}

условие ? выражение1 : выражение2

В отличие от if при вычислении получает определенное значение и может использоваться внутри других выражений.

int abs_a_minus_b = a > b ? a - b : b - a;

Функция вызывает себя:

/* Возвращает факториал числа n. */
int factorial(int n)
{
    /* база рекурсии */
    if (n == 0) {
        return 1;
    }

    return n * factorial(n - 1);
}

= factorial(5) =
= 5 * factorial(4) =
= 5 * 4 * factorial(3) =
…
= 5 * 4 * 3 * 2 * 1 * factorial(0) =
= 5 * 4 * 3 * 2 * 1 * 1 =
= 120

"Глупое" суммирование:

int silly_add(int a, unsigned int b)
{
    if (b == 0) {
        return a;
    }

    return silly_add(a + 1, b - 1);
}

silly_add(5, 3) =
= silly_add(6, 2) =
= silly_add(7, 1) =
= silly_add(8, 0) =
= 8

Эквивалентно циклу:

int silly_add(int a, unsigned int b)
{
    while (b != 0) {
        a = a + 1;
        b = b - 1;
    }
    return a;
}

Почему программа завершается с ошибкой сегментирования при вызове рекурсивной версии silly_add с достаточно большим значением b (если откомпилировать без оптимизации)?

Стек — абстрактный тип данных, представляющий собой список элементов, организованных по принципу LIFO (last in — first out, последним пришел — первым вышел).

Операции со стеком:

• push: добавить элемент,
• pop: извлечь последний (находящийся на вершине стека) элемент.

Аппаратный стек поддерживается центральным процессором и используется для хранения переменных и вызова подпрограмм.

Стек вызовов (call stack) — стек, хранящий информацию для возврата управления из подпрограмм (функций) в программу (или вызывающую функцию) при вложенных или рекурсивных вызовах.

Кадр стека выделяется при вызове функции и содержит связанное с ним состояние — адрес возврата, аргументы и локальные переменные. Структура кадра зависит от архитектуры процессора и соглашений системы (ABI).

#include <stdio.h>

int factorial(int n)
{
    if (n == 0) {
        return 1;
    }

    return n * factorial(n - 1);
}

int main(void)
{
    int a = 3;
    int b;

    b = factorial(a);

    return 0;
}

Размер стека ограничен системой:

user@kappa:~> ulimit -s
8192

(ответ в килобайтах)

Переполнение стека приводит к аварийному завершению программы.

Байты объекта могут быть упорядочены в памяти разными способами: от старшего к младшему или наоборот.

0x12345678 — четырехбайтовое значение (шестнадцатеричное число равное десятичному 305419896). Размещено в памяти по адресу n.

Big Endian (тупоконечный порядок) — сначала старший байт:

Little Endian (остроконечный порядок) — сначала младший:

В архитектурах x86 и x86-64 используется остроконечный порядок.

По умолчанию значения целого типа, кроме char, считается представленным в знаковой форме. Для char представление по умолчанию зависит от реализации. Использование знакового или беззнакового представления регулируется модификаторами signed и unsigned.

Для знаковых типов обычно используется дополнительный код (но стандарт допускает и другие способы представления).

signed char c = 127;   /* максимальное положительное,
                          битовое представление 0x7F (01111111) */

signed char c = -128;  /* минимальное отрицательное,
                          битовое представление 0x80 (10000000) */

signed char c = -1;    /* битовое представление 0xFF (11111111) */

unsigned char c = 255; /* 11111111 */

Модификаторы short и long варьируют размер базового целочисленного типа int. При этом int можно опускать:

int a; /* целое, размер определяется реализацией */
short int b; /* короткое целое, можно просто short */
long int c; /* длинное целое, можно просто long */
long long d; /* длинное целое повышенной емкости */
unsigned long e; /* можно комбинировать с unsigned */

Тип непосредственной константы задается суффиксами:

unsigned long a = 100lu;

#include <limits.h>

Файл limits.h содержит и другие константы, характеризующие реализацию языка и среду выполнения во время компиляции, например:

• ARG_MAX — максимальный размер аргумента программы,
• OPEN_MAX — максимальное количество открытых файлов,
• PATH_MAX — максимальная длина пути файла.

Оператор sizeof:

/* размер типа int в байтах */
sizeof(int)

#include <stdint.h>

Заданный размер в битах:

• int8_t
• int16_t
• int32_t
• uint8_t
• uint16_t
• uint32_t

Дополнительно, если поддерживается реализацией:

• int64_t
• uint64_t

Минимальный тип не менее указанного размера: int_least8_t, int_least16_t, int_least32_t, int_least64_t, uint_least8_t, uint_least16_t, uint_least32_t, uint_least64_t.

Наиболее быстрый тип не менее указанного размера: int_fast8_t, int_fast16_t, int_fast32_t, int_fast64_t, uint_fast8_t, uint_fast16_t, uint_fast32_t, uint_fast64_t.

Типы максимального размера: intmax_t, uintmax_t.

И соответствующие константы _MIN и _MAX.

• size_t — тип для размеров объектов данных,
• ssize_t — аналогично, но может быть отрицательным для представления специальных значений.

Используются в функциях ввода-вывода (stdio.h), выделения памяти, работы со строками и др.

size_t strlen(const char *s);

\[m*b^e\]

IEEE 754-2008

• нормализованная форма: \(a = s * 1,m * 2 ^ {(b - t)}\)
• субнормали: \(a = s * 0,m * 2 ^ {-t}\)

Типы:

• float — 32bit
• double — 64bit
• long double — 128bit

Специальные значения:

• -Infinity, +Infinity
• NaN

Десятичные дроби могут не иметь точного представления в двоичных форматах:
\(0,1_{10} = 0,0001100110011..._{2}\) (периодическая дробь).

enum тип_перечисления {список констант};

По умолчанию, первая константа получает значение 0, каждая последующая автоматически увеличивается на 1.

enum {
    ONE = 1,
    TWO,
    THREE
};

Массивы в Си имеют целочисленные индексы, начинающиеся с нуля.

int a[10]; /* Одномерный массив на десять элементов
              a[0] ... a[9] */

int a[10][5]; /* Двумерный массив 10 строк по 5 элементов */

int a[3] = {1, 2, 3}; /* Определение и инициализация */

int a[] = {1, 2, 3}; /* Компилятор может и сам подсчитать */

int a[10] = {0}; /* Инициализация нулями */

int a[10] = {1}; /* Единица и 9 нулей */

/* Инициализация двумерного массива */
int a[3][2] = {{0, 1}, {2, 3}, {4, 5}};

Обращение к элементу по индексу: a[i]

Обработка массива размера N.

for (int i = 0; i < N; i++) {
    обработать a[i];
}

Обработка двумерного массива размера N×M:

for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++) {
        обработать a[i][j];
    }
}

Размещение в памяти:

Признаком конца строки является символ (байт) с кодом 0 ('\0') При выделении памяти под строку следует помнить про дополнительный байт для терминального нуля!

char str1[10]; /* Не более 9 полезных символов */

char str2[10] = "Hello!\n"; /* Сколько занято байт? */

char str3[] = "Hello!\n"; /* А так? */

char str4[] = {'H', 'e', 'l', 'l', 'o', '!', '\n', '\0'};

char str5[] = ""; /* Пустая строка — 1 байт */

int x = 0;

• x — имя переменной,
• 0 — значение переменной,
• &x — адрес переменной (указатель типа int*).

Можно вывести адрес:

printf("%p\n", &x);

char *pc;     /* указатель на объект типа char */
int *pn, *pm; /* указатели на объекты типа int */
void *ptr;    /* нетипизированный указатель */

NULL — специальное значение, «нулевой адрес», индикатор того, что указатель не адресует никакого объекта памяти Константа NULL определена в ряде стандартных заголовочных файлов. NULL эквивалентен численному значению 0, но не обязательно представлен последовательностью нулевых битов.

void *ptr = NULL;

Операция разыменовывания * позволяет обратиться к объекту по указателю. Не допускается разыменование void *.

int n;
int *pn, *pm;
pn = pm = &n; /* pn и pm указывают на n */

/* следующие операции эквивалентны */
n = 1;
*pn = 1;  /* присвоить значение по указателю pn */
*pm = 1;  /* pm также указывает на n */

• &n — взятие адреса переменной,
• *pn — доступ к объекту (переменной) по указателю.

Любой указатель приводим к void *, в остальных случаях необходимо явное приведение.

void *ptr;
float *px, *py;
ptr = px;
py = (float *) ptr;

Указатель на функцию может быть использован для вызова функции или передачи в функцию в качестве параметра.

/* Функция, возвращающая указатель на char. */
char *a (void);

/* Указатель на функцию, возвращающую char. */
char (*a) (void);

/* Указатель на функцию, возвращающую указатель на char. */
char *(*a) (void);

/* Массив из 10 указателей на функции, которые возвращают
   указатель на char. */
char *(*a[10]) (void);

Пример:

/* Включает прототипы функций scanf и printf */
#include <stdio.h>

/* Прототип функции: функция должна быть объявлена до ее вызова. */
int max(int a, int b);

int main(void)
{
    int (*f)(int a, int b);
    f = max;

    /* вызовет max по указателю f */
    int m = f(20, 10);
    /* или можно явно обозначить использование указателя:
       int m = (*f) (20, 10); */
    printf("%d\n", m);

    return 0;
}

int max(int a, int b)
{
    return a > b ? a : b;
}

Прототип универсальной функции сортировки из stdlib.h:

void qsort (void *base, size_t nmemb, size_t size,
            int (*compar)(const void *, const void *));

Можно сортировать любые объекты, для которых определена функция сравнения:

#include <stdio.h>
#include <stdlib.h>

int int_compar(const void *pa, const void *pb) {
    int a = *(const int *)pa;
    int b = *(const int *)pb;

    /* < 0: а перед b,
       > 0: b перед a,
       = 0: значения равны (порядок произвольный). */
    return a - b;
}

int main(void)
{
    int a[] = {5, 1, 2, -1, 2, -4, 10};

    qsort(a, 7, sizeof(int), int_compar);

    for (int i = 0; i < 7; i++) {
        printf("%d\n", a[i]);
    }    

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define RAD(a) (a * (3.14 / 180))

int main(void) {
    int i;
    for (i = 0; i < 360; i++) {
        printf ("%4d %6.4lf\n", i, cos(RAD(i)));
    }
    return EXIT_SUCCESS;
}

$ gcc -o mathsample mathsample.c
/usr/bin/ld: /tmp/cceJg4LG.o: в функции «main»:
mathsample.c:(.text+0x31): неопределённая ссылка на «cos»
collect2: ошибка: выполнение ld завершилось с кодом возврата 1

$ gcc -lm -o mathsample mathsample.c
$

Символ $ здесь и далее обозначает приглашение интерпретатора командной строки.

Вместо встраивания модулей в исполняемый файл, можно загружать их динамически при запуске программы. Такие модули компонуются в разделяемые динамические библиотеки, которые могут размещаться в системе один раз и использоваться многими программами.

$ gcc -shared -o liblucky.so -fPIC lucky.c
$ gcc -L. -llucky -o luckycheck main.c

• -fPIC включает генерацию кода, не зависящего от размещения в адресном пространстве процесса (position-independent code),
• -L. задает путь для поиска библиотек: . — текущий каталог,
• -llucky — использовать библиотеку liblucky.so.

SO — Shared object (разделяемый объект). Аналогичный механизм в Windows — файлы DLL (Dynamic-link library).

$ ./luckycheck
luckycheck: error while loading shared libraries: liblucky.so: cannot open shared object file: No such file or directory

Не находит, т. к. библиотека не размещена в каталогах поиска динамического редактора связей. Но можно добавить нужный каталог, используя переменную окружения LD_LIBRARY_PATH:

$ LD_LIBRARY_PATH=. ./luckycheck

Можно посмотреть, какие библиотеки использует исполняемый файл:

$ ldd /bin/ls
        linux-vdso.so.1 (0x00007ffef29ee000)
        libselinux.so.1 => /lib64/libselinux.so.1 (0x00007f354be88000)
        libcap.so.2 => /lib64/libcap.so.2 (0x00007f354be7e000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f354bc00000)
        libpcre2-8.so.0 => /lib64/libpcre2-8.so.0 (0x00007f354bb63000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f354bef9000)

$ ldd luckycheck
        linux-vdso.so.1 (0x00007ffcb7be8000)
        liblucky.so => not found
        libc.so.6 => /lib64/libc.so.6 (0x00007f8553000000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f8553397000)

$ LD_LIBRARY_PATH=. ldd luckycheck
        linux-vdso.so.1 (0x00007ffe141a4000)
        liblucky.so => ./liblucky.so (0x00007f80ae993000)
        libc.so.6 => /lib64/libc.so.6 (0x00007f80ae600000)
        /lib64/ld-linux-x86-64.so.2 (0x00007f80ae99a000)

int fgetc(FILE *stream);
int getc(FILE *stream);
int getchar(void);

int fputc(int c, FILE *stream);
int putc(int c, FILE *stream);
int putchar(int c);
int ungetc(int c, FILE *stream);

Функции fgetc(), getc() и getchar() возвращают символ, считанный как unsigned char и преобразованный в int, или EOF по достижении конца файла или при возникновении ошибки. При успешном выполнении функция ungetc() возвращает c или EOF при ошибке.

Функции fputc(), putc() и putchar() возвращают записанный символ, преобразованный из unsigned char в int или EOF в случае ошибки.

Прочитать весь файл посимвольно:

while ((c = fgetc(f)) != EOF) {
    …
}

Цикл чтения завершился из-за ошибки или в результате достижения конца файла?

int feof(FILE *stream);
int ferror(FILE *stream);

• feof(f) — истина (не 0), если достигнут конец файла.
• ferror(f) — истина, если была ошибка.

char *fgets(char *s, int size, FILE *stream);
char *gets(char *s); /* Никогда не используйте эту функцию! */

int fputs(const char *s, FILE *stream);
int puts(const char *s);

Считывание строки и удаление '\n' в конце:

#define LINE_MAX 100

char s[LINE_MAX];

if (!fgets(s, LINE_MAX, stdin)) {
    /* TODO: обработать ошибку. */
}

/* Удаление возможного '\n' в конце строки. */
size_t n = strlen(s);
if (s[n - 1] == '\n')
    s[n - 1] = '\0';

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

При успешном выполнении функции fread() и fwrite() возвращают количество считанных или записанных единиц. Это количество равно количеству переданных байт только, если значение size равно 1. В случае ошибки или по достижении конца файла возвращается меньшее количество единиц (или ноль).

Чтение блоками до конца файла:

FILE *in = …;
char buf[BUFSIZ];
size_t n;

do {
    n = fread(buf, 1, BUFSIZ, in);
    printf("Прочитано байт: %zu\n", n);
} while (n == BUFSIZ);

if (ferror(in)) {
    perror("Ошибка чтения");
    exit(EXIT_FAILURE);
}

Константа BUFSIZ определена в stdio.h и задает рекомендуемый размер буфера ввода-вывода.

char buf[10]
fread(buf, 1, sizeof(buf), stdin);
printf("Прочитано: %s\n", buf); /* !!! */

Почему так нельзя?

int fseek(FILE *stream, long offset, int whence);
long ftell(FILE *stream);
void rewind(FILE *stream);
int fgetpos(FILE *stream, fpos_t *pos);
int fsetpos(FILE *stream, const fpos_t *pos);

Значения whence:

• SEEK_SET — смещение относительно начала,
• SEEK_CUR — относительно текущей позиции,
• SEEK_END — относительно конца файла.

Не все потоки допускают произвольное изменение позиции. В случае ошибки функции fseek(), ftell(), fgetpos() и fsetpos() возвращают -1 и устанавливают значение errno.

int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int sprintf(char *str, const char *format, ...);
int snprintf(char *str, size_t size, const char *format, ...);

При успешном выполнении возвращают количество напечатанных символов. Если возникла ошибка, то возвращается отрицательное значение.

int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *str, const char *format, ...);

При успешном выполнении данные функции возвращают количество входных совпавших и назначенных элементов, которое может быть меньше, чем предусматривалось, или даже равно нулю, в случае преждевременной ошибки при поиске совпадений. Если конец входных данных был достигнут раньше, чем произошло хотя бы одно совпадение или при ошибке совпадения возвращается значение EOF. Значение EOF также возвращается при ошибке чтения.

Выводим различные части строки "substring", используя установку терминального нуля и арифметику указателей:

#include <stdio.h>
#include <string.h>

int main (void) {
    char s[] = "substring";
    int n = strlen(s);

    /* Последние 6 символов: "string" */
    printf("%s\n", s + n - 6);

    /* Первые 3 симола: "sub" */
    char c = s[3];
    s[3] = '\0';
    printf("%s\n", s);

    /* Восстанавливаем строку в исходное состояние */
    s[3] = c;

    /* Символы с 4 по 6: "str" */
    s[6] = '\0';
    printf("%s\n", s + 3);

    return 0;
}

Разбиение строки:

char s[] = "one two three";

printf("%s\n", s); /* "one two three" */

/* Записываем терминальные нули на позиции пробелов */
s[3] = '\0';
s[7] = '\0';

/* Получилось 3 строки: s, (s + 4) и (s + 8) */
printf("%s\n", s);     /* "one" */
printf("%s\n", s + 4); /* "two" */
printf("%s\n", s + 8); /* "three" */

Функция strsep() (нестандартная, но доступна в glibc) делает это автоматически:

char s[] = "one two three";
char *sp = s;

while (sp != NULL) {
    printf("%s\n", strsep(&sp, " "));
}

Длина строки (варианты реализации strlen() были разобраны ранее):

size_t strlen(const char *s) {
    const char *p = s;

    while (*p != '\0')
        p++;

    return p - s;
}

Конкатенация (соединение) строк. Функция добавляет строку s2 в конец строки s1:

char *strcat(char *s1, const char *s2)
{
    char *p = s1;

    /* Ищем терминальный ноль в первой строке */
    while (*p != '\0')
        p++;

    /* Копируем символы второй строки в первую, начиная с этой позиции
       и до конца второй строки */
    while (*s2 != '\0') {
        *p = *s2;
        p++;
        s2++;
    }

    /* Далее устанавливаем терминальный ноль */
    *p = '\0';

    return s1;
}

Более компактная реализация:

char *strcat(char *s1, const char *s2)
{
    char *p = s1;

    while (*p)
        p++;

    /* Цикл закончится, когда будет присвоен '\0' */
    while ((*p++ = *s2++));

    return s1;
}

Двойные скобки в while использованы только для того, чтобы показать, что это намеренное присваивание, а не забытый символ в операторе сравнения. Без них GCC с -Wall выдаст предупреждение.

В стандартной библиотеке string.h определены функции для обработки строк:

/* Копирует строку из src в dest, возвращая указатель на конец строки
   результата в dest. */
char *stpcpy(char *dest, const char *src);

/* Добавляет строку src к строке dest, возвращая указатель на dest. */
char *strcat(char *dest, const char *src);

/* Возвращает указатель на местонахождение первого совпадения с
   символом c в строке s. */
char *strchr(const char *s, int c);

/* Сравнивает строки s1 и s2. */
int strcmp(const char *s1, const char *s2);

/* Сравнивает строки s1 и s2, применяя правила текущей локали. */
int strcoll(const char *s1, const char *s2);

/* Копирует строку src в dest, возвращая указатель на начало строки
   в dest. */
char *strcpy(char *dest, const char *src);

/* Вычисляет длину начального сегмента строки s, состоящего только
   из байт, не указанных в строке reject. */
size_t strcspn(const char *s, const char *reject);

/* Возвращает копию строки s, память для которой выделяется с
   помощью malloc(3). */
char *strdup(const char *s);

/* Переставляет символы в string в произвольном порядке. */
char *strfry(char *string);

/* Возвращает длину строки s. */
size_t strlen(const char *s);

/* Добавляет не более n байт из строки src в строку dest, возвращая
   указатель на dest. */
char *strncat(char *dest, const char *src, size_t n);

/* Сравнивает не более n байт строк s1 и s2. */
int strncmp(const char *s1, const char *s2, size_t n);

/* Копирует не более n байт из строки src в строку dest, возвращая
   указатель на dest. */
char *strncpy(char *dest, const char *src, size_t n);

/* Возвращает первое появление в строке s любых байтов из строки
   accept. */
char *strpbrk(const char *s, const char *accept);

/* Возвращает указатель на местонахождение последнего совпадения с
   символом c в строке s. */
char *strrchr(const char *s, int c);

/* Извлекает начальный токен из stringp, который отделён одним из
   байтов из delim. */
char *strsep(char **stringp, const char *delim);

/* Вычисляет длину начального сегмента из строки s, состоящего
   только из байт, указанных в accept. */
size_t strspn(const char *s, const char *accept);

/* Ищет первое соответствие подстроки needle в строке haystack и
   возвращает указатель на найденную подстроку. */
char *strstr(const char *haystack, const char *needle);

/* Извлекает токены из строки s, которые отделены одним из байтов
   из delim. */
char *strtok(char *s, const char *delim);

/* Преобразует src в текущую локаль и копирует первые n байт в
   dest. */
size_t strxfrm(char *dest, const char *src, size_t n);

А также функции для работы с последовательностями байтов, которые не обязательно должны быть строками (могут не заканчиваться нулевым символом и содержать нулевые символы в любом месте):

/* Копирование */
void *memcpy(void *dest, const void *src, size_t n);
void *memccpy(void *dest, const void *src, int c, size_t n);
void *memmove(void *dest, const void *src, size_t n);

/* Поиск */
void *memchr(const void *s, int c, size_t n);
void *memrchr(const void *s, int c, size_t n);
void *rawmemchr(const void *s, int c);

/* Сравнение */
int memcmp(const void *s1, const void *s2, size_t n);

/* Заполнение */
void *memset(void *s, int c, size_t n);

Пример использования strcmp() для проверки совпадения подстроки. Функция возвращает истину, если конец строки s совпадает со строкой suffix:

int ends_with(const char *s, const char *suffix) {
    size_t slen = strlen(s);
    size_t suffixlen = strlen(suffix);

    if (slen < suffixlen)
        return 0;

    return strcmp(s + slen - suffixlen, suffix) == 0;
}

Пример использования strncmp() для проверки совпадения подстроки. Функция возвращает истину, если начало строки s совпадает со строкой prefix:

int starts_with(const char *s, const char *prefix) {
    size_t slen = strlen(s);
    size_t prefixlen = strlen(prefix);

    if (slen < prefixlen)
        return 0;

    return strncmp(s, prefix, prefixlen) == 0;
}

В ctype.h определены функции для определения категорий и преобразования отдельных однобайтовых символов:

int   isalnum(int);
int   isalpha(int);
int   isascii(int);
int   isblank(int);
int   iscntrl(int);
int   isdigit(int);
int   isgraph(int);
int   islower(int);
int   isprint(int);
int   ispunct(int);
int   isspace(int);
int   isupper(int);
int   isxdigit(int);
int   toascii(int);
int   tolower(int);
int   toupper(int);

Например, isspace() проверяет, являются ли символы не отображаемыми. В локали «C» таковыми являются: пробел, символ перевода страницы '\f', символ новой строки '\n', символ перевода каретки '\r', символ горизонтальной табуляции '\t' и символ вертикальной табуляции '\v'.

Работа функций зависит от текущей локали. Доступны аналогичные функции с суффиксом _l и дополнительным аргументом типа locale_t для использования определенной локали.

Для работы с широкими символами (которые требуют более 8 бит для представления их кода), см. wchar.h и wctype.h. Вопрос обработки таких символов будет разобран позднее.

Пример: представление даты в файловой системе FAT.

struct file_date {
    uint16_t day: 5;
    uint16_t month: 4;
    uint16_t year: 7;
};

struct file_date mdate;

mdate.day = 11;
mdate.month = 11;
mdate.year = 42; /* 1980 + 42 = 2022 */

Объединения (union): память одновременно используется несколькими полями, можно интерпретировать те же байты как разные типы данных:

union int_date {
    uint16_t num;
    struct file_date fd;
};

union int_date u;
u.num = 12345;
printf("%d %d %d\n", u.fd.day, u.fd.month, u.fd.year + 1980);

Связный список — базовая динамическая структура данных, состоящая из узлов, каждый из которых содержит собственно данные и одну или две ссылки («связи») на следующий и/или предыдущий узел списка.

• Односвязный:

  struct node {
      T value;
      struct node *next;
  };
  

• Двухсвязный:

  struct node {
      T value;
      struct node *prev;
      struct node *next;
  };
  

Связный список обеспечивает сложность вставки и удаления элемента \(O(1)\), однако сложность доступа к элементу по его индексу составляет \(O(n)\).

На основе связных списков могут быть реализованы различные абстрактные типы данных коллекций:

• Список
• Стек
• Очередь
• Дек (двухсторонняя очередь)
• Кольцевой список

Пример реализации некоторых АТД с использованием связного списка.

Иерархическая структура данных, в которой каждый узел имеет не более двух потомков.

struct node {
    T value;
    struct node *left;
    struct node *right;
    struct node *parent; /* необязательно */
};

Двоичное дерево поиска — двоичное дерево, для которого выполняются следующие дополнительные условия:

• оба поддерева (левое и правое) являются двоичными деревьями поиска;
• у всех узлов левого поддерева произвольного узла X значения ключей данных меньше значения ключа данных самого узла X;
• у всех узлов правого поддерева произвольного узла X значения ключей данных больше либо равны значению ключа данных самого узла X.

Можно использовать для реализации ассоциативного массива, сопоставляющего ключи значениям. В отличие от обычного массива, ключи ассоциативного массива не обязательно являются последовательными числовыми индексами 0, 1, 2, …

Ассоциативный массив — абстрактный тип данных, позволяющий хранить пары вида (ключ, значение) и поддерживающий операции добавления пары, а также поиска и удаления пары по ключу:

• insert(ключ, значение) — добавить или заменить пару c указанным ключом;
• find(ключ) — найти значение по ключу;
• remove(ключ) — удалить пару с указанным ключом.

Ассоциативный массив не может хранить две пары с одинаковыми ключами.

Для реализации можно использовать деревья поиска или хеш-таблицы.

По мере работы программы выделяется все больше памяти, которая никогда не освобождается. Указатели на выделенную память заменяются другими значениями, что делает освобождение невозможным.

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    float real;
    float img;
} complex;

complex *make_complex(float real, float img) {
    complex *c = malloc(sizeof(complex));

    if (c == NULL) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    c->real = real;
    c->img = img;

    return c;
}

complex *cmpl_sum(const complex *a, const complex *b) {
    return make_complex(a->real + b->real,
                        a->img + b->img);
}

int main(void) {
    complex *sum = make_complex(0, 0);
    complex *c = make_complex(0, 0);

    while(scanf("%f%f", &c->real, &c->img) == 2) {
        /* Утечка памяти!!! */
        sum = cmpl_sum(sum, c);
        printf("Сумма: %f + %fi\n", sum->real, sum->img);
    }

    return EXIT_SUCCESS;
}

Возможное решение: использование автоматическог сборщика мусора (garbage collector), например, для Си доступен консервативный сборщик мусора Boehm–Demers–Weiser, предоставляющий макросы GC_MALLOC, GC_MALLOC_ATOMIC, и GC_REALLOC для замены стандартных функций.

8 бит на символ недостаточно — всего 256 различных значений. Стандарт Юникод версии 15.0 определяет 149 186 символов и поддерживает 161 письменность. Распространенная кодировка UTF-8 использует 1 байт для символов ASCII и 2 байта для символов кириллицы, а некоторые коды представляются 4 байтами.

#include <stdlib.h>
int mblen(const char *s, size_t n);

Многобайтовые строки можно преобразовать в строки широких символов типа wchar_t.

#include <stdlib.h>

int mbtowc(wchar_t *pwc, const char *s, size_t n);
size_t mbstowcs(wchar_t *dest, const char *src, size_t n);

Для определения широких литералов используется префикс L:

wchar_t wc = L'😀';
/* или так: wchar_t wc = L'\U0001F600'; */
wchar_t *ws = L"фывапролдж";

Функции ввода-вывода доступны в wchar.h:

int wprintf(const wchar_t *format, ...);
int fwprintf(FILE *stream, const wchar_t *format, ...);

int fwscanf(FILE *stream, const wchar_t *format, ...);
int wscanf(const wchar_t *format, ...);

wint_t fputwc(wchar_t wc, FILE *stream);
int fputws(const wchar_t *ws, FILE *stream);

wint_t fgetwc(FILE *stream);
wchar_t *fgetws(wchar_t *ws, int n, FILE *stream);

#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>

int main(void) {
    wchar_t wc = L'\U0001F600';
    wchar_t *ws = L"фывапролдж";

    /* Без setlocale правильно не выведет */
    setlocale(LC_ALL, "");
    /* или так, если мы хотим всегда выводить в UTF-8:
       setlocale(LC_CTYPE, "C.UTF-8"); */

    fwprintf(stdout, L"%lc %ls\n", wc, ws);

    return 0;
}

Пример: определение длины строки в многобайтовой кодировке и вывод символов через пробел (С  Р А З Р Я Д К О Й):

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <locale.h>

int main() {
    setlocale(LC_CTYPE, "C.UTF-8");

    /* Строка в UTF-8 */
    char *s = "ПРИВЕТ";

    size_t n = strlen(s);
    printf("%zu\n", n); /* 12 */

    /* Пытаемся вывести символы через пробел —
       получается ерунда */
    for (int i = 0; i < n; i++)
        /* Добавляем пробел перед всеми символами,
           кроме начального */
        printf("%s%c", i > 0 ? " ": "", s[i]);
    printf("\n");

    /* Количество многобайтовых символов */
    size_t wn = mbstowcs(NULL, s, 0);

    /* Возможна ошибка: не любая последовательность байтов
       соответствует широкому символу, и нужна подходящая локаль
       (попробуйте закомментировать setlocale выше). */
    if (wn == (size_t) -1) {
        perror("mbstowcs");
        exit(EXIT_FAILURE);
    }

    printf("%zu\n", wn); /* 6 — правильно */

    /* Преобразуем s в длинную строку */
    wchar_t ws[wn + 1]; /* Количество символов плюс терминальный ноль */
    mbstowcs(ws, s, wn);

    /* Выводим широкие символы через пробел —
       теперь дейтсвительно выводит "П Р И В Е Т" */
    for (int i = 0; i < wn; i++)
        printf("%s%lc", i > 0 ? " " : "", ws[i]);
    printf("\n");

    return EXIT_SUCCESS;
}

Вывод

12
▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒
6
П Р И В Е Т

Функции для проверки типа широких символов, аналогичные функциям в ctype.h:

#include <wctype.h>

int iswalnum(wint_t);
int iswalpha(wint_t);
wint_t towlower(wint_t);
wint_t towupper(wint_t);
…

Обычно функция возвращает управление в точку вызова. Нельзя использовать goto для выхода извне функции, но нелокальные переходы все же возможны.

#include <setjmp.h>

int setjmp(jmp_buf env);
void longjmp(jmp_buf env, int val);

Первая функция позволяет установить позицию для последующего возврата, вторая — перейти в установленную точку. На практике механизм нелокальных переходов также используется редко, обычно — для обработки ошибок.

#include <setjmp.h>
#include <stdio.h>

jmp_buf env;

void f1(void);
void f2(void);

int main(void) {
    if (setjmp(env) == 0) {
        printf("setjmp returned 0\n");
    } else {
        printf("Program terminates: longjmp called\n");
        return 0;
    }

    f1();

    printf("Program terminates normally\n");    
    return 0;
}


void f1(void) {
    printf("f1 begins\n");
    f2();
    printf("f1 returns\n");
}

void f2(void) {
    printf("f2 begins\n");
    longjmp(env, 1);
    printf("f2 returns\n");
}

Вывод:

setjmp returned 0
f1 begins
f2 begins
Program terminates: longjmp called

• ~a — двоичное дополнение.

  ~0b10101000 ⇒ 0b11111111111111111111111101010111
  ~0 ⇒ 0b11111111111111111111111111111111
  ~0b11111111111111111111111111111111 ⇒ 0
  ~ (-1) ⇒ 0
  

  Следствия использования дополнительного кода:

  • ~x + 1 ​=​= -x
  • ~x ​=​= -x - 1

• a & b — побитовое «И» («AND»).

  0b10101010 & 0b11001100 ⇒ 0b10001000
  

• a | b — побитовое «ИЛИ» («OR»).

  0b10101010 | 0b11001100 ⇒ 0b11101110
  

• a ^ b — побитовое исключающее «ИЛИ» («XOR»).

  0b10101010 ^ 0b11001100 ⇒ 0b01100110
  

  Свойства:

  x ^ 0 == x
  x ^ x == 0
  Коммутативность: x ^ y == y ^ x
  Ассоциативность: x ^ (y ^ z) == (x ^ y) ^ z
  

  • XOR-обмен:

    x = x ^ y;
    y = y ^ x;
    x = x ^ y;
    

  • шифрование (одноразовый блокнот)
  • XOR-связный список

Пример: функция open() API POSIX:

/* Сброс маски процесса, т. к. open использует эффективный режим,
   вычисляемый как mode & ~umask. */
umask(0)

/* Режим доступа: все права для владельца, группы, и остальных. */
int mode = S_IRWXU | S_IRWXG | S_IRWXO;

/* Убрать биты записи для группы и остальных. */
mode &= ~(S_IWGRP | S_IWOTH);
/* Или можно было установить маску:
   umask(S_IWGRP | S_IWOTH); */

/* Комбинация флагов:
   создать файл, только если не существует, открыть для записи. */
int fd = open(path1, O_CREAT | O_EXCL | O_WRONLY, mode);

/* Был ли задан бит записи для владельца? */
if (mode & S_IWUSR) /* истина */
    …;

• << — сдвиг влево:

  5 << 2 ⇒ 20

• >> — сдвиг вправо

  5 >> 2 ⇒ 1

Сдвиг влево на 1 бит эквивалентен умножению на 2:

5 << 3 == 5 * 2*2*2
-10 << 4 == -10 * 2*2*2*2

Сдвиг вправо сохраняет знак для знаковых типов и эквивалентен делению на 2, но с округлением в меньшую сторону а не к 0:

19 >> 2 == 4
20 >> 2 == 5
21 >> 2 == 5
-1 >> 1 == -1
-5 >> 1 == -3
-5 / 2 == -2

Приемы со сдвигами:

• Установка j-го бита i:

  i |= 1 << j;
  

• Сброс j-го бита значения i:

  i &= ~(1 << j);
  

• Проверка j-го бита значения i:

  if (i & (1 << j)) …;
  

• Упаковка значений:

  /* Дата первого релиза GCC */
  unsigned int d = 22;
  unsigned int m = 3;
  unsigned int y = 1987;
  unsigned int date = ((y << 4) + m) << 5) + d;
  

  Обратно:

  d = date % 32;
  m = (date >> 5) % 16;
  y = date >> 9;
  

Пример использование ассемблерной вставки в код программы на Си

#include <stdio.h>

int main ()
{
  int res = 0, a = 105, m = 5, rand = 0;

  __asm__ volatile( "imull %%ecx, %%eax\n" /* ассемблерная вставка */
                    "rdrand %%ebx"
                    : "=a" (res), /* выходные операнды */
                      "=b" (rand),
                      "+c" (m)    /* и параметры */
                    : "a" (a)
                    : "memory", "cc" );

  printf("%d\n", res);
  printf("%u\n", rand);

  return 0;
}

Rdrand это инструкция процессоров, относящихся к архитектуре x86, для генерации случайного числа при помощи внутреннего генератора случайных чисел. Rdrand является опциональным расширением набора инструкций x86-64 и IA-32. В процессорах Intel доступна, начиная с архитектуры Ivy Bridge, в процессорах AMD — начиная с модели Ryzen. Данный генератор случайных чисел соответствует стандартам безопасности и криптографическим стандартам, таким как NIST SP800-90, FIPS 140-2, и ANSI X9.82.

Intel Secure Key, также известный как Bull Mountain, — условное название Intel для инструкции rdrand и реализующего её аппаратного генератора случайных чисел (RNG). Intel называет их ГСЧ и «цифровой генератор случайных чисел». Генератор использует встроенный в процессор источник энтропии.

Для проверки поддержки процессором RDRAND можно использовать инструкцию CPUID. При наличии поддержки бит 30 регистра ECX оказывается установлен после вызова функции 01H инструкции CPUID.

• C++ и викиучебник. Основы С++ от Яндекс

C++ — компилируемый, статически типизированный язык программирования общего назначения.

Поддерживает такие парадигмы программирования, как процедурное программирование, объектно-ориентированное программирование, обобщённое программирование. Язык имеет богатую стандартную библиотеку, которая включает в себя распространённые контейнеры и алгоритмы, ввод-вывод, регулярные выражения, поддержку многопоточности и другие возможности.

C++ сочетает свойства как высокоуровневых, так и низкоуровневых языков.

В сравнении с языком C — наибольшее внимание уделено поддержке объектно-ориентированного и обобщённого программирования.

Область его применения включает создание операционных систем, разнообразных прикладных программ, драйверов устройств, приложений для встраиваемых систем, высокопроизводительных серверов, а также компьютерных игр. Существует множество реализаций языка C++, как бесплатных, так и коммерческих и для различных платформ.

C++ оказал огромное влияние на другие языки программирования, в первую очередь на Java и C#.

Синтаксис C++ унаследован от языка C. Изначально одним из принципов разработки было сохранение совместимости с C. Тем не менее C++ не является в строгом смысле надмножеством C; множество программ, которые могут одинаково успешно транслироваться как компиляторами C, так и компиляторами C++, довольно велико, но не включает все возможные программы на C.

Язык возник в начале 1980-х годов, когда сотрудник фирмы Bell Labs Бьёрн Страуструп придумал ряд усовершенствований к языку C под собственные нужды (задачи теории очередей в приложении к моделированию телефонных вызовов).

Язык C, будучи базовым языком системы UNIX, на которой работали компьютеры Bell, является быстрым, многофункциональным и переносимым. Страуструп добавил к нему возможность работы с классами и объектами. В результате практические задачи моделирования оказались доступными для решения как с точки зрения времени разработки, так и с точки зрения времени вычислений. В первую очередь в C были добавлены классы (с инкапсуляцией), наследование классов, строгая проверка типов, inline-функции и аргументы по умолчанию. Ранние версии языка, первоначально именовавшегося «C with classes» («Си с классами»), стали доступны с 1980 года.

К 1983 году в язык были добавлены новые возможности, такие как виртуальные функции, перегрузка функций и операторов, ссылки, константы, пользовательский контроль над управлением свободной памятью, улучшенная проверка типов и новый стиль комментариев (//). Получившийся язык уже перестал быть просто дополненной версией классического C и был переименован из C с классами в «C++».

Никто не обладает правами на язык C++, он является свободным.

Стандарт C++ состоит из двух основных частей: описание ядра языка и описание стандартной библиотеки (только в 1998 году язык стал стандартизированным).

• C++ поддерживает как комментарии в стиле C (/* комментарий */), так и однострочные (//)
• Спецификатор inline для функций. Функция, определённая внутри тела класса, является inline по умолчанию. Данный спецификатор является подсказкой компилятору и может встроить тело функции в код вместо её непосредственного вызова.
• Квалификаторы const и volatile. В отличие от С, где const обозначает только доступ на чтение, в C++ переменная с квалификатором const должна быть инициализирована. volatile используется в описании переменных и информирует компилятор, что значение данной переменной может быть изменено способом, который компилятор не в состоянии отследить. Для переменных, объявленных volatile, компилятор не должен применять средства оптимизации, изменяющие положение переменной в памяти (например, помещающие её в регистр) или полагающиеся на неизменность значения переменной в промежутке между двумя присваиваниями ей значения.
• Для работы с памятью введены операторы new, new[], delete и delete[]. В отличие от библиотечных malloc и free, пришедших из C, данные операторы производят инициализации объекта. Для классов — это вызов конструктора, для POD-типов инициализацию можно либо не проводить(new Pod;) либо провести инициализацию нулевыми значениями (new Pod(); new Pod {};).
• Пространства имён (namespace).

  namespace Foo
  {
     const int x = 5;
  }
  
  const int y = Foo::x;
  

  Специальным случаем является безымянное пространство имён. Все имена, описанные в нём, доступны только в текущей единице трансляции и имеют локальное связывание. Пространство имён std содержит в себе стандартные библиотеки C++.

В C++ доступны следующие встроенные типы. Типы C++ практически полностью повторяют типы данных в C:

• символьные: char, wchar_t (char16_t и char32_t, в стандарте C++11);
• целочисленные знаковые: signed char, short int, int, long int (и long long, в стандарте C++11);
• целочисленные беззнаковые: unsigned char, unsigned short int, unsigned int, unsigned long int (и unsigned long long, в стандарте C++11);
• с плавающей точкой: float, double, long double;
• логический: bool, имеющий значения либо true, либо false.

C++ добавляет к C объектно-ориентированные возможности. Он вводит классы, которые обеспечивают три самых важных свойства ООП: инкапсуляцию, наследование и полиморфизм.

В стандарте C++ под классом подразумевается пользовательский тип, объявленный с использованием одного из ключевых слов class, struct или union, под структурой подразумевается класс, определённый через ключевое слово struct, и под объединением подразумевается класс, определённый через ключевое слово union. В зависимости от использованного ключевого слова меняются также и некоторые свойства самого класса. Например, в классе, объявленным через struct, члены без вручную прописанного модификатора доступа будут по умолчанию иметь публичный уровень доступа, а не приватный.

Стандартная библиотека C++ включает в себя набор средств, которые должны быть доступны для любой реализации языка, чтобы обеспечить программистам удобное пользование языковыми средствами и создать базу для разработки как прикладных приложений самого широкого спектра, так и специализированных библиотек. Стандартная библиотека C++ включает в себя часть стандартной библиотеки C.

Доступ к возможностям стандартной библиотеки C++ обеспечивается с помощью включения в программу (посредством директивы #include) соответствующих стандартных заголовочных файлов.

Стандартная библиотека включает в себя следующие разделы:

• Поддержка языка. Включает средства, которые необходимы для работы программ, а также сведения об особенностях реализации. Выделение памяти, RTTI, базовые исключения, пределы значений для числовых типов данных, базовые средства взаимодействия со средой, такие как системные часы, обработка сигналов UNIX, завершение программы.
• Стандартные контейнеры. В стандартную библиотеку входят шаблоны для следующих контейнеров: динамический массив (vector), статический массив (array), одно- и двунаправленные списки (forward_list, list), стек (stack), дек (deque), ассоциативные массивы (map, multimap), множества (set, multiset), очередь с приоритетом (priority_queue).
• Основные утилиты. В этот раздел входит описание основных базовых элементов, применяемых в стандартной библиотеке, распределителей памяти и поддержка времени и даты в стиле C.
• Итераторы. Обеспечивают шаблоны итераторов, с помощью которых в стандартной библиотеке реализуется стандартный механизм группового применения алгоритмов обработки данных к элементам контейнеров.
• Алгоритмы. Шаблоны для описания операций обработки, которые с помощью механизмов стандартной библиотеки могут применяться к любой последовательности элементов, в том числе к элементам в контейнерах. Также в этот раздел входят описания функций bsearch() и qsort() из стандартной библиотеки C.
• Строки. Шаблоны строк в стиле C++. Также в этот раздел попадает часть библиотек для работы со строками и символами в стиле C.
• Ввод-вывод. Шаблоны и вспомогательные классы для потоков ввода-вывода общего вида, строкового ввода-вывода, манипуляторы (средства управления форматом потокового ввода-вывода в стиле C++).
• Локализация. Определения, используемые для поддержки национальных особенностей и форматов представления (дат, валют и т. д.) в стиле C++ и в стиле C.
• Диагностика. Определения ряда исключений и механизмов проверки утверждений во время выполнения (assert). Поддержка обработки ошибок в стиле C.
• Числа. Определения для работы с комплексными числами, математическими векторами, поддержка общих математических функций, генератор случайных чисел.

• Добавлена библиотека , реализующая общепринятые механизмы поиска и подстановки с помощью регулярных выражений.
• Добавлена поддержка многопоточности.
• Атомарные операции
• unordered-варианты ассоциативных массивов и множеств.
• Умные указатели, обеспечивающие автоматическое освобождение выделенной памяти.

#include <iostream>

// Импортируем все объявления в пространстве имён "std" в глобальное пространство имён.
using namespace std;

int main()
{
    cout << "Hello, world!" << endl;
    return 0;
}

Во многих направлениях ПО C по-прежнему доминирует:

• Ядра операционных систем, например, Linux.
• Микроконтроллеры
• Видеокодеки
• Общие низкоуровневые библиотеки наподобие OpenSSL
• Инструменты командной строки Unix наподобие ls, cat и git

Можно отметить рост популярности Go (Разрабатываемый компанией Google) и Rust (поддерживаемый корпорацией Mozilla). Наблюдается, что некоторые стандартные инструменты, в прошлом обычно создававшиеся на C или C++, теперь переписываются на Go или Rust. Например, появляется множество инструментов командной строки, написанных на одном из этих языков. На Rust пишутся даже игровые движки.

Rust и Go - два современных языка, получивших значительное распространение в последние годы, каждый из которых обладает своими уникальными достоинствами и недостатками.

Производительность является важнейшим фактором при выборе языка для разработки, поскольку она может напрямую влиять на отзывчивость и масштабируемость ваших приложений. Rust и Go имеют различные подходы к достижению высокой производительности, и понимание этих различий жизненно важно для правильного выбора для вашего конкретного случая использования.

Классифицируем языки:

C, C++, Rust - высокопроизводительные языки.

Rust, Golang, Java, Python - языки с автоматическим управлением памятью.

Rust

Rust - это язык системного программирования, в котором особое внимание уделяется безопасности, параллельности и производительности. Он разработан для обеспечения низкоуровневого контроля над системными ресурсами и памятью, подобно таким языкам, как C и C++. Rust достигает высокой производительности за счет абстракций с нулевыми затратами, что означает, что абстракции практически не несут накладных расходов во время выполнения. Это позволяет разработчикам писать высокоуровневый код без ущерба для производительности.

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

Go

Go, также известный как Golang, - это статически типизированный компилируемый язык, который был создан в Google для повышения производительности и простоты использования крупномасштабных программных проектов. Go был разработан с учетом простоты и стремился найти баланс между простотой использования динамических языков, таких как Python и Ruby, и производительностью компилируемых языков, таких как C и C++.

Сравнение производительности

Если сравнивать Rust и Go с точки зрения производительности, то Rust, как правило, имеет преимущество благодаря низкоуровневому управлению и абстракциям с нулевыми затратами. Производительность Rust более сопоставима с такими языками, как C и C++, что делает его лучшим выбором для случаев использования, требующих максимальной производительности и эффективности использования ресурсов, таких как системное программирование или высокопроизводительные вычисления.

Особенности языка

Возможности языка программирования могут оказать значительное влияние на производительность разработчика, удобство сопровождения кода и общий успех проекта. Rust и Go обладают собственным набором возможностей языка, которые предназначены для различных стилей разработки и случаев использования.

Особенности языка Rust

Rust - это многофункциональный язык, в котором большое внимание уделяется безопасности, параллелизму и производительности. Среди особенностей языка Rust можно выделить следующие:

• Система владения: Система владения в Rust позволяет осуществлять тонкий контроль над распределением и деаллокацией памяти, обеспечивая безопасность памяти во время компиляции без необходимости использования сборщика мусора. Эта система помогает предотвратить такие распространенные ошибки программирования, как разыменования нулевого указателя, гонки данных и ошибки использования после освобождения.
• Сопоставление шаблонов: Сопоставление шаблонов в Rust - это мощная функция, которая позволяет создавать лаконичный и выразительный код при работе со сложными типами данных, такими как перечисления и структуры. Эта функция помогает улучшить читаемость и сопровождаемость кода.
• Вывод типов: Система вывода типов в Rust позволяет сделать код более лаконичным за счет автоматического вывода типов переменных во многих случаях. Это помогает сократить количество шаблонов и сделать код более легким для чтения и написания.
• Макросы: Rust поддерживает макросы, которые позволяют разработчикам определять многократно используемые фрагменты кода, которые могут быть расширены во время компиляции. Макросы могут помочь сократить дублирование кода и повысить гибкость вашей кодовой базы.

Особенности языка Go

Язык Go разработан с учетом простоты и удобства использования, подчеркивая небольшой и последовательный набор языковых функций, ориентированных на производительность и удобство сопровождения. Некоторые из примечательных особенностей языка Go включают:

• Гороутины: Легкая модель параллелизма в Go основана на горутинах, которые похожи на потоки, но требуют меньше ресурсов. Гороутины облегчают написание параллельного и параллельного кода, повышая производительность и масштабируемость ваших приложений.
• Каналы: Каналы - это примитив синхронизации в Go, который обеспечивает безопасное взаимодействие между горутинами. Каналы упрощают написание параллельного кода без необходимости использования сложных механизмов блокировки, улучшая читаемость и сопровождаемость кода.
• Интерфейсы: Интерфейсы Go предоставляют мощный способ определения абстрактных типов и обеспечивают полиморфизм, позволяя создавать более гибкий и удобный в обслуживании код. В отличие от традиционного наследования, Go использует композицию и интерфейсы, что способствует многократному использованию кода и упрощает проектирование больших систем.
• Сборка мусора: Go включает в себя сборщик мусора, который упрощает управление памятью и помогает предотвратить утечки памяти и другие распространенные ошибки программирования. Это может облегчить написание безопасного и сопровождаемого кода, особенно для разработчиков, которые только начинают программировать системы.

Сравнение особенностей языка

Если сравнивать Rust и Go с точки зрения возможностей языка, то Rust предлагает более широкий набор функций и больший контроль над системными ресурсами, что делает его хорошо подходящим для низкоуровневого системного программирования и высокопроизводительных приложений. Система владения, согласование шаблонов и макросы Rust могут дать значительные преимущества в плане безопасности и выразительности кода.

С другой стороны, Go ставит во главу угла простоту и удобство использования, что делает его отличным выбором для разработчиков, которым важны производительность и удобство сопровождения. Гороутины, каналы и интерфейсы Go позволяют легко писать параллельные и масштабируемые бэкенд-приложения с минимальным количеством кода. Кроме того, сборщик мусора в Go помогает упростить управление памятью и предотвратить распространенные ошибки программирования.

Rust и Go обладают собственным набором языковых функций, которые подходят для разных стилей разработки и случаев использования. Rust может быть лучшим выбором для разработчиков, которым требуется тонкий контроль над системными ресурсами и памятью, в то время как Go, вероятно, больше подходит для тех, кто ставит во главу угла простоту, производительность и легкость в использовании.

Параллелизм и параллелизм

Важными аспектами при разработке бэкенда являются параллелизм и параллельность, поскольку они могут значительно повлиять на производительность и масштабируемость ваших приложений. Rust и Go имеют свои собственные подходы к обработке параллелизма и параллелизма, с различными компромиссами и преимуществами.

Параллелизм и параллелизм в Rust

Rust предоставляет комбинацию потоков, каналов и async/await для параллелизма и параллелизма. Потоки в Rust похожи на потоки в других языках, позволяя выполнять несколько задач одновременно. Каналы в Rust, вдохновленные языком Go, обеспечивают безопасное взаимодействие между потоками и помогают предотвратить гонки данных и другие проблемы синхронизации.

Rust также поддерживает асинхронное программирование благодаря синтаксису async/await, который позволяет осуществлять неблокирующий ввод/вывод и эффективно решать задачи, на выполнение которых может потребоваться много времени. Экосистема асинхронного программирования Rust, включая популярные библиотеки async-std и Tokio, предоставляет мощные инструменты для создания высокопроизводительных параллельных приложений.

Параллелизм и параллелизм в Go

Подход Go к параллелизму и параллельности вращается вокруг горутин и каналов. Гороутины - это легкие, параллельные единицы выполнения, которые управляются средой выполнения Go и требуют гораздо меньше ресурсов, чем традиционные потоки. Это позволяет легко порождать тысячи или даже миллионы горутин, обеспечивая высокую параллельность и масштабируемость приложений.

Каналы в Go обеспечивают безопасное взаимодействие между горутинами, позволяя разработчикам писать параллельный код с минимальными накладными расходами на синхронизацию. Оператор select в Go позволяет обрабатывать несколько каналов одновременно, что еще больше упрощает параллельное программирование.

Сравнение параллелизма и параллелизма

Если сравнивать Rust и Go с точки зрения параллелизма и параллельности, то оба языка предоставляют мощные инструменты для создания параллельных приложений. Rust предлагает более гибкий подход с потоками, каналами и async/await, удовлетворяя широкий спектр сценариев использования и требований к производительности. Гороутины и каналы в Go позволяют легко писать параллельный код с минимальным количеством шаблонов, что может значительно повысить производительность и удобство сопровождения кода.

Rust может быть лучшим выбором для разработчиков, которым требуется тонкий контроль над параллелизмом и параллельностью или которые работают над высокопроизводительными приложениями. Go, вероятно, больше подходит для тех, кто ставит во главу угла простоту, производительность и легкость в использовании при создании параллельных бэкенд-приложений.

Безопасность памяти

Безопасность памяти - критически важный аспект разработки бэкенда, поскольку она может напрямую влиять на стабильность и безопасность ваших приложений. Rust и Go имеют различные подходы к обеспечению безопасности памяти, с разными уровнями гарантий и компромиссов.

Безопасность памяти в Rust

Rust разработан с акцентом на безопасность памяти, чтобы устранить такие распространенные ошибки программирования, как разыменования нулевого указателя, гонки данных и ошибки использования после освобождения. В Rust безопасность памяти достигается благодаря системе владения, которая обеспечивает строгие правила выделения, доступа и деаллокации памяти.

Компилятор Rust обеспечивает безопасность памяти во время компиляции, гарантируя, что небезопасный код не может быть выполнен. Это означает, что приложения на языке Rust по своей природе более безопасны и менее подвержены ошибкам, связанным с памятью, чем те, которые написаны на языках без таких гарантий.

Безопасность памяти в Go

Go предоставляет более простую модель памяти по сравнению с Rust, полагаясь на сборщик мусора для управления распределением и деаллокацией памяти. Хотя сборщик мусора в Go может помочь предотвратить утечки памяти и другие распространенные ошибки программирования, он не обеспечивает такой же уровень гарантий безопасности памяти, как система владения в Rust.

Go включает некоторые функции, помогающие смягчить проблемы безопасности памяти, такие как проверка границ для фрагментов и массивов, а также встроенный детектор гонок. Однако эти функции не обеспечивают такого же уровня безопасности, как гарантии времени компиляции в Rust.

Сравнение безопасности памяти

Если сравнивать Rust и Go с точки зрения безопасности памяти, то Rust имеет явное преимущество благодаря своей системе владения и гарантиям времени компиляции. Ориентация Rust на безопасность памяти помогает предотвратить широкий спектр ошибок и уязвимостей в безопасности, что делает его отличным выбором для внутренних приложений, требующих высокого уровня стабильности и безопасности.

Go, с другой стороны, обеспечивает более простую модель памяти с некоторыми функциями безопасности, но не предлагает такого уровня гарантий, как Rust. Этот компромисс может быть приемлемым для некоторых приложений, особенно тех, для которых простота и удобство использования приоритетнее строгой безопасности памяти.

Экосистема и библиотеки

Экосистема и доступные библиотеки для языка программирования могут значительно повлиять на скорость и простоту разработки. Развитая экосистема с широким набором библиотек и инструментов может помочь разработчикам быстро создавать и внедрять приложения, в то время как менее развитая экосистема может потребовать более тщательной разработки или обходных путей.

Экосистема и библиотеки Rust

В последние годы Rust неуклонно развивает свою экосистему и библиотечную поддержку, большое количество библиотек сторонних разработчиков доступно через менеджер пакетов Cargo. Экосистема Rust включает библиотеки для веб-разработки, баз данных, сетевых технологий и многое другое, удовлетворяя широкий спектр потребностей бэкенд-разработки.

Однако экосистема Rust все еще относительно молода по сравнению с более развитыми языками, такими как Go, и в ней может быть не так много вариантов или зрелых библиотек для определенных случаев использования. Иногда это может усложнить поиск подходящих библиотек или инструментов для ваших конкретных нужд.

Экосистема и библиотеки Go

Go имеет более развитую экосистему по сравнению с Rust, с большой стандартной библиотекой и множеством библиотек сторонних разработчиков, доступных через систему управления пакетами Go Modules. Экосистема Go включает библиотеки для веб-разработки, баз данных, сетей и многого другого, что позволяет легко находить и использовать существующие решения для большинства задач разработки бэкенда.

Широкая поддержка библиотек и развитая экосистема Go могут помочь разработчикам быстро создавать и внедрять приложения, сокращая необходимость в разработке на заказ или обходных путях. Это может стать значительным преимуществом для команд, которые ценят быструю разработку и простоту использования.

Сравнение экосистемы и библиотек

При сравнении Rust и Go с точки зрения экосистемы и библиотек, Go имеет явное преимущество благодаря своей более развитой экосистеме и большой стандартной библиотеке. Широкая поддержка библиотек Go может помочь разработчикам быстро создавать и развертывать приложения, что делает его привлекательным выбором для проектов по разработке бэкенда, для которых приоритетны скорость и простота использования.

Экосистема Rust все еще развивается и имеет множество сторонних библиотек, но для определенных случаев использования может не хватать опций или зрелых библиотек. Этот компромисс может быть приемлемым для некоторых разработчиков, особенно для тех, кто работает над проектами, требующими уникальных возможностей и преимуществ производительности Rust.

Кривая обучения и сообщество

Кривая обучения и поддержка языка программирования сообществом могут значительно повлиять на легкость внедрения и успех проекта. Язык с крутой кривой обучения может потребовать больше времени и усилий для приобретения навыков, в то время как язык с сильным сообществом и широкими ресурсами может помочь разработчикам быстро преодолеть трудности и освоить лучшие практики.

Кривая обучения и сообщество Rust

Rust часто считается более сложным языком по сравнению с Go из-за уникальной системы владения и более сложных функций языка. Тем не менее, сообщество Rust известно своей дружелюбностью и поддержкой, а также обилием ресурсов, помогающих разработчикам изучать язык и преодолевать трудности.

Сообщество Rust подготовило обширную документацию, учебники и обучающие ресурсы, такие как официальная книга по Rust, Rust by Example и курс Rustlings. Кроме того, сообщество Rust активно работает на форумах, в чатах и социальных сетях, являясь ценным источником поддержки и знаний для разработчиков любого уровня подготовки.

Кривая обучения Go и сообщество

Считается, что Go имеет меньшую кривую обучения, чем Rust, благодаря своей простоте и минимальному синтаксису. Благодаря прямолинейному подходу к программированию на Go разработчики могут быстро освоить язык и начать создавать приложения с минимальными усилиями.

Сообщество Go также довольно большое и активное, с множеством ресурсов, доступных для изучения языка и преодоления трудностей. Официальный сайт Go предоставляет обширную документацию и учебники, а сообщество Go активно работает на форумах, в чатах и социальных сетях, обеспечивая поддержку и знания для разработчиков любого уровня подготовки.

Сравнение кривой обучения и сообщества

Если сравнивать Rust и Go с точки зрения кривой обучения и поддержки сообщества, то Go обычно считается более легким в изучении благодаря своей простоте и минимальному синтаксису. Это может сделать его привлекательным выбором для разработчиков, которые ценят продуктивность и простоту использования или являются новичками в системном программировании.

С другой стороны, Rust имеет более сложную кривую обучения из-за уникальной системы владения и более сложных функций языка. Однако сильное сообщество и богатые учебные ресурсы Rust могут помочь разработчикам преодолеть эти трудности и овладеть языком. Это может быть достойным компромиссом для разработчиков, которых привлекает безопасность, производительность и гибкость Rust.

Rust и Go имеют свои собственные кривые обучения и поддержку сообщества, удовлетворяя различные потребности и предпочтения разработчиков. Rust может больше подойти тем, кто готов потратить время и усилия на освоение его уникальных возможностей и воспользоваться преимуществами его безопасности и производительности. Go, вероятно, больше подходит тем, кто при изучении нового языка для разработки бэкенда отдает предпочтение простоте, быстрой разработке и легкости в использовании.

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

Примеры использования и отраслевое применение языка программирования могут дать ценную информацию о его пригодности для разработки бэкенда. Rust и Go были приняты различными отраслями и компаниями, каждая из которых имеет свои уникальные требования и сценарии использования.

Примеры использования Rust и его применение в промышленности

Rust находит все большее применение в таких отраслях, как веб-разработка, системное программирование, встраиваемые системы и разработка игр. Такие компании, как Mozilla, Dropbox и Cloudflare, используют Rust для своей критической инфраструктуры и высокопроизводительных систем. Ориентация Rust на безопасность, производительность и параллелизм делает его хорошо подходящим для таких требовательных приложений.

Кроме того, поддержка WebAssembly в Rust позволила ему стать популярным выбором для создания высокопроизводительных веб-приложений, запускаемых в браузере, что еще больше расширило сферу его использования и распространение в промышленности.

Примеры использования Go и внедрение в промышленности

Go получил широкое распространение в таких отраслях, как веб-разработка, облачные вычисления и распределенные системы. Такие компании, как Google, Uber и Kubernetes, выбрали Go для своих масштабных внутренних систем и инфраструктуры, оценив его простоту, удобство использования и масштабируемость. Легкая модель параллелизма Go и ориентация на производительность разработчиков делают его привлекательным выбором для таких типов приложений. Go также является популярным выбором для создания API, микросервисов и бессерверных функций благодаря сильной стандартной библиотеке и поддержке современных методов разработки.

Сравнение примеров использования и внедрения в промышленности

Если сравнивать Rust и Go с точки зрения примеров использования и внедрения в отрасли, то оба языка нашли успех в различных приложениях и отраслях. Rust хорошо подходит для высокопроизводительных, критичных к безопасности систем, в то время как Go часто выбирают для крупномасштабных внутренних систем и инфраструктуры, для которых приоритетны простота и удобство использования.

В конечном счете, выбор между Rust и Go для разработки будет зависеть от вашего конкретного случая использования, требований к производительности и приоритетов разработки. Оба языка доказали свою ценность в различных сценариях и могут быть успешным выбором для проектов.

Рассмотрим пример main.go:

package main
import "fmt"
 
func main() {
    fmt.Println("Hello Go!")
}

package main // определили пакет main

import "fmt" // импортировали пакет fmt

// функция для входа в программу
func main() {
	var name string // объявили переменную name типа string
	fmt.Scan(&name) // считали переменную name с потока ввода

	// функция Print() печатает сообщение в консоль
	fmt.Print("Hello, ", name)
}

В Go есть два способа запуска программ:

• С помощью команды go run <имя_файла>.go . Она автоматически компилирует исполняемый файл, запускает его и сразу же удаляет. Этот способ используется в тех случаях, когда нужно разово запустить небольшой кусок кода и быстро получить результат.
• С помощью команды go build <имя_файла>.go . Она также занимается компиляцией и создает в директории исполняемый файл, способный запускаться на разных ОС. Особенностью этой команды является то, что она обеспечивает кроссплатформенность, так как позволяет контролировать, для какой ОС и архитектуры создается бинарный файл.

Рассмотрим второй пример main.rs:

fn main() {
    println!("Привет, мир!");
}

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}