# 10 лекция - C++

(30.04.2022)

## Методы
Методы - функции класса или структуры

struct A
{
	int x;
	int f() {return x;}
};

A a;

sizeof(a);	//4, размеру int, тк функция не храниться в классе, она хранится в секции кода, имеет специльное скрытое имя, для связывания с классом A 

sizeof(A); //A, тоже самое

## Классы

### Инкапсуляция
Если вы хотите ограничить видимость некоторых методов и данных от пользователя библиотеки (Тк методы и поля могут поменяться в дальшейшем, что не должно ломать код, который раньше использовал вашу библиотеку)

#### Модификаторы доступа

1) `private`
2) `public`
3) `protected` (про наследование)

struct A
{
private: //(всё до конца закрыто снаружи или другого модификатора)
	int x;
public: //(всё до конца доступно снаружи или другого модификатора)
	int f() {return x;}
};

A a;

> У `struct` по умолчанию модификатор доступа `public`
> У `class` по умолчанию модификатор доступа `private`
> Больше различий НЕТ!

Как обратиться к `private` полям и методам если очень хочется

#define class struct
#define private public

(Можно сделать через ключи компиляции)

> Дефайны через ключи компиляции задают `define` на все файлы, если есть такой-же `define` в коде он переопредилит значние на новое (два одинаковых `define` не ошибка, варнинг, новый его переопределит)

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

`protected` поля не видны для окружающего мира, но видны наследникам

class A
{
private: 
	int x;
public: 
	int f() {return x;}
protected:
	float x;
};

class B : public A //('public' - способ наследования)
{
private:
	int z;
public:
	int g() {return f() + z;}
	int f() {return A::f() + z;} //можно перекрыть исходную (A::f() - вызов f из A)
protected:

};

B b;
b.f(); //будет вызов из B

> способ наследования понижает видимость до той, что мы указали
1) `public` ничего не меняет
2) `protected` сделает `public` поля класса `A` полями типа `protected`
3) `private` сделает `public` и `protected` поля класса `A` полями типа `private` (к ним будет доступ из `B`, естественно)

class A
{
private: 
	int y;
public: 
	int f() {return x;}
protected:
	float x;

friend int h(A &a);	//можно обьявить функцию или класс другом, она получает доступ ко всем private полям, Дружественность не наследуется и работает в одну сторону!	
//Не метод класса

	/*static int h() //Как статический метод, только без friend извращений
	{
		return y + 1;
	} //*/
};

int h(A &a)
{
	return a.y + 1;
}

> `friend` можно обьявлять в любом месте класса, и не может быть использован для доступа к `private` полям родителя.

#### Конструкторы/деструкторы при наследовании
Любят писать, что конструкторы и деструкторы не наследуются, но не все понимают, что это значит

class A
{
private: 
	int y;
public: 
	int f() {return x;}

	A(int x = 0, int t = 2){}
};

class B : public A
{
private:
	int z;
public:
	int f() {return A::f() + z;} 
protected:

};

A a(1, 4);
//B b(1, 4);	//Так нельзя
B b; //здесь будет вызван конструктор A

> Конструкторы наследуются, но не переходят к наследнику

class A
{
private: 
	int y;
public: 
	int f() {return x;}

	A(int x, int t = 2){}
};

class B : public A
{
private:
	int z;
public:
	int f() {return A::f() + z;} 
	B() : A(3) {}	//так можно иниц родителей
protected:

};

A a(1, 4);
//B b(1, 4);	//Так нельзя
B b; //здесь будет вызван конструктор A

> Сначала вызовется деструктор `B`, затем он вызывает деструктор `A`.

#### Указатели на классы

class A
{
private: 
	int y;
public: 
	int f() {return x;}

	A(int x, int t = 2){}
};

class B : public A
{
private:
	int z;
public:
	int f() {return A::f() + z;} 
	B() : A(3) {}	//так можно иниц родителей
protected:

};

A *a = new A;
B *b = new B;

a->f();
b->f();

A *p;
p = b; //указатель на A внутри B;
p->f(); //из A

class A
{
private: 
	int y;
public: 
	virtual int f() {return x;}	//вызывается в соотствие с типом обьекта
    //, а не типом указателя 

	A(int x, int t = 2){}
};

class B : public A
{
private:
	int z;
public:
	int f() {return A::f() + z;} 
	B() : A(3) {}	//так можно иниц родителей
protected:

};

A *a = new A;
B *b = new B;

a->f();
b->f();

A *p;
p = a;
p->f(); //из A
p = b; //указатель на A внутри B;
p->f(); //из B

delete p; //освободит память B, но вызовет только деструктор A

> Конструкторы не бывают виртуальным (очевидно)
> Деструкторы бывают виртуальными (очевидно)

> Таблица виртуальных функций лежит в `A` и это дополнительный вызов в память

> виртуальные функции будут виртуальными во всех наследниках по умолчанию

Можно написать `virtual f() = 0;`, означает что здесь нет реализации `f`, этот класс будет абстрактным. Мы не сможем создать копию абстрактного класса, но можем создать на него указатель. Абстрактный класс не жизнеспособен самостоятельно, но жизнеспособен (и его копия есть) в составе наследника, который реализовал все абстрактные функции.
(можно написать только для `virtual` и `0`)

#### Множественное наследование
(есть только в C++ и Python)

class B: public A, public C 
{
	//...
}

Представим ситуацию

A -> B  -> D
  -> C  

`B` и `C` наследуются от `A`, `D` наследуется от `B` и `C`.
> В `D` будет две разные реализации A!

Можно обьединить, надо поставить модификатор `virtual` в классах `B` и `C` при наследование от `A` - `class B : virtual public A`. (не бесплатно, тоже таблица виртуальности)

> `virtual` ставишь там где раcходятся реализацции на класс который не хочешь чтобы в будущем размножился.