зачем нам нужны виртуальные функции в c ++?

<p>я изучаю c++, и я только вхожу в виртуальные функции.</p><p>из того, что я прочитал (в книге и онлайн), виртуальные функции - это функции в базовом классе, которые вы можете переопределить в производных классах.</p><p>но ранее в книге, изучая базовое наследование, я смог переопределить базовые функции в производных классах без использования <code>virtual</code>.</p><p>так чего мне здесь не хватает? я знаю, что есть еще что-то для виртуальных функций, и это кажется важным, поэтому я хочу уточнить, что это такое. я просто не могу найти прямой ответ в интернете.</p>

<p>вот как я понял не только то, что --- <a href="https://www.ibm.com/support/knowledgecenter/en/ssltbw\_2.3.0/com.ibm.zos.v2r3.cbclx01/cplr139.htm"><code>virtual</code></a> функции, но почему они необходимы:</p><p>допустим, у вас есть эти два класса:</p><pre><code>class animal { public: void eat() { std::cout << "i'm eating generic food."; } }; class cat : public animal { public: void eat() { std::cout << "i'm eating a rat."; } }; </code></pre><p>в вашей основной функции:</p><pre><code>animal *animal = new animal; cat *cat = new cat; animal->eat(); // outputs: "i'm eating generic food." cat->eat(); // outputs: "i'm eating a rat." </code></pre><p>пока все хорошо, правда? животные едят обычную пищу, кошки едят крыс, все без <code>virtual</code>.</p><p>давайте немного изменим его, чтобы <code>eat()</code> вызывался через промежуточную функцию (тривиальная функция только для этого примера):</p><pre><code>// this can go at the top of the main.cpp file void func(animal *xyz) { xyz->eat(); } </code></pre><p>теперь наша основная функция:</p><pre><code>animal *animal = new animal; cat *cat = new cat; func(animal); // outputs: "i'm eating generic food." func(cat); // outputs: "i'm eating generic food." </code></pre><p>э-э-э ... мы передали кота в <code>func()</code>, но он не будет есть крыс. если вы перегружаете <code>func()</code>, чтобы он занимал <code>cat*</code>? если вам нужно извлечь больше животных из animal, им всем понадобится собственная функция <code>func()</code>.</p><p>решение состоит в том, чтобы сделать <code>eat()</code> из класса <code>animal</code> виртуальной функцией:</p><pre><code>class animal { public: virtual void eat() { std::cout << "i'm eating generic food."; } }; class cat : public animal { public: void eat() { std::cout << "i'm eating a rat."; } }; </code></pre><p>главный:</p><pre><code>func(animal); // outputs: "i'm eating generic food." func(cat); // outputs: "i'm eating a rat." </code></pre><p>готово.</p>

<p>без "виртуального" вы получаете "раннее связывание". какая реализация метода используется, определяется во время компиляции на основе типа указателя, через который вы вызываете.</p><p>с "виртуальным" вы получаете "позднее связывание". какая реализация метода используется, определяется во время выполнения в зависимости от типа указываемого объекта - как он был изначально создан. это не обязательно то, что вы думаете, основываясь на типе указателя, который указывает на этот объект.</p><pre><code>class base { public: void method1 () { std::cout << "base::method1" << std::endl; } virtual void method2 () { std::cout << "base::method2" << std::endl; } }; class derived : public base { public: void method1 () { std::cout << "derived::method1" << std::endl; } void method2 () { std::cout << "derived::method2" << std::endl; } }; base* obj = new derived (); // note - constructed as derived, but pointer stored as base* obj->method1 (); // prints "base::method1" obj->method2 (); // prints "derived::method2" </code></pre><p><strong>редактировать</strong> - см. <a href="https://stackoverflow.com/questions/10580/what-are-early-and-late-binding">этот вопрос</a> .</p><p>также - <a href="http://www.learncpp.com/cpp-tutorial/124-early-binding-and-late-binding/">это руководство</a> охватывает раннее и позднее связывание в c++.</p>

<p>вам нужен как минимум 1 уровень наследования и принижение, чтобы продемонстрировать это. вот очень простой пример:</p><pre><code>class animal { public: // turn the following virtual modifier on/off to see what happens //virtual std::string says() { return "?"; } }; class dog: public animal { public: std::string says() { return "woof"; } }; void test() { dog* d = new dog(); animal* a = d; // refer to dog instance with animal pointer cout << d->says(); // always woof cout << a->says(); // woof or ?, depends on virtual } </code></pre>

<p>вам нужны виртуальные методы для <strong>безопасного понижения рейтинга</strong>, <strong>простота</strong> и <strong>краткость</strong>.</p><p>это то, что делают виртуальные методы: они безопасно снижают код, по-видимому, с простым и лаконичным кодом, избегая небезопасного ручного приведения в более сложный и подробный код, который вы могли бы иметь в противном случае.</p><hr><h1>не виртуальный метод ⇒ статическое связывание</h1><p>следующий код намеренно "неверен". он не объявляет метод <code>value</code> как <code>virtual</code> и поэтому выдает непреднамеренный "неправильный" результат, а именно 0:</p><pre><code>#include <iostream> using namespace std; class expression { public: auto value() const -> double { return 0.0; } // this should never be invoked, really. }; class number : public expression { private: double number\_; public: auto value() const -> double { return number\_; } // this is ok. number( double const number ) : expression() , number\_( number ) {} }; class sum : public expression { private: expression const* a\_; expression const* b\_; public: auto value() const -> double { return a\_->value() + b\_->value(); } // uhm, bad! very bad! sum( expression const* const a, expression const* const b ) : expression() , a\_( a ) , b\_( b ) {} }; auto main() -> int { number const a( 3.14 ); number const b( 2.72 ); number const c( 1.0 ); sum const sum\_ab( &a, &b ); sum const sum( &sum\_ab, &c ); cout << sum.value() << endl; } </code></pre><p>в строке, отмеченной как "плохой", вызывается метод <code>expression::value</code>, поскольку <strong>статически известный тип</strong> (тип, известный во время компиляции) - <code>expression</code>, а метод <code>value</code> не является виртуальным.</p><hr><h1>виртуальный метод ⇒ динамическое связывание.</h1><p>объявление <code>value</code> как <strong><code>virtual</code></strong> в статически известном типе <code>expression</code> гарантирует, что каждый вызов проверит, что это за фактический тип объекта, и вызовет соответствующую реализацию <code>value</code> для этого <strong>динамический тип</strong> :</p><pre><code>#include <iostream> using namespace std; class expression { public: virtual auto value() const -> double = 0; }; class number : public expression { private: double number\_; public: auto value() const -> double override { return number\_; } number( double const number ) : expression() , number\_( number ) {} }; class sum : public expression { private: expression const* a\_; expression const* b\_; public: auto value() const -> double override { return a\_->value() + b\_->value(); } // dynamic binding, ok! sum( expression const* const a, expression const* const b ) : expression() , a\_( a ) , b\_( b ) {} }; auto main() -> int { number const a( 3.14 ); number const b( 2.72 ); number const c( 1.0 ); sum const sum\_ab( &a, &b ); sum const sum( &sum\_ab, &c ); cout << sum.value() << endl; } </code></pre><p>здесь выводом является <code>6.86</code>, как и должно быть, поскольку виртуальный метод <strong>вызывается виртуально</strong>. это также называется <strong>динамическое связывание</strong> вызовов. выполняется небольшая проверка, находим фактический динамический тип объекта и вызывается соответствующая реализация метода для этого динамического типа.</p><p>соответствующая реализация относится к наиболее конкретному (наиболее производному) классу.</p><p>обратите внимание, что реализации методов в производных классах здесь не помечены <code>virtual</code>, а вместо этого помечены <strong><code>override</code></strong>. их можно пометить <code>virtual</code>, но они автоматически становятся виртуальными. ключевое слово <code>override</code> гарантирует, что если <em> нет </em> такого виртуального метода в некотором базовом классе, то вы получите ошибку (что желательно).</p><hr><h1>безобразие делать это без виртуальных методов</h1><p>без <code>virtual</code> нужно было бы реализовать некоторую <em> версию динамического связывания "сделай сам" </em>. именно это, как правило, связано с небезопасным ручным понижением, сложностью и многословностью.</p><p>для случая отдельной функции, как здесь, достаточно сохранить указатель на функцию в объекте и вызвать ее через этот указатель на функцию, но даже в этом случае требуется небезопасное снижение производительности, сложность и многословность:</p><pre><code>#include <iostream> using namespace std; class expression { protected: typedef auto value\_func( expression const* ) -> double; value\_func* value\_func\_; public: auto value() const -> double { return value\_func\_( this ); } expression(): value\_func\_( nullptr ) {} // like a pure virtual. }; class number : public expression { private: double number\_; static auto specific\_value\_func( expression const* expr ) -> double { return static\_cast<number const*>( expr )->number\_; } public: number( double const number ) : expression() , number\_( number ) { value\_func\_ = &number::specific\_value\_func; } }; class sum : public expression { private: expression const* a\_; expression const* b\_; static auto specific\_value\_func( expression const* expr ) -> double { auto const p\_self = static\_cast<sum const*>( expr ); return p\_self->a\_->value() + p\_self->b\_->value(); } public: sum( expression const* const a, expression const* const b ) : expression() , a\_( a ) , b\_( b ) { value\_func\_ = &sum::specific\_value\_func; } }; auto main() -> int { number const a( 3.14 ); number const b( 2.72 ); number const c( 1.0 ); sum const sum\_ab( &a, &b ); sum const sum( &sum\_ab, &c ); cout << sum.value() << endl; } </code></pre><p>один из положительных способов взглянуть на это так: если вы сталкиваетесь с небезопасным снижением рейтинга, сложностью и многословностью, как описано выше, то зачастую виртуальный метод или методы действительно могут помочь.</p>

<p>виртуальные функции используются для поддержки <strong>runtime polymorphism</strong>.</p><p>то есть ключевое слово <strong>virtual</strong> указывает компилятору <strong>не принимать решение (о привязке функции) во время компиляции, а отложить на время выполнения "</strong>.</p><ul> <li> <p>вы можете сделать функцию виртуальной, поставив перед ключевым словом <code>virtual</code> в объявлении базового класса. например,</p> <pre><code> class base { virtual void func(); } </code></pre></li> <li> <p>когда <strong>базовый класс</strong> имеет виртуальную функцию-член, любой класс, который наследуется от базового класса, может <strong>переопределить</strong> функцию с <strong>точно таким же прототипом</strong> т.е. только функциональность может быть переопределена, а не интерфейс функции.</p> <pre><code> class derive : public base { void func(); } </code></pre></li> <li> <p>указатель базового класса может использоваться для указания на объект базового класса, а также на объект производного класса.</p> </li> <li>когда виртуальная функция вызывается с использованием указателя базового класса, компилятор решает во время выполнения, какая версия функции - то есть версия базового класса или переопределенная версия производного класса - должна быть вызвана. это называется <strong>runtime polymorphism</strong>.</li> </ul>

<p>если базовый класс - <code>base</code>, а производный класс - <code>der</code>, у вас может быть указатель <code>base *p</code>, который фактически указывает на экземпляр <code>der</code>. когда вы вызываете функцию <code>p->foo();</code>, если <code>foo</code> <strong> не является </strong> виртуальной, то выполняется версия <code>base</code>, игнорируя тот факт, что <code>p</code> фактически указывает на <code>der</code>. если foo <strong> является </strong> виртуальным, <code>p->foo()</code> выполняет "крайний лист" переопределения <code>foo</code>, полностью принимая во внимание фактический класс указанного элемента. таким образом, разница между виртуальным и не виртуальным на самом деле довольно существенна: первый допускает время выполнения <a href="http://en.wikipedia.org/wiki/type\_polymorphism">полиморфизм</a> , базовую концепцию oo программирования, а второй - нет.</p>

<p>потребность в виртуальной функции объяснена [легко понять]</p><pre><code>#include<iostream> using namespace std; class a{ public: void show(){ cout << " hello from class a"; } }; class b :public a{ public: void show(){ cout << " hello from class b"; } }; int main(){ a *a1 = new b; // create a base class pointer and assign address of derived object. a1->show(); } </code></pre><p>результат будет:</p><pre><code>hello from class a. </code></pre><p>но с виртуальной функцией:</p><pre><code>#include<iostream> using namespace std; class a{ public: virtual void show(){ cout << " hello from class a"; } }; class b :public a{ public: virtual void show(){ cout << " hello from class b"; } }; int main(){ a *a1 = new b; a1->show(); } </code></pre><p>результат будет:</p><pre><code>hello from class b. </code></pre><p>следовательно, с помощью виртуальной функции вы можете достичь полиморфизма во время выполнения.</p>

<p>вы должны различать перегрузку и перегрузку. без ключевого слова <code>virtual</code> вы перегружаете только метод базового класса. это ничего не значит, кроме сокрытия. допустим, у вас есть базовый класс <code>base</code> и производный класс <code>specialized</code>, которые оба реализуют <code>void foo()</code>. теперь у вас есть указатель на <code>base</code>, указывающий на экземпляр <code>specialized</code>. когда вы вызываете <code>foo()</code> для него, вы можете наблюдать разницу, которую делает <code>virtual</code>: если метод виртуальный, будет использоваться реализация <code>specialized</code>, если он отсутствует, будет выбрана версия из <code>base</code>. лучше никогда не перегружать методы из базового класса. создание метода, не являющегося виртуальным, позволяет его автору сказать, что его расширение в подклассах не предназначено.</p>

<p>я хотел бы добавить еще одно использование виртуальной функции, хотя она использует ту же концепцию, что и приведенные выше ответы, но, думаю, ее стоит упомянуть.</p><p><strong>виртуальный разрушитель</strong></p><p>рассмотрим эту программу ниже, не объявляя деструктор базового класса как виртуальный; память для кошки не может быть очищена.</p><pre><code>class animal { public: ~animal() { cout << "deleting an animal" << endl; } }; class cat:public animal { public: ~cat() { cout << "deleting an animal name cat" << endl; } }; int main() { animal *a = new cat(); delete a; return 0; } </code></pre><p><strong>результат:</strong></p><blockquote> <pre><code>deleting an animal </code></pre></blockquote><pre><code>class animal { public: virtual ~animal() { cout << "deleting an animal" << endl; } }; class cat:public animal { public: ~cat(){ cout << "deleting an animal name cat" << endl; } }; int main() { animal *a = new cat(); delete a; return 0; } </code></pre><p>результат:</p><blockquote> <pre><code>deleting an animal name cat deleting an animal </code></pre></blockquote>

<blockquote> <p>зачем нам нужны виртуальные методы в c++?</p> </blockquote><h2>быстрый ответ:</h2><ol> <li>это дает нам один из необходимых "ингредиентов"<sup>1</sup> для <em>объектно-ориентированное программирование</em>.</li> </ol><p>в bjarne stroustrup c++ программирование: принципы и практика, (14.3):</p><blockquote> <p>виртуальная функция предоставляет возможность определить функцию в базовом классе и иметь функцию с тем же именем и типом в производном классе, вызываемую, когда пользователь вызывает функцию базового класса. это часто называется <em>полиморфизм во время выполнения</em>, <em>динамическая диспетчеризация</em> или <em>диспетчеризация во время выполнения</em>, поскольку вызываемая функция определяется во время выполнения на основе тип используемого объекта.</p> </blockquote><ol start="2"> <li>это самая быстрая и эффективная реализация, если вам нужно <em>вызов виртуальной функции</em> <sup>2</sup>,.</li> </ol><blockquote> <p>для обработки виртуального вызова требуется одна или несколько частей данных, связанных с <em>производный объект</em> <sup>3</sup>, обычно это делается путем добавления адреса таблицы функций. эта таблица обычно называется <em>виртуальная таблица</em> или <em>таблица виртуальных функций</em>, а ее адрес часто называют <em>виртуальный указатель</em>. каждая виртуальная функция получает слот в виртуальной таблице. в зависимости от типа объекта (производного) вызывающего, виртуальная функция, в свою очередь, вызывает соответствующее переопределение.</p> </blockquote><hr><p><sup>1. использование наследования, полиморфизма во время выполнения и инкапсуляции является наиболее распространенным определением <em>объектно-ориентированного программирования</em>.</sup></p><p><sup>2. вы не можете кодировать функциональность, чтобы быть быстрее или использовать меньше памяти, используя другие языковые функции для выбора среди альтернатив во время выполнения. бьярне страуструп программирование на c++: принципы и практика. (14.3.1)</sup>,.</p><p><sup>3. что-то, чтобы сказать, какая функция действительно вызывается, когда мы вызываем базовый класс, содержащий виртуальную функцию.</sup></p>

<p>когда у вас есть функция в базовом классе, вы можете <code>redefine</code> или <code>override</code> в производном классе.</p><p><em> <strong>переопределение метода</strong> </em>: в производном классе дается новая реализация метода базового класса. <strong>не</strong> облегчить <code>dynamic binding</code>.</p><p><em> <strong>переопределение метода</strong> </em>: <code>redefining</code> a <code>virtual method</code> базового класса в производном классе. виртуальный метод <strong>облегчает динамическое связывание</strong>.</p><p>итак, когда вы сказали:</p><blockquote> <p>но ранее в книге, изучая базовое наследование, я смог переопределить базовые методы в производных классах без использования "виртуального".</p> </blockquote><p>вы не переопределяли его, так как метод в базовом классе не был виртуальным, скорее вы переопределяли его</p>

<p>у меня есть мой ответ в форме беседы, чтобы быть лучше прочитанным:</p><hr><p><strong> зачем нам нужны виртуальные функции? </strong></p><p>из-за полиморфизма.</p><p><strong> что такое полиморфизм? </strong></p><p>тот факт, что базовый указатель также может указывать на объекты производного типа.</p><p><strong> как это определение полиморфизма приводит к необходимости виртуальных функций? </strong></p><p>ну, через <em> раннее связывание </em>.</p><p><strong> что такое раннее связывание? </strong></p><p>раннее связывание (связывание во время компиляции) в c++ означает, что вызов функции фиксируется перед выполнением программы.</p><p><strong> так что ...? </strong></p><p>таким образом, если вы используете базовый тип в качестве параметра функции, компилятор распознает только базовый интерфейс, и если вы вызываете эту функцию с любыми аргументами из производных классов, он отсекается, что не должно происходить.</p><p><strong> если это не то, что мы хотим, почему это разрешено? </strong></p><p>потому что нам нужен полиморфизм!</p><p><strong> в чем тогда польза от полиморфизма? </strong></p><p>вы можете использовать указатель базового типа в качестве параметра отдельной функции, а затем во время выполнения вашей программы вы можете получить доступ к каждому из интерфейсов производного типа (например, к их функциям-членам) без каких-либо проблем, используя разыменование этой единственной функции. базовый указатель.</p><p><strong> я до сих пор не знаю, для чего нужны виртуальные функции ...! и это был мой первый вопрос! </strong></p><p>ну, это потому что ты задал свой вопрос слишком рано!</p><p><strong> зачем нам нужны виртуальные функции? </strong></p><p>предположим, что вы вызвали функцию с базовым указателем, у которого был адрес объекта из одного из его производных классов. как мы говорили об этом выше, во время выполнения этот указатель разыменовывается, но пока все хорошо, однако мы ожидаем, что метод (== функция-член) "из нашего производного класса" будет выполнен! однако в базовом классе уже определен тот же метод (с тем же заголовком), так почему ваша программа должна выбрать другой метод? другими словами, я имею в виду, как вы можете отличить этот сценарий от того, что мы обычно видели раньше?</p><p>краткий ответ "виртуальная функция-член в базе", и более длинный ответ: "на этом этапе, если программа видит виртуальную функцию в базовом классе, она знает (понимает), что вы пытаетесь использовать "полиморфизм" и т. д. переходит к производным классам (используя <a href="http://www.learncpp.com/cpp-tutorial/125-the-virtual-table/">v-table</a> , форма позднего связывания), чтобы найти <em> другой метод </em> с тем же заголовком, но с ожидаемой другой реализацией.</p><p><strong> почему другая реализация? </strong></p><p>ты с головой! иди почитай <a href="https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list">хорошая книга</a> !</p><p><strong> хорошо, подожди, подожди, подожди, зачем использовать базовые указатели, если он/она может просто использовать указатели производного типа? будь судьей, стоит ли вся эта головная боль? посмотрите на эти два фрагмента: </strong></p><p><strong> // 1: </strong></p><pre><code>parent* p1 = &boy; p1 -> task(); parent* p2 = &girl; p2 -> task(); </code></pre><p><strong> // 2: </strong></p><pre><code>boy* p1 = &boy; p1 -> task(); girl* p2 = &girl; p2 -> task(); </code></pre><p>хорошо, хотя я думаю, что <strong> 1 </strong> все же лучше, чем <strong> 2 </strong>, вы можно написать <strong> 1 </strong> так:</p><p>// 1:</p><pre><code>parent* p1 = &boy; p1 -> task(); p1 = &girl; p1 -> task(); </code></pre><p>и, кроме того, вы должны знать, что это все еще надуманное использование всего того, что я вам объяснил до сих пор. вместо этого, предположим, например, ситуацию, в которой у вас была функция в вашей программе, которая использовала методы из каждого из производных классов соответственно (getmonthbenefit ()):</p><pre><code>double totalmonthbenefit = 0; std::vector<centralshop*> mainshop = { &shop1, &shop2, &shop3, &shop4, &shop5, &shop6}; for(centralshop* x : mainshop){ totalmonthbenefit += x -> getmonthbenefit(); } </code></pre><p>теперь попробуйте переписать это, <em> без каких-либо головных болей! </em></p><pre><code>double totalmonthbenefit=0; shop1* branch1 = &shop1; shop2* branch2 = &shop2; shop3* branch3 = &shop3; shop4* branch4 = &shop4; shop5* branch5 = &shop5; shop6* branch6 = &shop6; totalmonthbenefit += branch1 -> getmonthbenefit(); totalmonthbenefit += branch2 -> getmonthbenefit(); totalmonthbenefit += branch3 -> getmonthbenefit(); totalmonthbenefit += branch4 -> getmonthbenefit(); totalmonthbenefit += branch5 -> getmonthbenefit(); totalmonthbenefit += branch6 -> getmonthbenefit(); </code></pre><p>и на самом деле, это может быть еще и надуманным примером!</p>

<p>это помогает, если вы знаете основные механизмы. c++ формализует некоторые методы кодирования, используемые программистами c, "классы" заменяются на "оверлеи" - структуры с общими разделами заголовка будут использоваться для обработки объектов различных типов, но с некоторыми общими данными или операциями. обычно базовая структура оверлея (общая часть) имеет указатель на таблицу функций, которая указывает на различный набор процедур для каждого типа объекта. c++ делает то же самое, но скрывает механизмы, то есть <code>ptr->func(...)</code> c++, где func является виртуальным, поскольку c будет <code>(*ptr->func\_table[func\_num])(ptr,...)</code>, где изменения между производными классами являются содержимым func\_table. [не виртуальный метод ptr-> func () просто переводится как mangled\_func (ptr, ..).]</p><p>в результате вам нужно понять базовый класс только для вызова методов производного класса, т. е. если подпрограмма понимает класс a, вы можете передать ей указатель производного класса b, тогда будут вызваны виртуальные методы. из b, а не a, так как вы проходите через таблицу функций b указывает на.</p>

<p>ключевое слово virtual сообщает компилятору, что он не должен выполнять раннее связывание. вместо этого он должен автоматически установить все механизмы, необходимые для выполнения позднего связывания. для этого типичный компилятор1 создает одну таблицу (называемую vtable) для каждого класса, содержащего виртуальные функции. компилятор помещает адреса виртуальных функций для этого конкретного класса в vtable. в каждом классе с виртуальными функциями он тайно размещает указатель, называемый vpointer (сокращенно vptr), который указывает на vtable для этого объекта. когда вы делаете виртуальный вызов функции через указатель базового класса, компилятор незаметно вставляет код для извлечения vptr и поиска адреса функции в vtable, вызывая, таким образом, правильную функцию и вызывая позднее связывание.</p><p>подробнее в этой ссылке <a href="http://cplusplusinterviews.blogspot.sg/2015/04/virtual-mechanism.html">http://cplusplusinterviews.blogspot.sg/2015/04/virtual-mechanism.html</a> </p>

<p>ключевое слово <strong>virtual</strong> заставляет компилятор выбирать реализацию метода, определенную в классе <strong>объекта</strong>, а не в классе <strong>указателя</strong>.</p><pre><code>shape *shape = new triangle(); cout << shape->getname(); </code></pre><p>в приведенном выше примере shape :: getname будет вызываться по умолчанию, если только getname () не определен как виртуальный в базовом классе shape. это заставляет компилятор искать реализацию getname () в классе triangle, а не в классе shape.</p><p><strong>виртуальная таблица</strong> - это механизм, в котором компилятор отслеживает различные реализации подклассов виртуальных методов. это также называется динамической диспетчеризацией, и <em> есть </em> некоторые накладные расходы, связанные с ней.</p><p>наконец, почему виртуальная среда даже необходима в c++, почему бы не сделать ее поведение по умолчанию, как в java?</p><ol> <li>c++ основан на принципах "нулевые накладные расходы" и "платите за то, что вы используете". так что он не пытается выполнить динамическую диспетчеризацию для вас, если вам это не нужно.</li> <li>чтобы обеспечить больше контроля над интерфейсом. делая функцию не виртуальной, интерфейс/абстрактный класс может управлять поведением во всех его реализациях.</li> </ol>

<p>зачем нам нужны виртуальные функции?</p><p>виртуальные функции избегают ненужной проблемы с типизацией, и некоторые из нас могут спорить, зачем нам нужны виртуальные функции, когда мы можем использовать указатель производного класса для вызова функции, специфичной для производного класса! ответ таков: это сводит на нет всю идею наследования в большой системе развитие, где наличие одного объекта указателя базового класса очень желательно.</p><p>давайте сравним ниже две простые программы, чтобы понять важность виртуальных функций:</p><p>программа без виртуальных функций:</p><pre><code>#include <iostream> using namespace std; class father { public: void get\_age() {cout << "fathers age is 50 years" << endl;} }; class son: public father { public : void get\_age() { cout << "son`s age is 26 years" << endl;} }; int main(){ father *p\_father = new father; son *p\_son = new son; p\_father->get\_age(); p\_father = p\_son; p\_father->get\_age(); p\_son->get\_age(); return 0; } </code></pre><p>результат:</p><pre><code>fathers age is 50 years fathers age is 50 years son`s age is 26 years </code></pre><p>программа с виртуальной функцией:</p><pre><code>#include <iostream> using namespace std; class father { public: virtual void get\_age() {cout << "fathers age is 50 years" << endl;} }; class son: public father { public : void get\_age() { cout << "son`s age is 26 years" << endl;} }; int main(){ father *p\_father = new father; son *p\_son = new son; p\_father->get\_age(); p\_father = p\_son; p\_father->get\_age(); p\_son->get\_age(); return 0; } </code></pre><p>результат:</p><pre><code>fathers age is 50 years son`s age is 26 years son`s age is 26 years </code></pre><p>внимательно проанализировав оба выхода, можно понять важность виртуальных функций.</p>

<p>что касается эффективности, <em>виртуальные функции</em> несколько менее эффективны, чем функции раннего связывания.</p><p>"этот механизм виртуального вызова можно сделать почти таким же эффективным, как и механизм" обычного вызова функции "(в пределах 25%). его служебная память занимает один указатель в каждом объекте класса с виртуальными функциями плюс один vtbl для каждого такого класса" [- <em>тур по c++</em> бьярне страуструп]</p>

<p>вот полный пример, который иллюстрирует, почему используется виртуальный метод.</p><pre><code>#include <iostream> using namespace std; class basic { public: virtual void test1() { cout << "test1 from basic." << endl; } virtual ~basic(){}; }; class varianta : public basic { public: void test1() { cout << "test1 from varianta." << endl; } }; class variantb : public basic { public: void test1() { cout << "test1 from variantb." << endl; } }; int main() { basic *object; varianta *vobjecta = new varianta(); variantb *vobjectb = new variantb(); object=(basic *) vobjecta; object->test1(); object=(basic *) vobjectb; object->test1(); delete vobjecta; delete vobjectb; return 0; } </code></pre>

<h1>ответ ооп: <em> полиморфизм подтипа </em></h1><p>в c++ виртуальные методы необходимы для реализации <strong> полиморфизма </strong>, точнее <strong> подтипа </strong> или <strong> полиморфизм подтипа </strong>, если вы применяете определение из википедии.</p><p>wikipedia, subtyping, 2019-01-09: в теории языка программирования подтип (также полиморфизм подтипов или полиморфизм включения) является формой полиморфизма типов, в которой подтип является типом данных, который по некоторому понятию связан с другим типом данных (супертипом). заменяемости, то есть элементы программы, обычно подпрограммы или функции, написанные <strong> для работы с элементами супертипа </strong>, также могут работать с элементами подтипа.</p><p>примечание. подтип означает базовый класс, а подтип - унаследованный класс.</p><h2>дальнейшее чтение относительно <em> подтип полиморфизм </em></h2><ul> <li> <a href="https://en.wikipedia.org/wiki/subtyping">https://en.wikipedia.org/wiki/subtyping</a> </li> <li> <a href="https://en.wikipedia.org/wiki/polymorphism\_(computer\_science)#subtyping">https://en.wikipedia.org/wiki/polymorphism\_ (computer\_science) #subtyping</a> </li> </ul><h1>технический ответ: <em> динамическая отправка </em></h1><p>если у вас есть указатель на базовый класс, то вызов метода (который объявлен как виртуальный) будет отправлен методу фактического класса создаваемого объекта. вот как <em> подтип полиморфизм </em> реализуется в c++.</p><h2>дальнейшее чтение полиморфизм в c++ и <em> dynamic dispatch </em></h2><ul> <li> <a href="http://www.cplusplus.com/doc/tutorial/polymorphism/">http://www.cplusplus.com/doc/tutorial/polymorphism/</a> </li> <li> <a href="https://en.cppreference.com/w/cpp/language/virtual">https://en.cppreference.com/w/cpp/language/virtual</a> </li> </ul><h1><strong> ответ реализации: создает <em> запись vtable </em> </strong></h1><p>для каждого модификатора, "виртуального" в методах, компиляторы c++ обычно создают запись в vtable класса, в котором объявлен метод. вот как обычный компилятор c++ реализует <em> dynamic dispatch </em>.</p><h2>дальнейшее чтение vtables</h2><ul> <li> <a href="https://en.wikipedia.org/wiki/virtual\_method\_table">https://en.wikipedia.org/wiki/virtual\_method\_table</a> </li> </ul><hr><p><strong> пример кода </strong></p><pre><code>#include <iostream> using namespace std; class animal { public: virtual void maketypicalnoise() = 0; // no implementation needed, for abstract classes virtual ~animal(){}; }; class cat : public animal { public: virtual void maketypicalnoise() { cout << "meow!" << endl; } }; class dog : public animal { public: virtual void maketypicalnoise() { // needs to be virtual, if subtype polymorphism is also needed for dogs cout << "woof!" << endl; } }; class doberman : public dog { public: virtual void maketypicalnoise() { cout << "woo, woo, woow!"; cout << " ... "; dog::maketypicalnoise(); } }; int main() { animal* apobject[] = { new cat(), new dog(), new doberman() }; const int cnanimals = sizeof(apobject)/sizeof(animal*); for ( int i = 0; i < cnanimals; i++ ) { apobject[i]->maketypicalnoise(); } for ( int i = 0; i < cnanimals; i++ ) { delete apobject[i]; } return 0; } </code></pre><hr><p><strong> вывод примера кода </strong></p><pre><code>meow! woof! woo, woo, woow! ... woof! </code></pre><hr><p><strong> диаграмма классов uml примера кода </strong></p><p> <a href="https://i.stack.imgur.com/dprca.png"><img src="https://i.stack.imgur.com/dprca.png" alt="uml class diagram of code example"></a> </p>

<p>виртуальные методы используются в дизайне интерфейса. например, в windows есть интерфейс под названием iunknown, как показано ниже:</p><pre><code>interface iunknown { virtual hresult queryinterface (refiid riid, void **ppvobject) = 0; virtual ulong addref () = 0; virtual ulong release () = 0; }; </code></pre><p>эти методы оставлены пользователю интерфейса для реализации. они необходимы для создания и уничтожения определенных объектов, которые должны наследовать iunknown. в этом случае среда выполнения знает о трех методах и ожидает, что они будут реализованы при вызове. таким образом, в некотором смысле они действуют как договор между самим объектом и тем, что использует этот объект.</p>

<p>я думаю, что вы имеете в виду тот факт, что когда метод объявлен виртуальным, вам не нужно использовать ключевое слово "virtual" в переопределениях.</p><pre><code>class base { virtual void foo(); }; class derived : base { void foo(); // this is overriding base::foo }; </code></pre><p>если вы не используете 'virtual' в объявлении base для foo, то derived's foo просто будет его скрывать.</p>

<p>вот объединенная версия кода c++ для первых двух ответов.</p><pre><code>#include <iostream> #include <string> using namespace std; class animal { public: #ifdef virtual virtual string says() { return "??"; } #else string says() { return "??"; } #endif }; class dog: public animal { public: string says() { return "woof"; } }; string func(animal *a) { return a->says(); } int main() { animal *a = new animal(); dog *d = new dog(); animal *ad = d; cout << "animal a says\t\t" << a->says() << endl; cout << "dog d says\t\t" << d->says() << endl; cout << "animal dog ad says\t" << ad->says() << endl; cout << "func(a) :\t\t" << func(a) << endl; cout << "func(d) :\t\t" << func(d) << endl; cout << "func(ad):\t\t" << func(ad)<< endl; } </code></pre><p>два разных результата:</p><p><strong> без #define virtual </strong> он связывается во время компиляции. animal * ad и func (animal *) - все они указывают на метод animal () с названием ().</p><pre><code>$ g++ virtual.cpp -o virtual $ ./virtual animal a says ?? dog d says woof animal dog ad says ?? func(a) : ?? func(d) : ?? func(ad): ?? </code></pre><p><strong> с помощью #define virtual </strong> он связывается во время выполнения. dog * d, animal * ad и func (animal *) указывают/ссылаются на метод say () dog, поскольку dog является их типом объекта. если метод [dog's say () "woof"] не определен, то он будет первым, который ищется в дереве классов, то есть производные классы могут переопределять методы своих базовых классов [animal's say ()].</p><pre><code>$ g++ virtual.cpp -d virtual -o virtual $ ./virtual animal a says ?? dog d says woof animal dog ad says woof func(a) : ?? func(d) : woof func(ad): woof </code></pre><p>интересно отметить, что все атрибуты класса (данные и методы) в <a href="https://docs.python.org/3/tutorial/classes.html">python фактически являются виртуальными</a> . поскольку все объекты создаются динамически во время выполнения, нет объявления типа или необходимости в ключевом слове virtual. ниже приведена версия кода python:</p><pre><code>class animal: def says(self): return "??" class dog(animal): def says(self): return "woof" def func(a): return a.says() if \_\_== "\_\_main\_\_": a = animal() d = dog() ad = d # dynamic typing by assignment print("animal a says\t\t{}".format(a.says())) print("dog d says\t\t{}".format(d.says())) print("animal dog ad says\t{}".format(ad.says())) print("func(a) :\t\t{}".format(func(a))) print("func(d) :\t\t{}".format(func(d))) print("func(ad):\t\t{}".format(func(ad))) </code></pre><p>результат:</p><pre><code>animal a says ?? dog d says woof animal dog ad says woof func(a) : ?? func(d) : woof func(ad): woof </code></pre><p>который идентичен виртуальному определению c++. обратите внимание, что <strong> <em> d </em> </strong> и <strong> <em> ad </em> </strong> - две разные переменные-указатели, ссылающиеся на один и тот же экземпляр dog. выражение (ad is d) возвращает true, и их значения одинаковы <<strong> main </strong>. объект dog в 0xb79f72cc>.</p>

<p>вы знакомы с указателями функций? виртуальные функции представляют собой аналогичную идею, за исключением того, что вы можете легко привязать данные к виртуальным функциям (в качестве членов класса). привязать данные к указателям на функцию не так просто. для меня это главное концептуальное отличие. многие другие ответы здесь просто говорят "потому что ... полиморфизм!"</p>

<p>суть в том, что виртуальные функции облегчают жизнь. давайте использовать некоторые идеи м. перри и опишем, что произойдет, если у нас не будет виртуальных функций, а вместо этого мы сможем использовать только указатели на функции-члены. в обычной оценке без виртуальных функций имеем:</p><pre><code> class base { public: void helloworld() { std::cout << "hello world!"; } }; class derived: public base { public: void helloworld() { std::cout << "greetings world!"; } }; int main () { base hwone; derived hwtwo = new derived(); base->helloworld(); //prints "hello world!" derived->helloworld(); //prints "hello world!" </code></pre><p>итак, это то, что мы знаем. теперь давайте попробуем сделать это с помощью указателей на функции-члены:</p><pre><code> #include <iostream> using namespace std; class base { public: void helloworld() { std::cout << "hello world!"; } }; class derived : public base { public: void displayhwderived(void(derived::*hwbase)()) { (this->*hwbase)(); } void(derived::*hwbase)(); void helloworld() { std::cout << "greetings world!"; } }; int main() { base* b = new base(); //create base object b->helloworld(); // hello world! void(derived::*hwbase)() = &derived::helloworld; //create derived member function pointer to base function derived* d = new derived(); //create derived object. d->displayhwderived(hwbase); //greetings world! char ch; cin >> ch; } </code></pre><p>хотя мы можем делать некоторые вещи с помощью указателей на функции-члены, они не так гибки, как виртуальные функции. сложно использовать указатель на функцию-член в классе; указатель на функцию-член почти, по крайней мере в моей практике, всегда должен вызываться в основной функции или из функции-члена, как в приведенном выше примере.</p><p>с другой стороны, виртуальные функции, хотя они могут иметь некоторые накладные расходы на указатель на функцию, значительно упрощают ситуацию.</p><p>правка: есть еще один метод, который похож на eddietree: <a href="https://stackoverflow.com/questions/17344759/c-virtual-function-vs-member-function-pointer-performance-comparison">виртуальная функция c ++ против указателя на функцию-член (сравнение производительности)</a> .</p>

<p>нам нужны виртуальные методы для поддержки "полиморфизма времени выполнения". когда вы ссылаетесь на объект производного класса, используя указатель или ссылку на базовый класс, вы можете вызвать виртуальную функцию для этого объекта и выполнить версию функции производного класса.</p>