pure-virtual

I'm using boost.python to make python-modules written in c++. I have some base class with pure virtual functions which I have exported like this: class Base { virtual int getPosition() = 0; }; boost::python::class_<Base>("Base") .def("GetPosition", boost::python::pure_virtual(&Base::getPosition)); in Python I have code: class Test(Base): def GetPosition(self): return 404 Test obj obj.GetPosition() RuntimeError: Pure virtual function called What's wrong? This error happens when a constructor or a destructor directly or indirectly calls a pure virtual member. (Remember that during constructor

I am getting random R6025 - pure virtual function call errors at random times when using this custom c# RTD client for ThinkOrSwim. How can I a) debug it to find out what's going wrong, and b) fix it? When windows pops up the message box saying there is an error, the code keeps running in the backgroud and no exceptions are thrown. But when I click OK on the message box, windows shuts the application down. Here is a snippet of the code requesting RTD data: var tosClassId = new Guid(Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Tos.RTD\CLSID", "", null).ToString()); var rtdClient =

UPD . There is a mark that it is a duplicate of this question . But in that question OP asks HOW to use default to define pure virtual destructor. This question is about what the difference . In C++ (latest standard if possible) what the real difference between defining pure virtual destructor with empty body implementation and just a empty body (or default)? Variant 1: class I1 { public: virtual ~I1() {} }; Variant 2.1: class I21 { public: virtual ~I21() = 0; }; I21::~I21() {} Variant 2.2: class I22 { public: virtual ~I22() = 0; }; I22::~I22() = default; Update I found at least 1 difference

I think virtual alone is generally sufficient. Is there another reason to make it pure virtual than to force derived classes to implement their own destructor? I mean if you allocate something in your class' constructor you should impement your own destructor - if your class is derived or not. Doesn't count as answer as I already know: If you want your class abstract and it has no pure virtual functions - leave it to the destructor. Some more uses? If you want your class abstract and it has no pure virtual functions - leave it to the destructor. Actually, I don't think there's more. All the

Consider the following sample code: #include <iostream> using namespace std; class base { public: base() { bar(); //Line1 this->bar(); //Line2 base *bptr = this; bptr->bar(); //Line3 ((base*)(this))->bar(); //Line4 } virtual void bar() = 0; }; class derived: base { public: void bar() { cout << "vfunc in derived class\n"; } }; int main() { derived d; } The above code has pure virtual function bar() in base class which is overriden in the derived class. The pure virtual function bar() has no definition in base class. Now focus on Line1 , Line2 , Line3 and Line4 . I understand : Line1 gives

The benefit of defining common virtual functions in the base class is that we don't have to redefine them in the derived classes then. Even if we define pure virtual functions in the base class itself, we'll still have to define them in the derived classes too. #include <iostream> using namespace std; class speciesFamily { public: virtual void numberOfLegs () = 0; }; void speciesFamily :: numberOfLegs () { cout << "\nFour"; } class catFamily : public speciesFamily { public: void numberOfLegs () { speciesFamily :: numberOfLegs (); } }; This may look fancy for sure, but are there any situations