Showing posts with label class. Show all posts
Showing posts with label class. Show all posts

Friday, November 15, 2019

Абстрактные классы (интерфейсы) в си++

Любой объект или сущность в природе имеет уровень абстракции. Это удобно и позволяет переходить от общего к деталям и наоборот. Например, “стул” — это конкретное описание предмета, но мы также можем говорить о нем, как о “мебели” или к примеру, как об “изделии из дерева”. Исходя из этого мы можем сказать, что стул — это также и элемент мебели, еще раз – стул является элементом мебели. В свою очередь стулья могут делиться на офисные, кухонные, и т.д., что в свою очередь вырастает в довольно запутанную иерархию отношений.  В нашем случае нам помогают с этим справиться классы и наследование, мы говорили об этом, когда рассматривали полиморфизм. Животные как общий уровень абстракции и кот с собакой, как конкретный уровень абстракции. К примеру общий уровень нам нужен как тип контейнера, в котором мы храним конкретные типы.

Как правило, когда мы работаем с иерархией классов нам нужны объекты конкретных типов, а не общих. В рассмотренном примере нам были нужны объекты конкретно собаки и кота. Но если бы мы рассматривали животных, рыб и людей, как конкретные типы формы жизни на нашей планете, то животные были бы конкретным типом, и мы бы создавали такие объекты.  Более того, если мы создаем в базовом классе чисто виртуальные функции, которые обязуемся реализовать в наследниках, то физически не можем создавать объекты такого класса. Вот и получается, что базовый класс для таких наследников является абстрактным, и служит лишь для доступа к наследующим его конкретным классам, и мы называем его интерфейсом.
 
Как пульт дистанционного управления является интерфейсом между человеком и телевизором. Пультов много разных по форме, способу ввода информации и т.д. но все они должны предоставлять для пользователя кнопки с цифрами, для ввода номеров каналов. Этими кнопками служат наши чисто виртуальные методы. В современных языках программирования (Java), есть специальное ключевое слово “Interface“, служащее специально для этих целей, что облегчает узнавание таких классов в коде.  Давайте рассмотрим пример с такой иерархией.

           [__Shape__]       [_IDrawable_]      [_IMovable_]
          ^                 ^          ^            ^            ^
         /                     \       /           /             /
  [_Triangle_]        [_Circle_]         /             /
         \_____________________/________/

У нас есть базовый класс Shape, от которого мы наследуем классы Triangle и Circle. У Фигуры есть приватные поля и публичные методы, которые наследуются. У Круга также есть поле и метод. Также у нас есть два интерфейса. IDrawable, который наследуется Треугольником и Кругом, и IMovable, который наследуется только Треугольником. Таким образом мы хотим гарантировать то что оба наследника рисуются, т.е. переопределяют метод draw(). И Треугольник может двигаться, переопределяя метод move().

#include <iostream>
#include <vector>
#include <string>

class IDrawable {
public:
    virtual void draw() = 0;
};
class IMovable {
public:
    virtual void move() = 0;
};

class Shape {
public:
    Shape(int _x, int _y) : x{_x}, y{_y} {}
    virtual ~Shape() = default;
    int getX() const {return x;}
    int getY() const {return y;}
private:
    int x;
    int y;
};

class Triangle : public Shape, public IDrawable, public IMovable{
public:
    Triangle(int _x, int _y) : Shape(_x, _y) {}
    ~Triangle() override = default;
    void draw() override {std::cout << "Triangle draw\n";}
    void move() override {std::cout << "Triangle move\n";}
private:
};

class Circle : public Shape, public IDrawable {
public:
    Circle(int _x, int _y, int _r) : Shape(_x, _y), r{_r} {}
    ~Circle() override = default;
    void draw() override {std::cout << "Circle draw\n";}
    int getR() const {return r;}
private:
    int r;
};

Теперь для того чтобы не создавать каждый раз новый контейнер, определенного типа (например, одного из интерфейсов или базового класса), а работать с одним, нам нужен инструмент для перехода по иерархии типов, для вызова методов этих типов или доступа к данным. Дело в том, что имея например, контейнер Фигур, мы можем иметь доступ только к членам этого типа. И хотя в контейнере хранятся Круги, нам не доступен Радиус (int r) этих объектов. Но так как Круг является Фигурой (по нашей иерархии), мы можем изменить тип объекта из Фигуры в Круг, тем самым получив доступ к его членам. В этом нам поможет динамическое приведение типов dynamic_cast<T>(obj), принимающий в качестве параметра объект obj, который мы хотим привести к типу T.

int main() {
    Triangle tri1(0, 0);
    Circle cir1(1, 1, 1);
    std::vector<IDrawable *> shapes = {&tri1, &cir1};

    for (auto i_asIDrawable : shapes) {
        i_asIDrawable->draw();
        if (auto i_asShape = dynamic_cast<Shape *>(i_asIDrawable)) {
            std::cout << "x: " << i_asShape->getX() << std::endl;
            std::cout << "y: " << i_asShape->getY() << std::endl;
        }
        if (auto i_asCircle = dynamic_cast<Circle *>(i_asIDrawable)) {
            std::cout << "r: " << i_asCircle->getR() << std::endl;
        }
        if (auto i_asIMovable = dynamic_cast<IMovable *>(i_asIDrawable)) {
            i_asIMovable ->move();
        }
    }
    return 0;
}

Output:
>>Triangle draw
>>x: 0
>>y: 0
>>Triangle move
>>Circle draw
>>x: 1
>>y: 1
>>r: 1

К сожалению, использовать динамическое приведение очень дорого, т.к. создается временная копия объекта с новым типом. И считается плохим архитектурным решением. Поэтому часто, в угоду производительности,  интерфейсы объединяют в базовые классы, что усложняет понимание кода.
 
Перегуд В.

Thursday, October 31, 2019

Полиморфизм в си++.


Что такое полиморфизм? Давайте разбираться вместе. В каком-то смысле это свойство пользовательских типов. В более современных языках, таких как Java, в которых нет ограничений по обратной совместимости, полиморфизм “включен” по умолчанию. В нашем случае это не так, и его нужно включать принудительно. Но погодите, сам по себе полиморфизм не существует, сначала нам понадобится наследование. Вообще пользовательские типы это много всякой "дури", но не будем хвататься за все сразу. Наследовать свойства одних типов другими это удобно, преимущества такого подхода всем известны, это дает нам возможность строить родительские связи между типами и работать с наследниками как потомками одного родительского типа.

Давайте рассмотрим пример. Мы имеем родительский класс животные и его наследников кот и собака.
class Cat : public Animal {}; Cat cat;
Сложим наших наследников в контейнер и обработаем каждый элемент в цикле, например, вызовем унаследованный от родительского типа метод – подать сигнал. Создав контейнер, который содержит "элементы" родительского типа - животные и так как этому условию соответствуют наши наследники – кот и собака, помещаем их туда.
vector<Animal*> army = {&cat, &dog};
for(auto solder : army){ solder->signal(); }
 
Далее мы можем "решать проблему" тремя способами.
 
Первый способ – мы хотим сохранить нашу систему как можно более простой и принимаем как должное, что все животные могут “говорить”, просто издавать звуки, это достаточный для нас уровень абстракции, и мы не будем его дальше детализировать. Потому что на уровне наследников нам не важно, что именно они “говорят”, а более важно к примеру, что кот ловит мышей, а собака нарушителей границы, но при этом они могут подать звуковой сигнал. Создадим в родителе общий для всех наследников метод один раз и можем его использовать в любом наследнике, которых может быть любое количество.
class Animal{ void signal() { todo(); } }; 
 
Второй способ, когда у нас возникла необходимость конкретизировать поведение некоторых наследников. По каким-то причинам это может понадобится - переопределить поведение наследника, чтобы оно отличалось от родительского.
class Cat : public Animal{ void signal() { todo(); } };
Но в отличии от Java, только этого недостаточно. Мы должны указать в родительском типе, что при наличии преопределенного метода в наследнике, нужно использовать именно его, с помощью ключевого слова virtual:
virtual void signal() { todo(); }
В добавок для удобства можно использовать ключевое слово override в наследнике:
void signal() override { todo(); }
 
Третий способ, это частный случай второго способа, когда у нас возникла необходимость конкретизировать поведение всех наследников. В этом случае, с одной стороны нам не нужно определять общий для вех наследников метод - мы это сделаем в самих наследниках, с другой стороны нам нужно как-то указать на необходимость обязательного определения такого поведения в наследниках, т.к. если мы его не определим в родителе или наследнике, то при его вызове получим ошибку. В этом случае нам поможет чисто виртуальный метод, записанный в родительском типе в таком виде:
virtual void signal() = 0;
 
“И где тут полиморфизм?”, спросите вы. И вообще зачем он? Для меня ответ такой – это инструмент, который позволяет решать задачу действуя от общего к частному, что часто очень полезно. При таком подходе мы можем создать скелет сложной системы и потом изменять ее, путем добавления или замены ее элементов, которые будут вести себя по разному, настоящая магия и превращения (morph). В нашем случае мы работаем с животными, которые могут быть и вести себя как кот, собака и т.д. Давайте рассмотрим сам механизм:
Animal* x = &cat;
x->signal();
Слева у нас родительский тип животное, справа наследник кот. И у родителя, и у наследника есть поведение - сигнал, какой его вариант будет использован при вызове, родительский или потомка?
 
Если мы хотим, чтобы использовался родительский, это обычное наследование без полиморфизма, это рассмотренный выше первый способ. Если мы хотим использовать вариант потомка, что в свою очередь дает возможность использовать собственные варианты для разных потомков, то есть вести себя по-разному – полиморфно. То определяем родительское поведение, как виртуальное, это рассмотренный выше второй способ.
 
Код, который можно скомпилировать:
#include <iostream>
#include <vector>

class Animal {
public:
    virtual void signal() {
        std::cout << "Animal!\n";
    }
};

class Cat : public Animal {
public:
    void signal() override {
        std::cout << "Cat!\n";
    }
};

class Dog : public Animal {
public:
    //void signal() override {
    //    std::cout << "Dog!\n";
    //}
};

int main() {
    Cat cat;
    Dog dog;
    std::vector<Animal *> army = {&cat, &dog};
    for (auto solder:army) {
        solder->signal();
    }

    return 0;
}

Output:
>>Cat!
>>Animal!

P.S. Статья писалась с целью навести порядок в голове, буду рад если еще кому-то будет полезно.
Перегуд В.