virtual

Because of my device I can't use virtual functions. Suppose I have: class Base { void doSomething() { } }; class Derived : public Base { void doSomething() { } }; // in any place { Base *obj = new Derived; obj->doSomething(); } the obj->doSomething() will call just the Base::doSomething() Is there a way with Base *obj , to call the doSomething of the Derived ? I know I can just put a virtual before doSomething() of Base it solve the problem, but I'm limited by my device, the compiler doesn't support it. paxos1977 You could down cast the base class pointer to the derived class and call the

Consider the following C++ code: class A { public: virtual void f()=0; }; int main() { void (A::*f)()=&A::f; } If I'd have to guess, I'd say that &A::f in this context would mean "the address of A's implementation of f()", since there is no explicit seperation between pointers to regular member functions and virtual member functions. And since A doesn't implement f(), that would be a compile error. However, it isn't. And not only that. The following code: void (A::*f)()=&A::f; A *a=new B; // B is a subclass of A, which implements f() (a->*f)(); will actually call B::f. How does it happen? Here

When discussing sealed classes, the term "virtual function table" is mentioned quite frequently. What exactly is this? I read about a method table a while ago (I don't remember the purpose of the purpose of this either) and a google/search on here brings up C++ related results. Thanks The C# virtual function table works basically the same as the C++ one, so any resources which describe how the C++ virtual function table works should help you pretty well with the C# one as well. For example, Wikipedia's description is not bad. The "virtual function table" or "virtual method table" is a list of

This is an online C++ test question, which has been done. #include<iostream> using namespace std; class A { }; class B { int i; }; class C { void foo(); }; class D { virtual void foo(); }; class E { int i ; virtual void foo(); }; class F { int i; void foo(); }; class G { void foo(); int i; void foo1(); }; class H { int i ; virtual void foo(); virtual void foo1(); }; int main() { cout <<"sizeof(class A) : " << sizeof(A) << endl ; cout <<"sizeof(class B) adding the member int i : " << sizeof(B) << endl ; cout <<"sizeof(class C) adding the member void foo() : " << sizeof(C) << endl ; cout <<

Coming from a C++ background, this came as a surprise to me. In C++ it's good practice to make virtual functions private. From http://www.gotw.ca/publications/mill18.htm : "Guideline #2: Prefer to make virtual functions private." I also quote Eric Lippert's blog, from Knights-knaves-protected-and-internal : Private virtual methods are illegal in C#, which irks me to no end. I would totally use that feature if we had it. I understand that in C#, you wouldn't be able to override a private virtual method in a derived (but not nested) class. Why is this the case? In C++ the access specifier has

Question is as stated in the title: What are the performance implications of marking methods / properties as virtual? Note - I'm assuming the virtual methods will not be overloaded in the common case; I'll usually be working with the base class here. Virtual functions only have a very small performance overhead compared to direct calls. At a low level, you're basically looking at an array lookup to get a function pointer, and then a call via a function pointer. Modern CPUs can even predict indirect function calls reasonably well in their branch predictors, so they generally won't hurt modern