// Plugin.cpp
#include "IPlugin.h"

class MyPlugin : public IPlugin {
public:
  void Initialize() override {
    std::cout << "MyPlugin initialized" << std::endl;
  }

  void DoSomething() override {
    std::cout << "Doing something in MyPlugin" << std::endl;
  }
};

extern "C" __declspec(dllexport) IPlugin* CreatePlugin() {
  return new MyPlugin();
}

int main() {
  std::vector<IPlugin*> plugins = LoadPlugins("plugins");

  for (auto plugin : plugins) {
    plugin->DoSomething();
  }

  for (auto plugin : plugins) {
    delete plugin;
  }

  return 0;
}

ip addr show

inet 192.168.1.100/24 brd 192.168.1.255 scope global dynamic wlan0

sudo vim /etc/netplan/*.yaml

network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3: # Замените на имя вашего интерфейса
      dhcp4: no
      addresses: [192.168.1.101/24]
      gateway4: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]

sudo netplan apply

ping <IP-адрес другого компьютера>

sudo apt-get install samba

mkdir /home/<ваш_пользователь>/share
chmod 777 /home/<ваш_пользователь>/share

sudo vim /etc/samba/smb.conf

[share]
comment = Shared Folder
path = /home/<ваш_пользователь>/share
browsable = yes
writable = yes
guest ok = yes
read only = no
create mask = 0777
directory mask = 0777

sudo service smbd restart

smb://<IP-адрес первого компьютера>/share

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

// Определение структуры элемента списка
struct IntrusiveElement {
    int data;
    struct IntrusiveElement *next;
    struct IntrusiveElement *prev;
};

// Функция для создания нового элемента
struct IntrusiveElement* create_element(int value) {
    struct IntrusiveElement *new_element = (struct IntrusiveElement *)malloc(sizeof(struct IntrusiveElement));
    if (new_element == NULL) {
        printf("Ошибка выделения памяти\n");
        exit(1);
    }
    new_element->data = value;
    new_element->next = NULL;
    new_element->prev = NULL;
    return new_element;
}

// Функция для вставки элемента после заданного элемента
void insert_after(struct IntrusiveElement *element, int value) {
    struct IntrusiveElement *new_element = create_element(value);
    if (element->next != NULL) {
        element->next->prev = new_element;
    }
    new_element->next = element->next;
    new_element->prev = element;
    element->next = new_element;
}

// Функция для удаления элемента
void remove_element(struct IntrusiveElement *element) {
    if (element->prev != NULL) {
        element->prev->next = element->next;
    }
    if (element->next != NULL) {
        element->next->prev = element->prev;
    }
    free(element);
}

// Функция для печати содержимого списка
void print_list(struct IntrusiveElement *head) {
    struct IntrusiveElement *current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

int main() {
    struct IntrusiveElement *head = create_element(0); // Создание головы списка
    
    // Вставка элементов в список
    insert_after(head, 1);
    insert_after(head->next, 2);
    insert_after(head->next->next, 3);
    
    // Печать списка
    print_list(head);
    
    // Удаление второго элемента
    remove_element(head->next->next);
    
    // Печать обновленного списка
    print_list(head);
    
    return 0;
}

#include <iostream>
using namespace std;

// Определение класса элемента списка
class IntrusiveElement {
public:
    int data;
    IntrusiveElement *next;
    IntrusiveElement *prev;
};

// Класс для управления списком
class IntrusiveList {
private:
    IntrusiveElement *head;
public:
    IntrusiveList() { head = nullptr; } // Конструктор инициализирует пустой список

    // Метод для вставки элемента после заданного элемента
    void insertAfter(IntrusiveElement *element, int value) {
        IntrusiveElement *new_element = new IntrusiveElement();
        new_element->data = value;
        if (element->next != nullptr) {
            element->next->prev = new_element;
        }
        new_element->next = element->next;
        new_element->prev = element;
        element->next = new_element;
    }

    // Метод для удаления элемента
    void removeElement(IntrusiveElement *element) {
        if (element->prev != nullptr) {
            element->prev->next = element->next;
        }
        if (element->next != nullptr) {
            element->next->prev = element->prev;
        }
        delete element;
    }

    // Метод для печати содержимого списка
    void printList() {
        IntrusiveElement *current = head;
        while (current != nullptr) {
            cout << current->data << " -> ";
            current = current->next;
        }
        cout << "NULL" << endl;
    }
};

int main() {
    IntrusiveList list;
    IntrusiveElement *head = new IntrusiveElement(); // Создание головы списка
    head->data = 0;
    list.head = head;
// Вставка элементов в список
    list.insertAfter(list.head, 1);
    list.insertAfter(list.head->next, 2);
    list.insertAfter(list.head->next->next, 3);

    // Печать списка
    list.printList();

    // Удаление второго элемента
    list.removeElement(list.head->next->next);

    // Печать обновленного списка
    list.printList();

    return 0;
}

sudo apt-get install exuberant-ctags  # Для Ubuntu/Debian

ctags -R .

YouCompleteMe — плагин для автодополнения и навигации по коду.
Coc.nvim — аналогичен YouCompleteMe, но использует LSP (Language Server Protocol).
Tagbar — отображение структуры файла в виде боковой панели.

     A       B
   / | \      \
  C  D  E      F

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

// Структура узла дерева
typedef struct Node {
  int data;
  struct Node *parent; // Указатель на родителя
  struct Node *leftChild; // Левый ребенок
  struct Node *rightSibling; // Правый брат/сестра
} Node;

// Функция для создания нового узла
Node* createNode(int value) {
  Node* newNode = (Node*)malloc(sizeof(Node));
  if (newNode == NULL) {
    printf("Ошибка выделения памяти\n");
    exit(1);
  }
  newNode->data = value;
  newNode->parent = NULL;
  newNode->leftChild = NULL;
  newNode->rightSibling = NULL;
  return newNode;
}

// Функция для добавления ребенка к узлу
void addChild(Node* parent, Node* child) {
  if (parent->leftChild == NULL) {
    parent->leftChild = child;
  } else {
    Node* sibling = parent->leftChild;
    while (sibling->rightSibling != NULL) {
      sibling = sibling->rightSibling;
    }
    sibling->rightSibling = child;
  }
  child->parent = parent;
}

// Функция для печати леса
void printForest(Node* root) {
  if (root == NULL) return;
   
  Node* current = root;
  while (current != NULL) {
    printf("%d ", current->data);
    if (current->leftChild != NULL) {
      printForest(current->leftChild);
    }
    current = current->rightSibling;
  }
}

int main() {
  // Создание леса
  Node* forestRootA = createNode(10); // Первое дерево
  Node* forestRootB = createNode(20); // Второе дерево
    
  Node* child1 = createNode(11);
  Node* child2 = createNode(12);
  Node* child3 = createNode(13);
    
  addChild(forestRootA, child1);
  addChild(forestRootA, child2);
  addChild(forestRootA, child3);
    
  Node* child21 = createNode(21);
  Node* child22 = createNode(22);
    
  addChild(forestRootB, child21);
  addChild(forestRootB, child22);
    
  // Печать леса
  printForest(forestRootA);
  printForest(forestRootB);
    
  return 0;
}

#include <iostream>
using namespace std;

// Класс узла дерева
class Node {
public:
  int data;
  Node* parent; // Указатель на родителя
  Node* leftChild; // Левый ребенок
  Node* rightSibling; // Правый брат/сестра

  // Конструктор класса
  Node(int value) : data(value), parent(nullptr), leftChild(nullptr), rightSibling(nullptr) {}
};

// Функция для добавления ребенка к узлу
void addChild(Node* parent, Node* child) {
  if (parent->leftChild == nullptr) {
    parent->leftChild = child;
  } else {
    Node* sibling = parent->leftChild;
    while (sibling->rightSibling != nullptr) {
      sibling = sibling->rightSibling;
    }
    sibling->rightSibling = child;
  }
  child->parent = parent;
}

// Функция для печати леса
void printForest(Node* root) {
  if (root == nullptr) return;
  
  Node* current = root;
  while (current != nullptr) {
    cout << current->data << " ";
    if (current->leftChild != nullptr) {
      printForest(current->leftChild);
    }
    current = current->rightSibling;
  }
}

int main() {
  // Создание леса
  Node* forestRootA = new Node(10); // Первое дерево
  Node* forestRootB = new Node(20); // Второе дерево
   
  Node* child1 = new Node(11);
  Node* child2 = new Node(12);
  Node* child3 = new Node(13);
    
  addChild(forestRootA, child1);
  addChild(forestRootA, child2);
  addChild(forestRootA, child3);
    
  Node* child21 = new Node(21);
  Node* child22 = new Node(22);
    
  addChild(forestRootB, child21);
  addChild(forestRootB, child22);
   
  // Печать леса
  printForest(forestRootA);
  printForest(forestRootB);
    
  return 0;
}

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

#define SIZE 1024

typedef struct Node {
  char *word;
  size_t wcount;
  struct Node *left;
  struct Node *right;
} TNode;

typedef TNode *Tree;

void out_error_message(const char* msg);
Tree add_tnode(Tree root, const char* word);
char* scan_word(char* eof);
void tree_destroy(Tree root);
char* str_realloc(char* src, size_t* size);
void get_array_pnodes(const Tree root, Tree array_pnodes[SIZE], size_t* index);
size_t get_tsize(const Tree root);
void insert_sort(Tree array[SIZE], const size_t tsize,
                 int (*cmp)(const Tree node1, const Tree node2));
int compare_wcount(const Tree node1, const Tree node2);

int main(void) {
  Tree root = NULL;
  char *word = NULL;
  char eof = '\0';

  do {
    word = scan_word(&eof);
    if (strlen(word)) {
      root = add_tnode(root, word);
    }
    free(word);
    word = NULL;
  } while (eof != EOF);

  size_t tsize = get_tsize(root);
  Tree array_pnodes[SIZE] = {NULL};
  size_t index = 0;

  get_array_pnodes(root, array_pnodes, &index);
  insert_sort(array_pnodes, tsize, compare_wcount);

  for (size_t i = 0; i != tsize; ++i) {
    printf("%s %d\n", array_pnodes[i]->word, array_pnodes[i]->wcount);
  }

  tree_destroy(root);
  return 0;
}

char* str_realloc(char* src, size_t* size) {
  *size *= 2;
  char* newstr = (char*)realloc(src, *size * sizeof(char));
  if (newstr) {
    src = newstr;
  }
  return src;
}

char* scan_word(char* eof) {
  char ch;
  size_t size = 16;
  int idx = 0;
  char* word = (char*)calloc(size, sizeof(char));
  if (word == NULL) {
    out_error_message("Memory allocation error");
  }
  while (isspace(ch = getchar()));
  do {
    if (isalpha(ch)) {
      if (idx == size) {
        word = str_realloc(word, &size);
      }
      word[idx++] = tolower(ch);
    }
  } while (EOF != (ch = getchar()) && !isspace(ch));
  if (ch == EOF) {
    *eof = ch;
  }
  return word;
}

Tree add_tnode(Tree root, const char* word) {
  if (!root) {
    root = (Tree)malloc(sizeof(TNode));
    if (root) {
      size_t wlen = strlen(word);
      root->left = root->right = NULL;
      root->word = (char*)calloc(wlen + 1, sizeof(char));
      if (root->word) {
        strncpy(root->word, word, wlen);
        root->wcount = 1;
      }
    } else if (!root->word) {
      out_error_message("Memory allocation error");
    }
    return root;
  }

  int cmp = strcmp(word, root->word);
  if (!cmp) {
    ++(root->wcount);
  } else if (0 < cmp) {
    root->right = add_tnode(root->right, word);
  } else {
    root->left = add_tnode(root->left, word);
  }
  return root;
}

size_t get_tsize(const Tree root) {
  if (!root) {
    return 0;
  }
  return 1 + get_tsize(root->left) + get_tsize(root->right);
}

void get_array_pnodes(const Tree root, Tree array_pnodes[SIZE], size_t *index) {
  if (!root) {
    return;
  }
  get_array_pnodes(root->left, array_pnodes, index);
  array_pnodes[(*index)++] = root;
  get_array_pnodes(root->right, array_pnodes, index);
}

int compare_wcount(const Tree node1, const Tree node2) {
  return node1->wcount > node2->wcount;
}

void insert_sort(Tree array[SIZE], const size_t tsize,
                 int (*cmp)(const Tree node1, const Tree node2)) {
  for (size_t i = 0, j = 1; j != tsize; ++i, j = i + 1) {
    while (j >= 1 && cmp(array[j], array[j - 1])) {
      Tree tmp = array[j - 1];
      array[j - 1] = array[j];
      array[j--] = tmp;
    }
  }
}

void tree_destroy(Tree root) {
  if (!root) {
    return;
  }
  free(root->word);
  tree_destroy(root->left);
  tree_destroy(root->right);
  free(root);
}

void out_error_message(const char *msg) {
  perror(msg);
  abort();
}

// заголовочный файл для bzero
#include <strings.h>

char buffer[100];
// Заполняем массив buffer нулями
bzero(buffer, sizeof(buffer));

// Заголовочный файл для memset
#include <string.h>

char buffer[100];
// Устанавливаем весь буфер в нули
memset(buffer, 0, sizeof(buffer));