{"id":842,"date":"2022-08-30T15:08:05","date_gmt":"2022-08-30T15:08:05","guid":{"rendered":"https:\/\/unknownerror.org\/index.php\/2013\/11\/09\/diamond-inheritance-scenario-compiles-fine-in-g-but-produces-warnings-errors-in-vc-eclipse-collection-of-common-programming-errors\/"},"modified":"2022-08-30T15:08:05","modified_gmt":"2022-08-30T15:08:05","slug":"diamond-inheritance-scenario-compiles-fine-in-g-but-produces-warnings-errors-in-vc-eclipse-collection-of-common-programming-errors","status":"publish","type":"post","link":"https:\/\/unknownerror.org\/index.php\/2022\/08\/30\/diamond-inheritance-scenario-compiles-fine-in-g-but-produces-warnings-errors-in-vc-eclipse-collection-of-common-programming-errors\/","title":{"rendered":"Diamond-inheritance scenario compiles fine in G++, but produces warnings\/errors in VC++\/Eclipse-Collection of common programming errors"},"content":{"rendered":"

I have a base class ‘Base’, which is a pure virtual class:<\/p>\n

class Base {\n\npublic:\n    virtual void A() = 0;\n    virtual void B() = 0;\n\n    virtual ~Base() { } \/\/ Eclipse complains that a class with virtual members must have virtual destructor\n};\n<\/code><\/pre>\n
I also have 2 other classes, one of them implements A() and the other one implements B():<\/p>\n
class DerivedA : public virtual Base\n{\npublic:\n    virtual void A() {\n        printf(\"Hello from A\");\n    }\n};\n\nclass DerivedB : public virtual Base\n{\npublic:\n    virtual void B() {\n        printf(\"Hello from B\");\n    }\n};\n<\/code><\/pre>\n
The virtual keyword in the declaration should solve the diamond problem.<\/p>\n
Now I would like to combine the two classes into another class, so that both A() and B() are implemented, like this:<\/p>\n
class DerivedC: public DerivedA, public DerivedB {\n     \/\/ Now DerivedA and DerivedB are combined\n};\n\n\/\/ Somewhere else in the code\nDerivedC c;\nc.A();\nc.B();\n<\/code><\/pre>\n
The problem:<\/strong> Even though G++ compiles the code just fine, Eclipse gives an error: The type 'DerivedC' must implement the inherited pure virtual method 'Base::B'<\/code>. When compiling with visual studio, I get 2 warnings:<\/p>\n
warning C4250: 'DerivedC' : inherits 'DerivedB::DerivedB::B' via dominance\nwarning C4250: 'DerivedC' : inherits 'DerivedA::DerivedA::A' via dominance\n<\/code><\/pre>\n
So the question is:<\/strong> what is the correct way of doing this? Does the code above produce undefined behavior?<\/p>\n
Note:<\/strong> The title may be a little misleading, I have no idea what a good title for this question would be.<\/p>\n
    \n
  1. \n
    \n
    What is the correct way of doing this? Does the code above produce undefined behavior?<\/strong><\/p>\n<\/blockquote>\n
    The code is perfectly valid. There is no Undefined Behavior here.
    \nAn unqualified call of A()<\/code> through a DerivedC<\/code> class object, will always call DerivedA::A()<\/code>, while an unqualified call of B()<\/code> through a DerivedC<\/code> class object, will always call the DerivedB::B()<\/code> instance.<\/p>\n
    Visual C++ gives you a warning because your code uses a less commonly known feature of virtual Inheritance which may not be obvious to most common users and might surprise them. In this case, the warning<\/em> should be taken as an Informative Nitpick<\/em> rather than a warning.<\/p>\n
    Note that the C++ Standard does not restrict compilers from emitting informative warnings for perfectly valid code. The documentation for warning C4250 gives an example which tells you why visual C++ chooses to give this warning.<\/p>\n<\/li>\n
  2. \n
    You might want to try this :<\/p>\n
    class DerivedC: public DerivedA, public DerivedB {\npublic:\n    using DerivedA::A;\n    using DerivedB::B;\n};\n<\/code><\/pre>\n
    I can’t test with Eclipse or VC++ myself…<\/p>\n<\/li>\n
  3. \n
    I don’t know why a compiler would complain about any of this; this is just the standard mixin technique. Classes Base<\/code>, DerivedA<\/code> and DerivedB<\/code> are abstract, and can’t be instantiated, but that’s usually the case for mixins. The whole point of a mixin is that it doesn’t implement all of the interface. And DerivedC<\/code> implements both A()<\/code> and B()<\/code> through its inherited members.<\/p>\n
    If a compiler refuses to compile this code, it is broken.<\/p>\n
    As for warnings… a compiler is free to warn about anything it pleases:<\/p>\n
      \n
    • \n
      There is no requirement that a class with virtual members have a virtual destructor. In practice, it’s usually a good idea, however (unless the destructor is protected), and a compiler warning is appropriate.<\/p>\n<\/li>\n
    • \n
      The warnings from Visual Studio are “informative”, I guess, but this is the way the language is designed to work. And it’s certainly not something to avoid. For that matter, I don’t think that dominance actually plays a role here, since the functions in Base<\/code> are pure virtual. What Visual Studios seems to be trying to say is that in DerivedC<\/code>, the actual overload of A()<\/code> is DerivedA::A()<\/code>, and not Base::A()<\/code>. Which seems to be what one would intuitively expect to me; the rules concerning dominance are really just a formal statement of what one would intuitively expect.<\/p>\n<\/li>\n<\/ul>\n
      Anyway, I’d definitely turn the warning about dominance off. There’s certainly nothing to worry about in that respect. And I’d complain loudly about a compiler which didn’t compile the code.<\/p>\n<\/li>\n
    • \n
      Your Base class is abstract : it can’t be instantiated. The B and A class are also abstract because they implement only one method.<\/p>\n
      The two solutions are, in file DerivedC.cpp<\/code><\/p>\n
      void DerivedC::A(){ \n   DerivedA::A();\n}\nvoid DerivedC::B(){\n   Derived:B();\n}\n<\/code><\/pre>\n
      Or you can use using<\/code> keyword in your header-file:<\/p>\n
      class DerivedC: public DerivedA, public DerivedB {\npublic:\n    using DerivedA::A;\n    using DerivedB::B;\n};\n<\/code><\/pre>\n<\/li>\n<\/ol>\n
      Originally posted 2013-11-09 22:48:27. <\/small><\/p>","protected":false},"excerpt":{"rendered":"
      I have a base class ‘Base’, which is a pure virtual class: class Base { public: virtual void A() = 0; virtual void B() = 0; virtual ~Base() { } \/\/ Eclipse complains that a class with virtual members must have virtual destructor }; I also have 2 other classes, one of them implements A() […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-842","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/842","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/comments?post=842"}],"version-history":[{"count":0,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/842\/revisions"}],"wp:attachment":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/media?parent=842"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/categories?post=842"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/tags?post=842"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}