Използване на силата на виртуалните функции

Тази програма е тривиална и наистина не демонстрира много добре силата на виртуалните функции (или по-общо полиморфизма). Помислете за тази промяна:

// add second derived class
class Derived2 : public Base {
public:
    void vf() { std::cout << "Derived2 vf()" << std::endl; }
};

// in main
int user_choice;
std::cin >> user_choice;
Base * ptr;
if (user_choice == 0)
    ptr = new Derived();
else
    ptr = new Derived2();
ptr->vf();

Тук изборът на клас зависи от въвеждането на потребителя - компилаторът няма начин да предскаже какъв тип обект ptr действително ще сочи към повикването ptr->vf();.

В ред Base* bp = &d2 типът на обекта е известен по време на компилиране. Тогава решението коя функция да се използва в случая на bp->vf(); също може да бъде взето по време на компилиране, нали?

Да.
Това е част от оптимизацията на компилатора, която повечето съвременни интелигентни компилатори ще могат да направят.

Ако компилаторът може да определи коя функция да извика по време на самото компилиране, тогава той ще го направи. Докато това зависи изцяло от компилатора дали може да открие точната функция, която да извика по време на компилиране или по време на изпълнение, виртуализмът ви гарантира поведението, което искате за вашата програма.

Тъй като типът на обекта е известен по време на самото компилиране, силата на виртуалните функции използва ли се в тази примерна програма?

Зависи изцяло от компилатора. Повечето съвременни компилатори ще могат да оценят това извикване на функция по време на компилация.

Ами... ДА и НЕ и на двата въпроса: зависи на какво ниво на абстракция спорите.

• От езикова гледна точка 1) е погрешно схващане. Типът за d2 е известен, но когато дойде d2 адресът да бъде присвоен на bp, ще се извърши преобразуване от Derived* в Base*. От там нататък статичният тип на bp е Base* (защото това е неговата декларация), а динамичният тип, който сочи към неговия Произведен (защото това е, към което се отнася информацията за типа по време на изпълнение, свързана с обекта). От тях нататък всяка операция чрез bp приема Base* като тип и изисква пренасочване за всяка виртуална функция.

• От гледна точка на компилатора може да се направи известна оптимизация и тъй като във всички ваши функции pb винаги сочи към Derived, виртуалното пренасочване може всъщност да бъде пропуснато. Но това се дължи на начина, по който е структуриран вашият конкретен пример, а не на езикова характеристика.

In the line Base* bp = &d2, the object type is known at compile time. Then the decision of which function to use in the case of bp->vf(); can also be made at compile time right?

Не, решението коя функция да се използва се прави динамично по време на изпълнение въз основа на типа на обекта, а не на типа указател/препратка към този обект. Това се нарича динамично обвързване. Компилаторът поддържа скрит указател, наречен virtual pointer или vptr, който сочи към таблица, наречена виртуална таблица. Ще има една виртуална таблица на клас с поне една виртуална функция (независимо колко обекта са създадени за класа). Виртуалната таблица съдържа адреса на виртуалните функции на класа.

Since the object type is known at compile time itself, is the power of virtual functions used in this sample program?

Всъщност посоченият обект може да не е известен по време на компилиране. Вземете пример за метод, който приема указателя на базовия клас като параметър, както е показано по-долу:

void draw(Shape *bp)
{
    bp->draw();
}

В този случай действителният обект може да бъде всяка форма, получена от Shape. Но изчертаната форма зависи от действителния тип на предадения обект.