Added missing files and removed unnessesary ones

2023-07-16 16:44:42 +03:00
parent c3fa5367c3
commit 199dd693e4
41 changed files with 1442 additions and 50 deletions
--- a/C++/C++.md
+++ b/C++/C++.md
@ -545,3 +545,243 @@ void boo(int* ptr) {
 ## Структуры

 > Структура - тип данных, позоляющий объединить несколько переменных в одной еденице.
+
+```C++
+#include <iostream>
+
+struct Employee {
+    short id;
+    int age;
+    double salary;
+};
+
+Employee john = {5, 20, 30.0}; 
+std::cout << john.id << ' ' << john.age << ' ' << john.salary << '\n';
+```
+
+## Перечисления
+
+> Перечисление - это пользовательский тип данных, который представляет собой набор именованных констант, которым присваиваются целочисленные значения. Весит как *int*
+
+```C++
+#include <iostream>
+
+enum Weekday {
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+    Sunday,
+};
+
+enum Weekday2 {
+    Monday = 1,
+    Tuesday = 2,
+    Wednesday = 3,
+    Thursday = 4,
+    Friday = 5,
+    Saturday = 6,
+    Sunday = 7,
+};
+
+Weekday today = Saturday;
+```
+
+Weekday полностью аналогичен Weekday2
+
+## Объединение
+
+> Объединение - это пользовательский тип данных, позволяющий хранить различные типы данных в одной области памяти. Объединение занимает память, достаточную для хранения переменной имеющий самый большой размер.
+
+```C++
+union MyUnion{
+    int intValue;
+    char charValue;
+};
+
+MyUnion val = 65;
+int a = val.intValue; // 65
+char b = val.charValue; // 'A'
+```
+
+## Передача значений в функцию (Подробнее)
+
+* Передача по значению (создаётся копия, может быть медленно, используется для примитивов)
+
+    ```C++
+    void increment(int a) {
+        a++;
+    }
+
+    int a = 5;
+    increment(&a); // a остаётся 5
+    ```
+
+* Передача по ссылке (копия не создаётся, используется для больших значений / структур, аналогична передаче по значению, но синтаксис проще)
+
+    ```C++
+    void increment(int& a) {
+        a++;
+    }
+
+    int a = 5;
+    increment(a); // a становится 6
+    ```
+
+* Передача по указателю (копия не создаётся, используется в основном для массивов)
+
+    ```C++
+    void increment(int* a) {
+        (*a)++;
+    }
+
+    int a = 5;
+    increment(&a); // a тоже становится 6
+    ```
+
+## Классы
+
+> Классы - шаблон или описание, определяющее структуру поведения объектов.
+> Объект - экземляр класса
+
+```С++
+class ClassName{
+// Поля и методы класса
+};
+```
+
+> Поля класса - переменные, котроые представляют состояие объетогв класса
+> Методы класа - функции, которые определяют поведение объектов класса
+
+```С++
+ClassName objectName; // создание объекта класса просто
+
+ClassName objectName = new ClassName(); //создание объекта класса сложно
+delete objectName;
+```
+
+## Пример
+
+```С++
+#include <iostream>
+#include <string>
+
+class Person{
+public:
+std::string name;
+int age;
+
+void displayInfo(){
+    std::count << "Name: " << name << ", Age: " << age << '\n';
+}
+}
+
+int main(){
+Person person1;
+person1.name = "Alice";
+person1.age = 25;
+person1.displayInfo();
+
+Person* person2 = new Person();
+person2 -> name = "Bob";
+person2 -> age = 30;
+person2 -> displayInfo();
+
+delete person2;
+return 0;
+}
+```
+
+> Пользовательский тип данных
+
+### Модификаторы доступа
+
+* public - доступно всем (по умолчанию в struct)
+* private - доступно только внутри класса (по умолчанию в class)
+* protected - достпуно внутри класса и наследникам
+
+### Конструктор и деструктор
+
+> Конструктор - функция, которая вызывается при инициализации класса (может быть несколько)
+> Деструктор - функция, которая вызывается при уничтожении объекта
+
+```C++
+#include <iostream>
+
+class MyClass {
+public:
+    MyClass() {
+        std::cout << "Constructed\n";
+    }
+
+    MyClass(int val) {
+        std::cout << "Constucted" << val << '\n';f
+    }
+
+    ~MyClass() {
+        std::cout << "Destroyed\n";
+    }
+};
+```
+
+### this
+
+> this - указатель на объект вызвовший метод
+
+```C++
+#include <string>
+
+class Foo{
+public:
+    Person(std::string val) {
+        this->name = val;
+    }
+};
+```
+
+## ООП
+
+> Инкапсуляция - данные класса скрыты от прямого доступа и манипулиций извне класса
+> Наследование - создаёт классы-потомки
+> Полимарфизм - разные классы используют один и тот же интерфейс
+
+```C++
+#include <iostream>
+
+class Figure {
+public:
+    virtual void draw() {
+        std::cout << "Draw figure\n";
+    }
+};
+
+class Circe: public Figure {
+public:
+    void draw() override {
+        std::cout << "Draw circle\n";
+    }
+};
+
+class Rectangle: public Figure {
+public:
+    void draw() override {
+        std::cout << "Draw rectangle\n";
+    }
+};
+
+int main() {
+    Figure* figure = new Figure();
+    Figure* circle = new Circle():
+    Figure* rectangle = new Rectangle();
+
+    figure->draw();
+    circle->draw();
+    rectangle->draw();
+
+    delete figure;
+    delete circle;
+    delete rectangle;
+}
+```