Your SlideShare is downloading. ×
Virtual Functions
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Virtual Functions

1,418
views

Published on

Virtual Functions support dynamic binding and object-oriented programming. A class that declares or inherits a virtual function is called a polymorphic class.

Virtual Functions support dynamic binding and object-oriented programming. A class that declares or inherits a virtual function is called a polymorphic class.

Published in: Technology

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,418
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
40
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Virtual Functions By Roman Okolovich
  • 2. ISO/IEC 14882:1998(E). International Standard. First Edition 1998-09-01  10.3 Virtual Functions  10.3.1 Virtual Functions support dynamic binding and object- oriented programming. A class that declares or inherits a virtual function is called a polymorphic class.  If a virtual member function vf is declared in a class Base and in a class Derived, derived directly or indirectly from Base, a member function vf with the same name and same parameter list as Base::vf is declared, then Derived::vf is also virtual (whether or not it is so declared) and it overrides Base::vf. For convenience we say that any virtual function overrides itself.  C++ standard does not say anything about implementation of virtual functions. The compilers are free to implement it by any (correct) mechanism. However, practically majority of the compilers that exist today implement virtual functions using vtable mechanism.
  • 3. Example class Transaction // base class for all transactions { public: Transaction(); virtual void logTransaction() const = 0; // make type-dependent log entry //... }; Transaction::Transaction() // implementation of base class constructor { //... logTransaction(); // as final action, log this transaction } class BuyTransaction : public Transaction // derived class { public: virtual void logTransaction() const; // how to log transactions of this type //... }; class SellTransaction : public Transaction // derived class { public: virtual void logTransaction() const; // how to log transactions of this type //... }; BuyTransaction b;
  • 4. General classes class A at the code generation { level: int foo(); struct D { int a1; int a1; int a2; int a2; int a3; int a3; }; int b1; class B int b2; { int b3; int bar(); int d1; int d2; int b1; int d3; int b2; }; int b3; ?foo@A@@ModuleA@(A* pThis); }; ?bar@B@@ModuleB@(B* pThis); class D : public A, public B ?foo@D@@ModuleD@(D* pThis); { int foo(); D::D() {} int d1; int d2; A::foo( (A*)&D ); int d3; }; A* pA = new D; pA->foo();
  • 5. Virtual Functions class Vbase at the code generation level: struct Vbase { { static struct VbTable virtual void foo(); void* m_pVptr; //  { virtual void bar(); int a1; void (*foo)(); }; int a1; ?foo@Vbase@@ModuleVb@(Vbase* pThis); void (*bar)(); ?bar@Vbase@@ModuleVb@(Vbase* pThis); }; }; cBase.m_pVptr[foo_idx](&cBase); Vbase cBase; struct V { cBase.foo(); void* m_pVptr; //  static struct VTable int a1; { int b1; void (*foo)(); }; void (*bar)(); class V : public Vbase void (*dir)(); ?foo@V@@ModuleV@(V* pThis); void (*alpha)(); { ?dir@V@@ModuleV@(V* pThis); ?alpha@V@@ModuleV@(V* pThis); }; void foo(); virtual void dir(); virtual void alpha(); int b1; };
  • 6. Class Constructors class Vbase at the code generation level: { Vbase::Vbase virtual void foo(); { virtual void bar(); m_pVptr->[0] = void(*foo)(); virtual void dir() = 0; m_pVptr->[1] = void(*bar)(); void do() m_pVptr->[2] = 0; { }; foo(); } int a1; V::V : Vbase() { }; m_pVptr->[0] = void(*foo)(); m_pVptr->[1] = void(*Vbase::bar)(); m_pVptr->[2] = void(*dir)(); class V : public Vbase m_pVptr->[3] = void(*alpha)(); { Vbase::m_pVptr = m_pVptr; void foo(); } virtual void dir(); virtual void alpha(); V objV; int b1; objV.do(Vbase* this) }; { this->foo(); // this  Vbase // foo(this); }
  • 7. __declspec(novtable) class __declspec(novtable) IBase at the code generation level: { virtual void foo() = 0; IBase::IBase virtual void bar() = 0; { virtual void dir() = 0; //m_pVptr }; // will not be initialized at all class V : public IBase }; { void foo(); virtual void bar(); virtual void dir(); int b1; }; class __declspec(novtable) A { public: A() {}; virtual void func1(){ std::cout << 1; } virtual void func2(){ std::cout << 2; } virtual void func3(){ std::cout << 3; } }; class A1 : public A { public: // no func1, func2, or func3 };
  • 8. Default values #include <iostream> at the code generation level: using namespace std; struct VA { class A { void* m_pVptr; }; public: virtual void Foo(int n = 10) { ?foo@A@@ModuleA@(VA* pThis, 10); cout << "A::Foo, n = " << n << endl; struct VB } { void* m_pVptr; }; }; class B : public A { ?foo@B@@ModuleB@(VB* pThis, 20); public: virtual void Foo(int n = 20) { cout << "B::Foo, n = " << n << endl; A * pa = new B(); } pa->m_pVptr[fooID]((VA*)&B, XXX); }; Answer: 10 int main() { A * pa = new B(); pa->Foo(); return 0; }
  • 9. Things to Remember  Don't call virtual functions during construction or destruction, because such calls will never go to a more derived class than that of the currently executing constructor or destructor.
  • 10. References  PDF: Working draft, Standard for Programming Language C++

×