548 lines
13 KiB
Markdown
548 lines
13 KiB
Markdown
# УДАЧИ НАМ
|
||
|
||
## 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
|
||
* Важно не вернуть ссылку или указатель на локальную переменную
|
||
|
||
## Структуры
|
||
|
||
> Структура - тип данных, позоляющий объединить несколько переменных в одной еденице.
|