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

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

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

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

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

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

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

— Открытое наследование означает «является». Все, что применимо к базовому классу, должно быть применимо также и к производным от него классам, потому что каждый объект производного класса является также объектом базового класса.

— Имена в производных классах скрывают имена из базовых классов.
При открытом наследовании это всегда нежелательно.

— Чтобы сделать скрытые имена видимыми, используйте using-объявления либо перенаправляющие функции.

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

— Чисто виртуальные функции означают, что наследуется только интерфейс.

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

— Невиртуальные функции означают, что наследуются интерфейс и обязательная реализация.

— К числу альтернатив виртуальным функциям относятся идиома NVI и различные формы паттерна проектирования "Стратегия".
Идиома NVI сама по себе - это пример реализации паттерна "Шаблонный Метод".

— Недостаток переноса функциональности из функций-членов вовне класса заключается в том, что функциям-нечленам недостает прав доступа к закрытым членам класса.

— Объекты tr1::function работают как обобщенные указатели на функции.
Такие объекты поддерживают все вызываемые сущности, совместимые с сигнатурой целевой функции.

— Никогда не переопределяйте наследуемые невиртуальные функции.

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

— Семантика композиции кардинально отличается от семантики открытого наследования.

— В предметной области композиция означает "содержит".
В области реализации она означает "реализовано посредством".

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

— В отличие от композиции, закрытое наследование позволяет проводить оптимизацию пустого базового класса.
Это может оказаться важным для разработчиков библиотек, которые стремятся минимизировать размеры объектов.

— Множественное наследование сложнее одиночного.
Оно может привести к неоднозначности и необходимости применять виртуальное наследование.

— Цена виртуального наследования - дополнительные затраты памяти, снижение быстродействия и усложнение операций инициализации и присваивания.
На практике его разумно применять, когда виртуальные базовые классы не содержат данных.

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

— И классы, и шаблоны поддерживают интерфейсы и полиморфизм.

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

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

— В объявлениях параметров шаблона ключевые слова class и typename взаимозаменяемы.

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

— В шаблонах производных классов ссылки на имена из шаблонов базовых классов осуществляются с помощью префикса "this->". using-объявления либо посредством явного указания базового класса.

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

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

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

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

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

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

— Классы-характеристики делают доступной информацию о типах во время компиляции.
Они реализованы с применением шаблонов и их специализаций.

— В сочетании с перегрузкой классы-характеристики позволяют проверять типы во время компиляции.

— Метапрограммирование шаблонов позволяет перенести часть работы со стадии исполнения на стадию компиляции. 
За счет этого можно раньше обнаружить ошибки и повысить производительность программ.

— Технология ТМР может быть использована для генерации кода на основе комбинации политик, а также чтобы предотвратить генерацию кода, некорректного для определенных типов данных.

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

— Полезность nothrow new ограничена, поскольку эта форма применима только для выделения памяти;
последующие вызовы конструктора могут по-прежнему возбуждать исключения.

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

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

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

— Когда пишете размещающую версию оператора new, убедитесь, что не забыли о соответственном размещающем операторе delete.
Если его не будет, то в программе могут возникать тонкие, трудноуловимые утечки памяти.

— Объявляя размещающие версии new и delete, позаботьтесь о том, чтобы нечаянно не скрыть нормальных версий этих функций.

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

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

—  Основная функциональность стандартной библиотеки С++ состоит из STL, потоков iostream и локалей. Также включена стандартная библиотека С99.

— TR1 добавляет поддержку "интеллектуальных" указателей (например, tr1::shared_ptr), обобщенных указателей на функции (tr1::function), кэшированных контейнеров, регулярных выражений и еще 10 компонентов.

— Отчет TR1 сам по себе - всеrо лишь спецификация.
Чтобы воспользоваться преимуществами TR1, понадобится реализация. Одним из источников реализаций компонентов TR1 является проект Boost.

— Boost - сообщество и WеЬ-сайт для разработки бесплатных библиотек на С++ с открытыми исходными текстами, подверrающихся публичному обсуждению.
Boost оказывает немалое влияние на процедуру стандартизации С++.

— Boost предоставляет реализацию многих компонентов TR1, но - кроме того - и множество друrих библиотек.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080

void handle_client(int client_socket) {
  char buffer[1024];
  ssize_t bytes_read = recv(client_socket, buffer, sizeof(buffer)-1, 0);
  if(bytes_read > 0) {
    buffer[bytes_read] = '\0';
    printf("Received request:\n%s\n", buffer);
        
    // Send a simple response back to the client
    const char* response =
      "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
      "<html><body><h1>Hello from C Web Server!</h1></body></html>";
    send(client_socket, response, strlen(response), 0);
  }
    
  close(client_socket); // Close connection after sending response
}

int main() {
  int server_fd, new_socket;
  struct sockaddr_in address;
  int opt = 1;
  int addrlen = sizeof(address);
    
  // Create socket file descriptor
  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
    perror("socket failed");
    exit(EXIT_FAILURE);
  }
    
  // Forcefully attaching socket to port 8080
  if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
    perror("setsockopt");
    exit(EXIT_FAILURE);
  }
    
  address.sin_family = AF_INET;
  address.sin_addr.s_addr = INADDR_ANY;
  address.sin_port = htons(PORT);
    
  // Bind the socket to the specified IP and port
  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0 ) {
    perror("bind failed");
    exit(EXIT_FAILURE);
  }
    
  // Listen for incoming connections
  if (listen(server_fd, 3) < 0) {
    perror("listen");
    exit(EXIT_FAILURE);
  }
    
  while(1) { // Accept multiple clients
    if ((new_socket = accept(server_fd, (struct sockaddr *)NULL, NULL)) < 0) {
      perror("accept");
      continue;
    }
        
    handle_client(new_socket);
  }
    
  return 0;
}

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <string>
#include <arpa/inet.h>

using namespace std;

const string default_response =
"RFC 2616 compliant HTTP Response\r\n"
"HTTP/1.1 200 OK\r\n"
"Server: Simple C++ Web Server\r\n"
"Content-Length: 26\r\n"
"\r\n"
"<h1>Hello from C++!</h1>\r\n";

// Handle incoming requests
void handleRequest(int sockfd) {
  char buffer[1024];
  memset(buffer, 0, sizeof(buffer));
  ssize_t n = read(sockfd, buffer, sizeof(buffer)-1);
  cout << "Client Request:" << endl << buffer << endl;
    
  write(sockfd, default_response.c_str(), default_response.length());
  close(sockfd);
}

int main() {
  int listenfd, connfd;
  struct sockaddr_in servaddr;
    
  listenfd = socket(AF_INET, SOCK_STREAM, 0);
  bzero(&servaddr, sizeof(servaddr));
  servaddr.sin_family = AF_INET;
  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
  servaddr.sin_port = htons(8080);
    
  bind(listenfd, reinterpret_cast<const sockaddr*>(&servaddr), sizeof(servaddr));
  listen(listenfd, 10);
    
  while(true) {
    connfd = accept(listenfd, nullptr, nullptr);
    handleRequest(connfd);
  }
    
  return 0;
}

use actix_web::{web, App, HttpServer, Responder};

async fn index() -> impl Responder {
  "Hello from Rust!"
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
  println!("Starting web server on http://localhost:8080");
  HttpServer::new(|| {
    App::new().route("/", web::get().to(index))
  })
  .bind(("127.0.0.1", 8080))?
  .run()
  .await
}

package main
import (
  "fmt"
  "log"
  "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintf(w, "Hello from Go!")
}

func main() {
  http.HandleFunc("/", handler)
  log.Fatal(http.ListenAndServe(":8080", nil))
}

// hex_to_bin.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

void digit_to_bin(const char digit) {
  int cp_digit;
  if (digit > 47 && digit < 58) {
    cp_digit = digit - 48;
  } else if (digit > 96 && digit < 103) {
    cp_digit = digit - 87;
  } else {
    perror("Incorrect input");
    exit(0);
  } 

  for (int i = 3; i >= 0; --i) {
    printf("%d", (cp_digit >> i) & 1);
  }
}

void hex_to_bin(const char* hex_str_num) {
  for (int i = 0; i != strlen(hex_str_num); ++i) {
    digit_to_bin(tolower(hex_str_num[i]));
  }
  putchar('\n');
}

void read_line(char* buffer, size_t buffer_size) {
  const char* input = fgets(buffer, buffer_size, stdin);

  if (NULL != input) {
    char* end_ptr = strchr(buffer, '\n');
    if (NULL != end_ptr) {
      *end_ptr = '\0';
    }
  }
}

char* prefix_ignore(char* input) {
  char* result = NULL;
  if (input[0] == '0' && tolower(input[1]) == 'x') {
    result = &input[2];
  }
  return result;
}

int main(void) {
  enum {SIZE = 101};
  char input[SIZE] = {0};
  
  read_line(input, SIZE);
  //puts(input);

  if (strlen(input)) { 
    const char* hex_ptr = prefix_ignore(input);
    if (NULL != hex_ptr) {
      hex_to_bin(prefix_ignore(input));
    } else {
      hex_to_bin(input);
    }
  }

  return 0;
}

# Динамическое создание класса Person
Person = type('Person', (), {'name': 'John'})
john = Person()
print(john.name)

let obj = {};
obj.sayHello = function () {
    console.log("Привет!");
};
obj.sayHello();

class Animal
  def speak
    puts "Р-р!"
  end
end

Animal.class_eval do
  define_method(:roar) { |volume| puts "#{volume} Р-Р-Р!!!" }
end

lion = Animal.new
lion.roar("Громко")

template <typename T>
void process(T value) {
  std::cout << "Обработка типа: " << typeid(value).name() << "\n";
}

process<int>(42); // Обработаем целое число
process<double>(3.14); // Обработаем вещественное число

trait Shape {
  fn area(&self) -> f64;
}

struct Circle(f64);
impl Shape for Circle {
  fn area(&self) -> f64 {
    std::f64::consts::PI * self.0.powi(2)
  }
}

fn print_area(shape: &dyn Shape) {
  println!("Площадь фигуры: {}", shape.area());
}

// Используем circle
let c = Circle(3.0);
print_area(&c);

package main

import "fmt"

type Shaper interface {
  Area() float64
}

type Rectangle struct {
  width, height float64
}

func (r Rectangle) Area() float64 {
  return r.width * r.height
}

func main() {
  r := Rectangle{width: 10, height: 5}
  fmt.Println(r.Area()) // Площадь прямоугольника
}

package main

import (
  "fmt"
  "reflect"
)

type MyStruct struct{}

func (m MyStruct) SayHi() string {
  return "Привет!"
}

func main() {
  myInstance := MyStruct{}
  methodValue := reflect.ValueOf(myInstance).MethodByName("SayHi").Call(nil)[0]
  fmt.Println(methodValue.String())
}

ls -i

find /path/to/directory -inum <номер_inode> -print

stat file_name

kill -l | grep SIGKILL

man 7 signal

ps aux | grep systemd

root       1  0.0  0.0   7880  1804 ?        Ss   Aug11   0:01 /usr/lib/systemd/systemd --switch-root=/run/initramfs/initrd.img
...

pidof systemd

sudo systemctl start <служба>.service

sudo systemctl stop <служба>.service

sudo systemctl reboot

sudo systemctl status <служба>.service

sudo systemctl disable <служба>.service

$ uptime
17:30:01 up 8 days, 3 hours, 2 users, load average: 0.15, 0.21, 0.25

echo "-1000" > /proc/1234/oom_score_adj

echo "-17" > /proc/1234/oom_score_adj

# Создание группы control group
mkdir /sys/fs/cgroup/memory/myapp
# Установка лимита памяти для группы myapp (например, 1GB)
echo "1073741824" > /sys/fs/cgroup/memory/myapp/memory.limit_in_bytes
# Перемещение процесса в новую группу
echo "<PID>" > /sys/fs/cgroup/memory/myapp/tasks

[Service]
OOMScoreAdjust=-1000

<устройство> <точка_монтирования> <тип ФС> <опции> <dump> <pass>

/dev/sdb1
UUID=f8a7c2b9-b2d5-42cd-a4f7-e7227054a678
LABEL=data_disk
//server/share

/mnt/data
/home/user

ext4
xfs
btrfs
swap
cifs
nfs
tmpfs
proc
sysfs
devtmpfs

/dev/sda1     /               ext4      defaults       0          1

tmpfs           /run            tmpfs     mode=0755,nosuid,nodev,size=10% 0       0

/dev/sdc1       none            swap      sw                0       0

//nas.example.com/home /mnt/nas_home cifs credentials=/root/.smbcreds,_netdev,rw,user 0 0

Уровень  Описание
0        Выключение компьютера
1        Однопользовательский режим
2–5      Много-пользовательские режимы
6        Перезагрузка компьютера

sudo systemctl isolate multi-user.target # эквивалент старого уровня 3