# УДАЧИ НАМ

## Statement

> Наименьшая независимая еденица в языке C++

### Основные

* declaration:

    ```C++
    int i;
    ```

* assigment :

    ```C++
    i = 5;
    ```

* Output (хоть Коля и не согласен, что это основной)

    ```C++
    std::cout << i;
    ```

declaration и assigment можно вместе

```C++
int i = 5;
```

## Expression

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

## Функции

> Последовательность statement'ов. Исполнение начинается с функции main()

## Библиотеки

> Набор скомпилированного кода, для использования в других программах

### Примеры библиотек

* iostream - для ввода / вывода

## Коментарии

* Однострочные

    ```C++
    // Коментарий
    ```

* Многострочные

    ```C++
    /* Длинный
    Коментарий */
    ```

## Пример простой программы

```C++
#include <iostream>

int main() {
    std::cout << "Hello, world!\n";
}
```

## Переменные

> В C++ есть переменные, они жрут оперативку

* Копирующая инициализация

```C++
int val = 5;
```

* Прямая инициализация

```C++
int val(5);
```

### Неинициализированные переменные

> Неинициализированные переменные могут иметь в себе мусор, что может привести к ошибкам

### Инициализация и объявление нескольких переменных

```C++
int a, b;
```

```C++
int a = 5, b = 6;
```

## Типы данных

* void - ничего

### Числа

* short - число 16 бит
* int - число 16 или 32 бита
* long - число 32 бита
* long long - число 64 бита
* char - число или символ. 8 бит

#### Отрицательные числа

* signed - может быть отрицательным (по умолчанию, кроме char)
* unsigned - число не отрицательно

#### Переполнение

* Переполнение случается при потере бит из-за того, что значение после операции выходит за границу их значений

65635 как unsigned int + 1 выдаст 0

#### Целочисленное деление

Деление двух цилочисленных значений всегда выдаёт целое число (округление вниз)

### Символьные тип char

char представляет собой 1 символ (не всегда) и всегда весит 1 байт.

Для инициализации char символом используется *одинарные* ковычки

### Строки

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

### Типы данных с плавающией точкой

Типы с плавающей могут показывать дробные числа

* float - 32 бита
* double - 64 бита (двойная точность по сравнению с float)
* long double - от 8 до 16 байт (зависит от компилятора)

### Логические значения

* true
* false

## Константы

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

## IOSTREAM

### Подключение IOSTREAM

```C++
#include <iostream>;
```

### *cout*

> *cout* - объект для вывода в терминал

```C++
#include <iostream>;

std::cout << 5 << '\n';
```

### *endl*

> endl можно использовать как '\n'

```C++
#include <iostream>;

std::cout << 5 << std::endl;
```

### *cin*

> cin используется для ввода значений из терминала

```C++
#include <iostream>;

int a = 0;
std::cin >> a;
```

## Ветвление

```C++
#include <iostream>;

int a = 5;
if (a == 5) {
    std::cout << 5 << '\n';
} else if (a == 6) {
    std::cout << 6 << '\n';
} else {
    std::cout << "Neither\n";
}
```

### Логические операторы

* && - и
* || - или
* ! - не

## Циклы

### Цикл for

> for (инициализация; условие; изменение)

```C++
#include <iostream>;

// Выводит числа от 0 до 5 включительно
for (int i = 0; i <= 5; i++) {
    std::cout << i << '\n';
}
```

### Цикл while (с пред условием)

```C++
#include <iostream>;

// Аналогичен коду сверху
int i = 0;
while (i <= 5) {
    std::cout << i << '\n';
    i++;
}
```

### Цикл do while

> Цикл do while выполнит тело хотя бы один раз, даже если условие изначально false

```C++
#include <iostream>;


// Выведет 0 (не смотря на то, что 0 чётное) и 1
int i = 0
do {
    std::cout << i << '\n';
    i++;
} while (i % 2 != 0)
```

### Операторы прерывания

* *break*
* *continue*

Они аналогичны оным из Python

## switch

```C++
int a = 5;
switch(a){
    case 1:
        std::cout << "1" << '\n';
        break;
    case 2:
        std::cout << "2" << '\n';
        break;
    default:
        std::cout << "Other" << '\n';
        break;
}
```

## Goto

> Goto позволяет перейти к исполнению другого блока кода. Если будете его использовать, то придёт страшный Николай и даст по рукам книжкой о правильном написании кода

```C++
mark:
    // do-something

// 1 eternity later (возможно даже в другой функции)

goto mark;
```

## Массивы

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

### Объявление массива

```C++
int number[5]; // пять интов. Массив называется numbers
char chars[20];
bool flags[3];
```

### Инициализация массива

```C++
int numbers[3] = {10, 20, 30};
int foo[] = {10, 20, 30}; // Тоже будет на 3 элемента
int bar[10] = {10, 20, 30} // Оставшиеся 8 не инициализированны
```

### Обход массива

```C++
#include <iostream>

int numbers[] = {10, 20, 30}

for (int i = 0; i < 3; i++) {
    std::cout << i << '\n';
}
```

### Размер массива

```C++
int arr[5];

int n = sizeof(arr) / sizeof(int); // n - длинна массива
```

### Многомерные массивы

```C++
#include <iostream>

int arr[2][2] = {{10, 20}, {30, 40}};
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 2; j++) {
        std::cout << arr[i][j] << '\n';
    }
}
```

### Динамический массив

> Массив, размер которого может быть указан в runtime. Ключевое слово *new* используется для создания, a *delete* для освобождения памяти.

```C++
int* dynamic_array = new int[5]; // dynamic_array - список из 5 чисел
delete[] dynamic_array;
```

```C++
#include <iostream>

int n;
std::cin >> n;
int* nums = new int[n];

for (int i = 0; i < n; i++) {
    std::cin >> nums[i];
}

for (int i = 0; i < n; i ++) {
    std::cout << nums[i] << ' ';
}
std::cout << std::endl;

delete[] nums;
```

## Процедуры и функции

> Процедуры - функции, которые возвращают void

```C++
#include <iostream>

// Функция, возвращает int который получила
int foo(int n) {
    return n;
}

// Процедура
void bar(int n) {
    std::cout << n << '\n';
}
```

### Передача значений в функцию

> При передаче аргумента, как значения, создаётся его копия, а при передаче по ссылки, копия не создаётся и может менять его

```C++
#include <iostream>

void increment1(int i) {
    i++;
    std::cout << i << '\n';
}

void increment2(int& i) {
    i++;
    std::cout << i << '\n';
}

int main() {
    int i = 5;
    increment1(i) // Выведет 6, но i останется 5
    increment2(i) // Выведет 6, и i станет 6
}
```

### Передача массивов в функцию

> При передаче массивов в функцию, нужно кинуть туда ещё и длину. Функция может менять оригинальный массив. Копия не создаётся

```C++
#include <iostream>

void foo(int bar[], int size) {
    if (size >= 1) {
        std::cout << bar[1] << '\n';
    } else {
        std::cout << "Not enough elements\n";
    }
}
```

## Ссылки и указатели

> *Ссылка* (*reference*) - псевдоним джя существующей переменной. Может иметь не валидный адрес или быть не инициализированной

```C++
int a = 5;
int& b = a; // При изменении b, будет меняться a
b++; // a и b станут 6
```

> Указатель (*pointer*) содержит адрес существующей переменной

```C++
int a = 5;
int* b = &a; // При изменении b, будет меняться a
(*b)++ // a станет равна 6
```

## Строки (углубление)

```C++
#include <iostream>
#include <string>

int main() {
    std::string a = "abc";

    // b - копия a
    std::string b = a;

    // c содержит 'c'
    сhar c = a[2];

    // последний символ a стал z
    a[2] = 'z'
}
```

### Перебор символов

```C++
#include <string>

std::string a = "abc"
for (char c: a) {
    std::cout << c << '\n';
}

for (int i = 0; i < a.length(); i++) {
    std::cout << a[i] << '\n';
}
```

### Ввод строки с клавиатуры

```C++
#include <iostream>
#include <string>

std::string str;
// Ввести 1 слово
std::cin >> str;

// Ввести строку
std::getLine(std::cin, str);
```

### Полезные методы строк

* length(), size() - длина строки
* substr(start,length) - извлекает часть строки
* find(substring) - первое вхождение
* replace(oldString, NewString) - заменяет все вхождения из старой в новую строку (ничего не возвращает, изменения на месте)
* toupper(), tolower() - меняет регистр соответсвенно названию
* empty() - проверяет пустая ли строка
* compare() -сравнивает две строки. Возвращает 0, если строкми одинаковые.
* insert(index,string) - вставляет строку в указанную позицию.
* erase(start,length) - удалает часть строки

### Полезные функции для строк

* getLine(inputStream, string) - считывает строку из потока и тсохраняет в переменную str

## Способы передачи аргументов в функию

* по значению (pass by value) - создание копии
  * Изначальное не меняется
  * Создание копии может занимать много времени
  * Используется для передачи примитивов
* по сслылке (pass by reference) - передача в функцию указатель на объект
  * Изначальное значение может меняться
  * Копия не создаётся
  * Используется для составных типов и больших объектов
* Передача по указателю (pass by pointer) - pass by reference без кучки синтактического сахара
    Разименование - операция, которая позволяет получить доступ к значению, на которое указывает pointer.(*)

```C++
void boo(int* ptr) {
    (*ptr)++;
}
```

## Возврат значений из функции

* Возврат по значению return
* Важно не вернуть ссылку или указатель на локальную переменную

## Структуры

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