Виртуальные функции - указатель базового класса

Question

Я понял, почему указатель базового класса делается для указания на объект производного класса. Но я не понимаю, почему нам нужно назначить ему объект базового класса, когда он является объектом базового класса сам по себе.

Может ли кто-нибудь объяснить это?

#include <iostream> 
using namespace std; 
class base { 
    public: 
     virtual void vfunc() { 
      cout << "This is base's vfunc().\n"; 
     } 
}; 
class derived1 : public base { 
     public: 
      void vfunc() { 
       cout << "This is derived1's vfunc().\n"; 
    } 
}; 
int main() 
{ 
    base *p, b; 
    derived1 d1; 
    // point to base 
    p = &b; 
    p->vfunc(); // access base's vfunc() 
    // point to derived1 
    p = &d1; 
    p->vfunc(); // access derived1's vfunc() 
    return 0; 
} 

Answer 1

Потому что указатели сами по себе ничего не могут сделать.
Указатель должен указывать на действительный объект, чтобы вы могли его использовать.

Почему вышеупомянутое заявление?

Поэтапное объяснение, возможно, устранит ваши сомнения.

Шаг 1:

base *p; 

Создает указатель p который может хранить адрес объекта класса base. Но он не инициализирован, он указывает на любой случайный адрес в памяти.

Шаг 2:

p = &b; 

Назначает адрес с действительным base объекта к указателю p. p теперь содержит адрес этого объекта.

Шаг 3:

p->vfunc(); // access base's vfunc() 

Dererences указатель p и вызов метода vfunc() на объект, на который указывает его. i.e: b.

Если удалить Шаг 2:, Ваш код просто пытается разыменования UNINITIALIZED указатель и вызовет Undefined Behavior & скорее всего аварии.

Answer 2

Не обязательно называть

p = &b; 
p->vFunc(); 

вы можете напрямую позвонить

b.vFunc(); 

как даст тот же результат.

Однако, похоже, вы должны понимать силу виртуальных функций. Предположим, хотите ли вы сохранить 10 экземпляров объектов base или derived1 и вызвать функцию повторно, как вы это сделаете? или после сохранения его в массиве, если вы хотите передать его общей функции?

vase *p[4]; 

base b1; 
derived d; 

p[0] = new base(); 

p[1] = &b1; 

p[2] = new dervied1();  

p[3] = &d; 

for (int i =0 ;i <4 ;i++) 
{ 
    p[i]->vFunc(); 
} 

Answer 3

Я не полностью уверены, что я понимаю ваш вопрос совершенно, но типичного случая использования виртуальной функции, когда мы пишем функцию, и хочу работать с объектом базы класс или что-либо производные от него:

struct base { 
    virtual void dosomething() = 0; 
}; 

void myfunc(base *b) { 
    b->dosomething(); 
} 

Когда мы пишем myfunc, мы не знаем и не заботиться о точной идентичности объекта вовлеченного - мы просто заботимся о том, что он знает, как dosomething по команде.

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

Answer 4

Этот тип ссылок очень хорошо применяется, когда вы хотите применять шаблоны проектирования (вам может потребоваться пройти продвинутый курс объектно-ориентированного дизайна или начать с чтения книги: сначала голова, дизайн-паттерны, я предлагаю)

смотрите, например, как реализовать узор декоратора в java в указанной книге.

public abstract class Beverage { 
String description = "Unknown Beverage"; 
public String getDescription() { 
    return description; 
} 
public abstract double cost(); 
} 

то, что мы имеем эспрессо и DarkRoast как два дочерних классов:

public class Espresso extends Beverage { 

public Espresso() { 
    this.description = "Espresso"; 
} 

public double cost() { 
    return 1.99; 
} 
} 

public class DarkRoast extends Beverage { 
public DarkRoast() { 
    description = "Dark Roast Coffee"; 
} 

public double cost() { 
    return .99; 
} 
} 

теперь мы собираемся добавить декоратор:

public abstract class CondimentDecorator extends Beverage { 
public abstract String getDescription(); 
} 

и построить некоторые конкретные декоратора:

public class Mocha extends CondimentDecorator { 

Beverage beverage; 

public Mocha(Beverage beverage) { 
    this.beverage = beverage; 
} 

public String getDescription() { 
    return beverage.getDescription() + ", Mocha"; 
} 

public double cost() { 

    return .20 + beverage.cost(); 
} 
} 

и другая обертка:

public class Whip extends CondimentDecorator { 
Beverage beverage; 

public Whip(Beverage beverage) { 
    this.beverage = beverage; 
} 

public String getDescription() { 
    return beverage.getDescription() + ", Whip"; 
} 

public double cost() { 
    return .10 + beverage.cost(); 
} 
} 

наконец, увидеть то, что произошло в основной функции и как воспользоваться преимуществами указателя на класс отца:

public static void main(String[] args) { 
    Beverage beverage = new Espresso(); 
    System.out.println(beverage.getDescription() + " $" + beverage.cost()); 
    Beverage beverage2 = new DarkRoast(); 
    beverage2 = new Mocha(beverage2); 
    beverage2 = new Mocha(beverage2); 
    beverage2 = new Whip(beverage2); 
    System.out.println(beverage2.getDescription() + " $" + beverage2.cost()); 

вы можете догадаться, что это выход? скважина:

Espresso $1.99 
Dark Roast Coffee, Mocha, Mocha, Whip $1.49