StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
2241846
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2010-02-11T02:31:32.103
FavoriteCount
0
LastActivityDate
2016-09-17T05:03:03
LastEditDate
2016-09-17T05:03:03
LastEditorUserId
2648679
OwnerUserId
46571
ParentId
2238928
PostTypeId
2
Score
2
ViewCount
0
LastEditorDisplayName
text
Body
ABSTRACT In this paper, we discuss virtual functions in C++. Part zero explains how virtual functions are declared and overridden. Part one attempts (and perhaps fails) to explain how virtual functions are implemented. Part two is a sample program that uses the example classes defined in parts zero and one. Part three is the classic animal example given in every virtual function - polymorphism tutorial. PART ZERO A method of a class is said to be virtual if and only if its declared to be so. <pre><code>class my_base { public: void non_virtual_test() { cout << 4 << endl; } // non-virtual virtual void virtual_test() { cout << 5 << endl; } // virtual }; </code></pre> (Of course, I am assuming the programmer did not previously do anything like <code>#define virtual</code>.) A class that redeclares and re-implements a non-virtual method of one of its bases is said to overload that method. A class that redeclares and re-implements a virtual method of one of its bases is said to override that method. <pre><code>class my_derived : public my_base { public: void non_virtual_test() { cout << 6 << endl; } // overloaded void virtual_test() { cout << 7 << endl; } // overriden }; </code></pre> PART ONE When the compiler detects a class has virtual methods, it automatically adds a virtual method table (also known as vtable) to the class' memory layout. The result is similar to what would have been generated from compiling this code: <pre><code>class my_base { //<vtable> // The vtable is actually a bunch of member function pointers protected: void (my_base::*virtual_test_ptr)(); //</vtable> // The actual implementation of the virtual function // is hidden from the rest of the program. private: void virtual_test_impl() { cout << 5 << endl; } // Initializing the real_virtual_test pointer in the vtable. public: my_base() : virtual_test_ptr(&my_base::virtual_test_impl) {} public: void non_virtual_test() { cout << 4 << endl; } // The interface of the virtual function is a wrapper // around the member function pointer. inline void virtual_test() { *virtual_test_ptr(); } }; </code></pre> When the compiler detects a class has overridden a virtual method, it replaces its associated entry in the vtable. The result is similar to what would have been generated from compiling this code: <pre><code>class my_derived : public my_base { // The actual implementation of the virtual function // is hidden from the rest of the program. private: void virtual_test_impl() { cout << 7 << endl; } // Initializing the real_virtual_test pointer in the vtable. public: my_derived() : virtual_test_ptr(&my_derived::virtual_test_impl) {} public: void non_virtual_test() { cout << 6 << endl; } }; </code></pre> PART TWO Now that it's clear that virtual functions are implemented using vtables, which are nothing but a bunch of function pointers, it should be clear what this code does: <pre><code>#include <iostream> using namespace std; class my_base { public: void non_virtual_test() { cout << 4 << endl; } virtual void virtual_test() { cout << 5 << endl; } }; class my_derived : public my_base { public: void non_virtual_test() { cout << 6 << endl; } void virtual_test() { cout << 7 << endl; } } int main() { my_base* base_obj = new my_derived(); // This outputs 4, since my_base::non_virtual_test() gets called, // not my_derived::non_virtual_test(). base_obj->non_virtual_test(); // This outputs 7, since the vtable pointer points to // my_derived::virtual_test(), not to my_base::virtual_test(). base_obj->virtual_test(); // We shall not forget // there was an object that was pointed by base_obj // who happily lived in the heap // until we killed it. delete base_obj; return 0; } </code></pre> PART THREE Since no virtual function example is complete without an example with animals... <pre><code>#include <iostream> using namespace std; class animal { public: virtual void say_something() { cout << "I don't know what to say." << endl << "Let's assume I can growl." << endl; } /* A more sophisticated version would use pure virtual functions: * * virtual void say_something() = 0; */ }; class dog : public animal { public: void say_something() { cout << "Barf, barf..." << endl; } }; class cat : public animal { public: void say_something() { cout << "Meow, meow..." << endl; } }; int main() { animal *a1 = new dog(); animal *a2 = new cat(); a1->say_something(); a2->say_something(); } </code></pre>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POwhy do we actually have virtual functions?
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USAbhinav Gauniyal
UserOwnerUserId
1. USpyon
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POwhy do we actually have virtual functions?
 singulars
 PostTypePostTypeId
 PTQuestion
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. This table or related slice is empty.
CommentsPostId
1. This table or related slice is empty.

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.