There are many articles that explain why you should never call virtual functions in constructor and destructor in C++. Take a look here and here for details what happens behind the scene during such calls. In short, objects are constructed from the base up to the derived. So when you try to call a virtual … Read more
However, in the case of a pure virtual function, the compiler would throw an error if we used an incorrect signature in the Derived class No, this compiles: class Base { virtual void my_function() = 0; }; class Derived : Base { void my_function(int); // ^^^ mistake! }; While this does not: class Base { … Read more
For future people struggling with a similar problem, the situation is that the compiler simply cannot find the type you are using (even if your Intelisense can find it). This can be caused in many ways: You forgot to #include the header that defines it. Your inclusion guards (#ifndef BLAH_H) are defective (your #ifndef BLAH_H … Read more
In the SO thread “Why is a pure virtual function initialized by 0?” Jerry Coffin provided this quote from Bjarne Stroustrup’s The Design & Evolution of C++, section §13.2.3, where I’ve added some emphasis of the part I think is relevant: The curious =0 syntax was chosen over the obvious alternative of introducing a new … Read more
If anywhere in the runtime of your program an object is created with a virtual function pointer not filled in, and when the corresponding function is called, you will be calling a ‘pure virtual function’. The handler you describe should be defined in the default libraries that come with your development environment. If you happen … Read more
Your assumption that pure virtual function cannot be called is absolutely incorrect. When a function is declared pure virtual, it simply means that this function cannot get called dynamically, through a virtual dispatch mechanism. Yet, this very same function can easily be called statically, non-virtually, directly (without virtual dispatch). In C++ language a non-virtual call … Read more
That line of code defines a pure virtual function in C++. It has nothing to do with the otherwise tricky Win32 API or GUI code in general. A pure virtual function is a virtual function that is used when the designer of the class wants to force derived classes to override the function and provide … Read more
pure lets the compiler know that it can make certain optimisations about the function: imagine a bit of code like for (int i = 0; i < 1000; i++) { printf(“%d”, fun(10)); } With a pure function, the compiler can know that it needs to evaluate fun(10) once and once only, rather than 1000 times. … Read more
They can result if you try to make a virtual function call from a constructor or destructor. Since you can’t make a virtual function call from a constructor or destructor (the derived class object hasn’t been constructed or has already been destroyed), it calls the base class version, which in the case of a pure … Read more
The reason =0 is used is that Bjarne Stroustrup didn’t think he could get another keyword, such as “pure” past the C++ community at the time the feature was being implemented. This is described in his book, The Design & Evolution of C++, section 13.2.3: The curious =0 syntax was chosen … because at the … Read more