Каково различие между реальным классом и абстрактным классом?

Абстрактный класс - это класс, для которого одно или несколько методов объявлены, но не определены, что означает, что компилятор знает, что эти методы являются частью класса, но не какой код для выполнения этого метода. Они называются абстрактными методами. Вот пример абстрактного класса.

class shape {
public:
  virtual void draw() = 0;
};

Это объявляет абстрактный класс, который указывает, что любые потомки класса должны реализовывать метод рисования, если класс должен быть конкретным. Вы не можете создать экземпляр этого класса, потому что это абстрактно, в конце концов, компилятор не знал бы, какой код выполнить, если вы звоните элементу. Таким образом, вы не можете сделать следующее:

shape my_shape();
my_shape.draw();

, чтобы иметь возможность фактически использовать метод вытягивания, вам нужно будет получать классы из этого абстрактного класса, который реализует метод рисования, что делает классы бетона:

class circle : public shape {
public:
  circle(int x, int y, int radius) {
    /* set up the circle */
  }
  virtual draw() {
    /* do stuff to draw the circle */
  }
};

class rectangle : public shape {
public:
  rectangle(int min_x, int min_y, int max_x, int max_y) {
    /* set up rectangle */
  }
  virtual draw() {
    /* do stuff to draw the rectangle */
  }
};

теперь вы можете создать Бетонные объекты круг и прямоугольник и используют их методы рисования:

circle my_circle(40, 30, 10);
rectangle my_rectangle(20, 10, 50, 15);
my_circle.draw();
my_rectangle.draw();

Теперь, конечно, вопрос в том, почему вы хотите сделать это? Разве вы не могли бы вы просто определили классы круга и прямоугольников и сделали все класс формы? Вы могли бы, но тогда вы не сможете воспользоваться их наследованием:

std::vector<shape*> my_scene;
my_scene.push_back(new circle(40, 30, 10));
my_scene.push_back(new rectangle(20, 10, 50, 15));
std::for_each(my_scene.begin(), my_scene.end(), std::mem_fun_ref(&shape::draw)

Этот код позволяет забрать все свои формы в один контейнер. Это делает его намного проще, если у вас много форм и много разных форм на вашей сцене. Например, теперь мы можем нарисовать все формы в одном Go, и код, который так, даже не нужно знать о различных видах форм, которые у нас есть.

Теперь, наконец, нам нужно знать, почему функция рисования формы абстрактна, а не просто пустая функция, то есть почему мы не просто определили:

class shape {
public:
  virtual void draw() {
    /* do nothing */
  }
};

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

Чтобы ответить вам последний вопрос, нет никакой такой вещи, как «нормальный полученный класс» каждый класс, является либо абстрактным, либо бетоном. Класс, который имеет какие-либо абстрактные методы, абстрактно, любой класс, который не является бетоном. Это просто способ дифференцировать два типа классов. Базовый класс может быть абстрактным, либо бетонным, и полученный класс может быть либо абстрактным, либо бетонным:

class abstract_base {
public:
  virtual void abstract_method1() = 0;
  virtual void abstract_method2() = 0;
};

class concrete_base {
public:
  void concrete_method1() {
    /* do something */
  }
};

class abstract_derived1 : public abstract_base {
public:
  virtual void abstract_method3() = 0;
};

class abstract_derived2 : public concrete_base {
public:
  virtual void abstract_method3() = 0;
};

class abstract_derived3 : public abstract_base {
public:
  virtual abstract_method1() {
    /* do something */
  }
  /* note that we do not provide an implementation for
     abstract_method2 so the class is still abstract */
};

class concrete_derived1 : public concrete_base {
public:
  void concrete_method2() {
    /* do something */
  }
};

class concrete_derived2 : public abstract_base {
public:
  virtual void abstract_method1() {
    /* do something */
  }
  virtual void abstract_method2() {
    /* do something */
  }
  /* This class is now concrete because no abstract methods remain */
};