308 lines
8.6 KiB
Markdown
308 lines
8.6 KiB
Markdown
## 3.7 Pointers to members
|
||
|
||
```C++
|
||
struct S {
|
||
int x;
|
||
double y;
|
||
|
||
void f(int z) {
|
||
std::cout << x + z << std::endl;
|
||
}
|
||
};
|
||
|
||
int main() {
|
||
int S::* p = &S::x;
|
||
S s;
|
||
s.*p; // returns s.x;
|
||
|
||
S* ps = &s;
|
||
ps->*p; // returns s.x;
|
||
|
||
void (S::* pf)(int) = &S::f; // pointer to method
|
||
(s.*pf)(3);
|
||
(ps->*pf)(5)
|
||
}
|
||
```
|
||
|
||
Интуитивно указатель на поле хранит "сдвиг относительно начала структуры".
|
||
|
||
## 3.8 Enums and enum classes
|
||
|
||
Дословно перечислимый тип
|
||
|
||
```C++
|
||
enum E {
|
||
White, Gray, Black
|
||
};
|
||
|
||
int main() {
|
||
int e = White;
|
||
std::cout << e << std::endl; // 0
|
||
}
|
||
```
|
||
|
||
Можно использовать как отдельный тип `E`, но он хранится в памяти как `int` и нумеруется начиная с нуля.
|
||
|
||
В C++-11 появились `enum class`. Она не вносит интовые константы и запрещает неявные конверсии.
|
||
|
||
С помощью двоеточия можно описать каким типом он должен представляться(обязательно целочисленным)
|
||
|
||
```C++
|
||
enum class E : int8_t {}
|
||
```
|
||
|
||
# IV. Inheritance
|
||
## 4.1 Public, private and protected inheritance
|
||
|
||
```C++
|
||
|
||
class Base {
|
||
protected:
|
||
int x;
|
||
public:
|
||
void f() {}
|
||
};
|
||
|
||
class Derived : Base {
|
||
int y;
|
||
void g() {
|
||
std::cout << x << std::endl; // x is inherited from Base, and protected
|
||
}
|
||
};
|
||
|
||
int main() {
|
||
Derived d;
|
||
// std::cout << d.x << std::endl; CE, x is protected
|
||
}
|
||
```
|
||
|
||
Ключевое слово `protected` означает то, что в отличие от `private` данный член класса будет доступен еще и его наследникам.
|
||
|
||
Наследование также бывает публичным, приватным, и защищенным.
|
||
|
||
По умолчанию у структур оно публичное, у классов приватное.
|
||
|
||
Публичное наследование значит, что "все знают" о том, что `Derived` является наследником `Base`, а приватное значит, что "никто не
|
||
знает".
|
||
|
||
Например, если мы сделаем `Derived : private Base`, то из `main` мы не сможем вызвать `d.f()`, так как хоть `f` и публично в `Base`, мы
|
||
унаследовали его приватно.
|
||
|
||
Если мы сделаем `Derived : public Base`, то мы все равно не сможем обратится к `d.x`, так как `d.x` приватно в `Base`.
|
||
|
||
Защищенное наследование значит, что только лишь друзья, наследники, и сам `Derived` имеет доступ к родительским полям.
|
||
|
||
По сути права доступа к полю "перемножаются" на тип наследования, нужно "пройти" оба модификатора.
|
||
|
||
```C++
|
||
|
||
struct Granny {
|
||
int x;
|
||
void f() {}
|
||
};
|
||
|
||
struct Mom : protected Granny {
|
||
int y;
|
||
void g() {
|
||
std::cout << x << std::endl;
|
||
}
|
||
};
|
||
|
||
struct Son : Mom {
|
||
int z;
|
||
void h() {
|
||
std::cout << x << std::endl // OK, can pass protected modifier
|
||
}
|
||
};
|
||
|
||
int main() {
|
||
Son s;
|
||
// s.x; cannot pass protected modifier from Mom to Granny
|
||
s.y; // OK, default inheritance for struct is public
|
||
}
|
||
```
|
||
|
||
Как работает дружба при наследовании?
|
||
|
||
Допустим в `struct Granny` мы объявили `main` своим другом.
|
||
Тогда теперь мы всё ещё не сможем обратиться к `s.x`. И это логично, ведь `friend` снимает все ограничения, которые ты наложил, но не те,
|
||
которые наложил кто-то другой, например, твой наследник.
|
||
|
||
> Строгая мама запрещает общаться с доброй бабушкой
|
||
|
||
## 4.2 Visibility
|
||
|
||
Что происходит если есть конфликт имён?
|
||
|
||
```C++
|
||
|
||
struct Base {
|
||
int x;
|
||
void f() {
|
||
std::cout << 1 << std::endl;
|
||
}
|
||
};
|
||
|
||
struct Derived : Base {
|
||
int y;
|
||
void f() {
|
||
std::cout << 2 << std::endl;
|
||
}
|
||
};
|
||
|
||
int main() {
|
||
Derived d;
|
||
d.f() // OK, 2
|
||
}
|
||
```
|
||
|
||
Главный принцип: _частное главнее общего_.
|
||
|
||
А что если
|
||
```C++
|
||
|
||
struct Base {
|
||
int x;
|
||
void f(int) {
|
||
std::cout << 1 << std::endl;
|
||
}
|
||
};
|
||
|
||
struct Derived : Base {
|
||
int y;
|
||
void f(double) {
|
||
std::cout << 2 << std::endl;
|
||
}
|
||
};
|
||
|
||
int main() {
|
||
Derived d;
|
||
d.f(0) // ???
|
||
}
|
||
```
|
||
|
||
Программа выведет 2. Более того, если бы `f` не принимала аргументов, то была бы ошибка компиляции. Полезно думать об этом так,
|
||
`Derived::f` затмевает `Base::f` как будто бы это более локальная область видимости.
|
||
|
||
Если мы хотим явно вызваться от родителя, то можно написать `d.Base::f(0);`.
|
||
|
||
Приватность и публичность также не влияет на то, какой метод мы будем вызывать, свой или родительский.
|
||
|
||
Чтобы научиться выбирать, нужно написать `using Base::f` внутри `Derived`. Более того, `using Base::f` игнорирует родительский
|
||
модификатор доступа, что логично.
|
||
|
||
Сначала создается область видимости, потом проверяются права доступа.
|
||
|
||
Сам `using` можно сделать приватным
|
||
```C++
|
||
private:
|
||
using Base::x;
|
||
```
|
||
|
||
Самый кринж
|
||
|
||
```C++
|
||
struct Granny {
|
||
int x;
|
||
void f() {}
|
||
};
|
||
|
||
struct Mom: private Granny {
|
||
friend int main();
|
||
int x;
|
||
};
|
||
|
||
struct Son : Mom {
|
||
int x;
|
||
void f(Granny& g) {
|
||
std::cout << g.x << std::endl;
|
||
}
|
||
};
|
||
```
|
||
|
||
Оно не скомпилируется, так как `Granny` из области видимости сына приватное и он не имеет к нему доступа. Поэтому нужно писать `::Granny &g`, дабы подчеркнуть, что имя берется из глобальной области.
|
||
|
||
## 4.3 Memory layout, constructors and destructors in case of inheritance.
|
||
|
||
```C++
|
||
struct Base {
|
||
int x;
|
||
};
|
||
|
||
struct Derived : Base {
|
||
double y;
|
||
};
|
||
|
||
int main() {
|
||
sizeof(Derived); // OK, 16. First x, then y, according to padding it's 2 * 8 = 16
|
||
}
|
||
```
|
||
|
||
А что если `Base` вообще не содержит полей, только, возможно, методы. `sizeof(Base) > 0`, так как структура должна иметь хоть какой-то
|
||
размер, чтобы разные размеры имели разные адреса.
|
||
|
||
Но тем не менее, `sizeof(Derived) == 8`. Данный феномен именуется EBO (Empty Base Optimization). Пустому `Base` разрешается ничего не
|
||
занимать в памяти.
|
||
|
||
При конструкции всегда должен **сначала** инициализироваться родитель. То есть либо у `Base` есть дефолтный конструктор, либо нужно
|
||
писать что-то типа
|
||
|
||
```C++
|
||
struct A {
|
||
A(int) { std::cout << "A " << x << std::endl; }
|
||
};
|
||
|
||
struct Base {
|
||
A x;
|
||
Base(int x): x(x) { std::cout << "Base" << std::endl; }
|
||
};
|
||
|
||
struct Derived : Base {
|
||
A y;
|
||
Derived(double y): Base(0), y(y) { std::cout << "Derived" << std::endl; }
|
||
}
|
||
|
||
int main() {
|
||
Derived d = 1;
|
||
}
|
||
```
|
||
|
||
Программа выведет
|
||
```
|
||
A 0
|
||
Base
|
||
A 1
|
||
Derived
|
||
```
|
||
|
||
Если написать деструкторы, то так как сначала выполняется тело деструктора, а потом уничтожаются поля, причём в обратном порядке, то выведется
|
||
```
|
||
~Derived
|
||
~A 1
|
||
~Base
|
||
~A 0
|
||
```
|
||
|
||
## 4.4 Casts in case of inheritance
|
||
|
||
```C++
|
||
struct Base {
|
||
int x = 1;
|
||
};
|
||
|
||
struct Derived : Base {
|
||
int y = 2;
|
||
};
|
||
|
||
void f(Base& b) {
|
||
std::cout << b.x << std::endl;
|
||
}
|
||
|
||
int main() {
|
||
Derived d;
|
||
f(d); // OK, can cast Derived to Base
|
||
}
|
||
```
|
||
|
||
Суть в том, что наследника можно кастовать к родителям, а вот обратное, ясное дело нельзя, ведь наследник может больше, чем родитель.
|