virtual

I have to load modules as dlls dynamically at runtime as they are not known ahead of time, just that they conform to a class interface. What I noticed is that after I catch an exception thrown by the dll (in the main program in the main thread), the right destructors are called and the modules destroyed and dll's unloaded, but then as the } at the end of the catch block is reached by the Visual Studio C++ debugger when stepping line by line, I get another exception which crashes the program with First-chance exception at 0x68ad2377 (msvcr90d.dll) in xxxxx.exe: 0xC0000005: Access violation

Refer to this question: Hide virtual function with non-virtual override And this question: override on non-virtual functions A function that overrides a virtual function is virtual too, even though it's not explicitly declared virtual. My technical question is: Is there away to make that overriding function non-virtual (and applies that to classes lower in the hierarchy)? In other words, can I turn the "virtuality" off? Obviously we can override a non-virtual function with a virtual function. Can we do the opposite, i.e. to override a virtual function with a non-virtual function? You are

I was reading the Wikipedia article on virtual inheritance. I followed the whole article but I could not really follow the last paragraph This is implemented by providing Mammal and WingedAnimal with a vtable pointer (or "vpointer") since, e.g., the memory offset between the beginning of a Mammal and of its Animal part is unknown until runtime. Thus Bat becomes (vpointer,Mammal,vpointer,WingedAnimal,Bat,Animal). There are two vtable pointers, one per inheritance hierarchy that virtually inherits Animal. In this example, one for Mammal and one for WingedAnimal. The object size has therefore

I wrote the following piece of code to test my understanding of virtual inheritance. Apparently, I still don't get it fully. Here is my code (followed by my question): #include <iostream> #include <vector> using namespace std; class Foo { public: virtual void foo(); void foo2(); }; void Foo::foo() { cout << "In FOO - foo 1" << endl; foo2(); } void Foo::foo2() { cout << "In FOO - foo 2" << endl; } class Bar : public Foo { public: void foo(); void foo2(); }; void Bar::foo() { cout << "In BAR - foo 1" << endl; foo2(); } void Bar::foo2() { cout << "In BAR - foo 2" << endl; } int main() { Foo* f =

I would like to ask you on what does the offset of the table of virtual functions for a class depend? I mean, from what I've read it at least depends on compiler, but does it varies from class to class? Edit: by offset I mean the position of the table relative to the address of the owner object. Edit: example code: void **vtable = *((void***)(((char*)object)+offset)); int **ivtable=(int **)vtable; void* firstFunction = (void*) ivtable[0]; There is certainly a dependency on the exact class. Remember that C++ has multiple inheritance (MI). The consequence of MI is that a single object may have

I have following code: #include <iostream> using namespace std; class Child1 { int i; }; class Child2 : public Child1 { int j; }; class Base1 { public: virtual Child1& getChildren() { cout << "Children1" << endl; return children; } private: Child1 children; }; class Base2 : public Base1 { public: virtual Child2& getChildren() { cout << "Children2" << endl; return children; } private: Child2 children; }; This code compiles fine but when I change the return type of getChildren() from reference type to object type in either or both Base1 and Base2 (e.g. virtual Child2 getChildren() , I get the