C/C++ Ready | Программирование

std::map<std::string, int> ages;

ages["Alice"] = 25;  
ages["Bob"] = 30;

int aliceAge = ages["Alice"];  // 25

if (ages.find("Charlie") != ages.end()) {  
    std::cout << "Charlie найден!\n";  
} else {  
    std::cout << "Charlie отсутствует.\n";  
}  

ages.erase("Alice");  // Удаляет элемент с ключом "Alice"

for (const auto& [key, value] : ages) {  
    std::cout << key << ": " << value << '\n';  
}  

int factorial(int n) {  
    return (n == 0) ? 1 : n * factorial(n - 1);  
}  

void infiniteRecursion() {
    infiniteRecursion();  // рекурсия без выхода
}

int tailFactorial(int n, int result = 1) {  
    return (n == 0) ? result : tailFactorial(n - 1, result * n);  
}  

template <typename T>
T functionName(T parameter1, T parameter2) {
    // Тело функции
}

bool compare(int a, int b) {
    return a < b; // Возвращает true, если a меньше b
}

std::vector<int> vec = {5, 3, 8, 1, 2};  
std::sort(vec.begin(), vec.end(), compare);  
// Теперь vec содержит: 1, 2, 3, 5, 8  

std::sort(vec.begin(), vec.end(), [](int a, int b) {  
    return a > b;  // Сортировка по убыванию  
});  
// Теперь vec содержит: 8, 5, 3, 2, 1  

int x = 5;
int y = x++;  // y = 5, x = 6
std::cout << y;  // Выведет 5, а не 6

int x = 5;
int y = ++x;  // y = 6, x = 6
std::cout << y;  // Выведет 6

int x = 5;
x++;  // Просто увеличим x на 1
std::cout << x;  // Выведет 6

int x = 10;    // Обычная переменная
int* ptr = &x; // Указатель, хранящий адрес переменной x

std::cout << *ptr;  // Выведет 10

// Выделили память для одного целого числа
int* p = new int;  

// Присваиваем значение 20 переменной, на которую указывает p
*p = 20;

delete p;  // Освобождаем память

int* arr = new int[5];  // Массив из 5 элементов
arr[0] = 10;     // Присваиваем значение первому элементу

delete[] arr;  // Освобождаем память массива

#include <cstdlib>
#include <ctime>

srand(time(0));
int random_number = rand() % 100;  // Число от 0 до 99
// Простое решение, но с низкой статистической случайностью

#include <random>

std::random_device rd;
// Генерирует 32-битное случайное число
int random_number = rd(); 
// Подходит для криптографии, но может быть медленным

#include <random>

std::mt19937 gen(std::random_device{}());
std::uniform_int_distribution<> dist(1, 10);
int random_number = dist(gen); // Число от 1 до 10
// Гибкий и современный способ генерации чисел

std::vector<int> numbers;  

numbers.push_back(10);  
numbers.push_back(20);  

int first = numbers[0];  // Доступ к первому элементу  

numbers.resize(5);

numbers.pop_back();  

#include <variant>
#include <iostream>

std::variant<int, double, std::string> data = 42;
data = 3.14;
data = "Hello, C++";

std::visit([](auto&& arg) { std::cout << arg << '\n'; }, data);

constexpr int square(int x) {
    return x * x; 
// Функция вычисляет квадрат числа
}

constexpr int result = square(5);  
// Значение вычисляется на этапе компиляции

std::tuple<int, double, char> getValues() {
    return {42, 3.14, 'A'}
}

auto [intValue, doubleValue, charValue] = getValues();
std::cout << intValue << ", " << doubleValue << ", " << charValue << '\n';

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = std::move(v1); // перемещение, а не копирование

auto square = [](int x) { return x * x; };
std::cout << square(5); // вывод: 25

auto num = 42; // num автоматически становится int

#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);
std::cout << *ptr; // вывод: 10

int* arr = new int[10];
delete[] arr; // правильное удаление массива

int* ptr = new int(5);
delete ptr;
ptr = nullptr; // обнуление   

void printStatus(bool status) {
    if (status) {
        std::cout << "Success\n";
    } else {
        std::cout << "Failure\n";
    }
}
printStatus(5); // компилируется, но ожидаем ли мы это?

void func(int x);
void func(double x);
func(2.5f); // Какую функцию вызвать?

class Product {
public:
    Product(int price) { }
};
void buy(const Product& p);
buy(99); // автоматически создается объект Product(99)

explicit Product(int price) { }

int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
int result = factorial(5); // вычисляется на этапе выполнения

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
constexpr int result = factorial(5); // вычисляется на этапе компиляции

int factorial(int n) {
    return (n == 0) ? 1 : n * factorial(n - 1);
}

void infiniteRecursion() {
    infiniteRecursion();  // рекурсия без выхода
}

int tailFactorial(int n, int result = 1) {
    return (n == 0) ? result : tailFactorial(n - 1, result * n);
}

int x = 10;
int* ptr = &a; // ptr хранит адрес переменной a

int& ref = x; // ref — это просто другое имя для переменной x

int* ptr2 = nullptr; // указатель может быть пустым
// int& ref2; // ошибка, ссылку нельзя оставить неинициализированной

void increment(int* ptr) {
    (*ptr)++; // изменение значения по указателю
}
increment(&a); // передаём адрес переменной a