pure-virtual

Say we have a class inheriting from two base classes (multiple inheritance). Base class A is abstract, declaring a pure virtual function foo , the other base class B declares and implements a function foo of the very same signature. struct A { virtual void foo(int i) = 0; }; struct B { virtual void foo(int i) {} }; struct C : public A, public B {}; I want to use the implementation of foo from base class B in my derived class C . However, if I do not implement the function foo a second time in my derived class C , I cannot instantiate any object of it (it remains abstract). Virtual inheritance

I teach a C++ programming class and I've seen enough classes of errors that I have a good feeling for how to diagnose common C++ bugs. However, there's one major type of error for which my intuition isn't particularly good: what programming errors cause calls to pure virtual functions? The most common error I've seen that causes this is calling a virtual function from a base class constructor or destructor. Are there any others I should be aware of when helping debug student code? "The most common error I've seen that causes this is calling a virtual function from a base class constructor or

I understand why this is happening, but I'm stuck trying to resolve it...here is what my code is doing when the error is generated (thus, leading to a crash) when my program exits... pure virtual method called SomeClass::~SomeClass() { BaseClassObject->SomePureVirtualMethod(this); } void DerivedClass::SomePureVirtualMethod(SomeClass* obj) { //Do stuff to remove obj from a collection } I never have a call to new SomeClass but I have a QList<SomeClass*> which I append SomeClass* objects to. The purpose of this destructor in SomeClass is to tell DerivedClass to remove a specific instance of

The following code compiles on a wide range of gcc and clang versions - when compiled and run with gcc 5.3.1, it prints A() then aborts with a pure virtual call error. #include <stdio.h> class A { public: A() { printf("A()\n"); } virtual void b() const = 0; }; int main() { const A& a{}; a.b(); return 0; } I realise binding a reference to a temporary is not ideal (though I think this case is covered by some sort of lifetime extension) - but it also works when trying to call a method that takes a const reference like: Foo({}); For convenience here's an example of it compiling with clang 3.2:

While compiling on GCC I get the error: pure-specifier on function-definition , but not when I compile the same code using VS2005. class Dummy { //error: pure-specifier on function-definition, VS2005 compiles virtual void Process() = 0 {}; }; But when the definition of this pure virtual function is not inline, it works: class Dummy { virtual void Process() = 0; }; void Dummy::Process() {} //compiles on both GCC and VS2005 What does the error means? Why cannot I do it inline? Is it legal to evade the compile issue as shown in the second code sample? Ok, I've just learned something. A pure