С/С++ Portal | Программирование

Способ вкатиться в робототехнику: опенсорсная дорожная карта Robotics Master Она сводит в одну программу хорошие курсы из Боннского университета, Мюнхенского технического университета и MIT, и за 21 месяц предлагает пройти обучение уровня магистратуры по робототехнике. План разбит на 7 семестров и идет по нарастающей: стартуешь с базы по C++, дальше постепенно углубляешься в мобильных роботов, компьютерное зрение, планирование траекторий, deep learning и другие ключевые направления. Программа покрывает темы вроде 2D/3D computer vision, планирования маршрутов для автономных систем, методов оптимизации в робототехнике, сенсорики, 3D SLAM. Для каждого семестра есть четкие цели и привязанные видеоматериалы. Плюс добавлены доп. ресурсы по PyTorch, линейной алгебре, матану и т.п., чтобы подтянуть математику и кодинг. 👉 @Cpportal

Редкое видео, на котором Линус Торвальдс представляет ядро Linux 1.0 в 1994 году. 👉 @Cpportal

👩‍💻 В сеть вывалилась гигантская куча курсов и книг Держи сотни гигабайт свежих уроков, и каждую неделю мы подкидываем ещё! • 1612 ГБ — DevOps • 1402 ГБ — Python • 1300 ГБ — C, C++ • 1815 ГБ — Frontend • 1515 ГБ — Backend • 898 ГБ — ИБ, Хакинг • 996 ГБ — Kotlin, Swift • 212 ГБ — JavaScript • 315 ГБ — Flutter • 820 ГБ — Go, PHP • 419 ГБ — Java, Rust • 648 ГБ — GameDev • 517 ГБ — Windows, Linux • 998 ГБ — Дизайн (UX/UI) • 617 ГБ — Нейросети (ML/RL) • 546 ГБ — БД (SQL & NoSQL) • 687 ГБ — Аналитика данных • 115 ГБ — QA-тестирование Подписывайся и не плати за то, что можно получить бесплатно

Классический BST на C, аккуратно, вставка без рекурсии.

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

/* структура узла дерева */
struct tree_node {
    int value;
    struct tree_node *left_child;
    struct tree_node *right_child;
};

/* создать новый узел дерева */
struct tree_node* create_node(int value) {
    struct tree_node* new_node = malloc(sizeof(struct tree_node));
    new_node->value = value;
    new_node->left_child = NULL;
    new_node->right_child = NULL;
    return new_node;
}

/* вставить значение в бинарное дерево поиска */
struct tree_node* insert_into_tree(struct tree_node* root, int value) {
    struct tree_node** current = &root;
    while (*current) {
        /* если меньше - идем влево, если больше - вправо */
        current = (value < (*current)->value)
            ? &(*current)->left_child
            : &(*current)->right_child;
    }
    *current = create_node(value);
    return root;
}

/* вывести значения дерева в отсортированном порядке */
void print_sorted(struct tree_node* node) {
    if (!node) return;
    print_sorted(node->left_child);
    printf("%d ", node->value);
    print_sorted(node->right_child);
}

int main() {
    struct tree_node* root = NULL;
    int numbers[] = {50, 30, 70, 20, 40, 60, 80};

    for (int i = 0; i < 7; i++) {
        root = insert_into_tree(root, numbers[i]);
    }

    printf("дерево в отсортированном порядке: ");
    print_sorted(root);
    printf("\n");

    return 0;
}{}
    

👉 @Cpportal

Если нужно отправлять или принимать данные по сети? Всегда приводите к сетевому порядку байт (big-endian):

    
        #include <stdio.h>
#include <stdint.h>

/* преобразовать порядок байт хоста в сетевой порядок (network byte order) */
uint32_t host_to_network_32(uint32_t host_value) {
    return ((host_value >> 24) & 0xff) |
           ((host_value >>  8) & 0xff00) |
           ((host_value <<  8) & 0xff0000) |
           ((host_value << 24) & 0xff000000);
}

/* преобразовать сетевой порядок байт обратно в порядок хоста */
uint32_t network_to_host_32(uint32_t network_value) {
    return host_to_network_32(network_value); /* то же преобразование */
}

int main() {
    uint32_t original_value = 0x12345678;

    printf("исходное значение: 0x%08x\n", original_value);

    uint32_t network_version = host_to_network_32(original_value);
    printf("сетевой формат: 0x%08x\n", network_version);

    uint32_t back_again = network_to_host_32(network_version);
    printf("обратно как было: 0x%08x\n", back_again);

    return 0;
}
{}
    

👉 @Cpportal

Курс по алгоритмам, к которому стоит периодически возвращаться: https://courses.csail.mit.edu/6.851/spring21/ 👉 @Cpportal

Самый быстрый способ сравнить до 3 байт памяти без memcmp вообще и без циклов.

    
        @branchHint(.likely);
if (actualSuffix.len < 4) {
    const xor =
        (actualSuffix[0] ^ patternSuffix[0])
        | (actualSuffix[actualSuffix.len - 1] ^ patternSuffix[actualSuffix.len - 1])
        | (actualSuffix[actualSuffix.len / 2] ^ patternSuffix[actualSuffix.len / 2]);

    return xor == 0;
}{}
    

Это разворачивается в красивый ассемблер: без стека, без переходов нулевое давление на регистры микро-опы легко раскидывают эти qword'ы в параллель 👉 @Cpportal

Если хочется реально понять, как комп стартует с нуля и во что превращается “операционка”, вот плейлист, который прям затягивает. How to build an Operating System (YouTube серия): * CPU, ассемблер, загрузка * BIOS и ввод с клавиатуры * стек, функции, сегментация * disk I/O * protected mode * написание ядра Это тот случай, когда после пары видео начинаешь иначе смотреть на “просто запусти программу”. Смотреть: тут 👉 @Cpportal

Большинство локов работают по одному: взял Lock A, потом Lock B, потом Lock C. А что если тебе нужно взять все три одновременно, или не брать ни одного? В Linux есть системный вызов ровно под это: semop (syscall #65 на x86_64). Он выполняет несколько операций над семафорами как одну атомарную транзакцию. semop принимает массив операций для набора семафоров. Можно сказать ядру: уменьши семафор 0, уменьши семафор 1 и подожди, пока семафор 2 станет равен нулю. Ядро гарантирует all-or-nothing. Либо все операции проходят вместе, либо вызов блокируется, пока они не станут возможны. Это убирает целый класс дедлоков. С обычными локами ты можешь взять Lock A, потом встать в ожидание Lock B, пока другой процесс держит B и ждет A. С semop ты не держишь “частичное состояние”. Ты либо полностью внутри, либо полностью снаружи. Вот полный демо-пример: два семафора захватываются атомарно.

    
        #include <stdio.h>
#include <sys/sem.h>

int main() {
    // Create semaphore set with 2 sems
    int id = semget(IPC_PRIVATE, 2, 0600);

    // Initialize both to 1 (unlocked)
    semctl(id, 0, SETVAL, 1);
    semctl(id, 1, SETVAL, 1);

    struct sembuf ops[2] = {
        {0, -1, SEM_UNDO},   // Acquire sem 0
        {1, -1, SEM_UNDO}    // Acquire sem 1
    };

    printf("Acquiring both semaphores...\n");
    semop(id, ops, 2); // Atomic!
    printf("Got both. Doing critical work...\n");

    // Release
    ops[0].sem_op = 1;
    ops[1].sem_op = 1;
    semop(id, ops, 2);
    printf("Released.\n");

    semctl(id, 0, IPC_RMID);  // Cleanup
    return 0;
}{}
    

Видишь флаг SEM_UNDO? Это твоя страховка. Если процесс упадет или его убьют, пока он держит эти семафоры, ядро автоматически откатит операции. Больше никаких “зомби-локов”, которые морозят всю систему из-за одного segfault. Тут же есть режим wait-for-zero. Поставь sem_op в 0, и процесс будет блокироваться, пока значение семафора не станет ровно нулем. Это удобно для барьеров: например, подождать, пока все воркеры отпустят ресурсы, прежде чем координатор пойдет дальше. 👉 @Cpportal