Pure virtual functions may not have an inline definition. Why?

by

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 keyword pure or abstract because at the time I saw no chance of getting a new keyword accepted. Had I suggested pure, Release 2.0 would have shipped without abstract classes. Given a choice between a nicer syntax and abstract classes, I chose abstract classes. Rather than risking delay and incurring the certain fights over pure, I used the tradition C and C++ convention of using 0 to represent “not there.” The =0 syntax fits with my view that a function body is the initializer for a function and also with the (simplistic, but usually adequate) view of the set of virtual functions being implemented as a vector of function pointers. [ … ]

So, when choosing the syntax Bjarne was thinking of a function body as a kind of initializer part of the declarator, and =0 as an alternate form of initializer, one that indicated “no body” (or in his words, “not there”).

It stands to reason that one cannot both indicate “not there” and have a body – in that conceptual picture.

Or, still in that conceptual picture, having two initializers.

Now, that’s as far as my telepathic powers, google-foo and soft-reasoning goes. I surmise that nobody’s been Interested Enough™ to formulate a proposal to the committee about having this purely syntactical restriction lifted, and following up with all the work that that entails. Thus it’s still that way.

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  3. Pure virtual function with implementation
  4. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  5. Why do we need a pure virtual destructor in C++?
  6. Can I take the address of a function defined in standard library?
  7. Is null reference possible?
  8. “constructing” a trivially-copyable object with memcpy
  9. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  10. Where do “pure virtual function call” crashes come from?
  11. Is floating point addition commutative in C++?
  12. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  13. Standard-layout and tail padding
  14. Deducing first template argument with other template parameters defaulted
  15. Get pointer to object from pointer to some member
  16. Understanding the example on lvalue-to-rvalue conversion
  17. Is it legal to declare a constexpr initializer_list object?
  18. Self-initialization of a static constexpr variable, is it well-formed?
  19. Are notes and examples in the core language specification of the C++ Standard non-normative?
  20. What is the purpose of a declaration like int (x); or int (x) = 10;
  21. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  22. Does C++11 allow dollar signs in identifiers?
  23. Is stl vector concurrent read thread-safe?
  24. What happens when a function that returns an object ends without a return statement
  25. Is it allowed for a compiler to optimize away a local volatile variable?
  26. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  27. Why is `make_unique` disallowed?
  28. Using std::bind with member function, use object pointer or not for this argument?
  29. Why don’t I need to specify “typename” before a dependent type in C++20?
  30. memcpy/memmove to a union member, does this set the ‘active’ member?

Leave a Comment