Standardkonform?

CMatt

Hallo.
Kann mir einer von euch sagen ob folgender code dem c++ standard enstpricht?

class base1
{
public:
   virtual void foo() = 0;
};

class base2
{
public:
  virtual void foo() = 0;
};

class impl : public base1, public base2
{
public:
  virtual void base1::foo() {
     //...
   }
   virtual void base2::foo() {
    //...
  }
};

VC++ 6 mag es nicht, VC++ 7 mag es, auch ohne code language extensions. Mit mehr konnte ich es noch nicht testen (wäre coole wenn es einer von euch durch nen GNU compiler jagen könnte und sagen könnte ob der das frisst oder nicht).

Thx!

Artchi

Was sollte da jetzt nicht Standardkonform sein? Anders würde ich es auch nicht machen. Bzw. wie würdest du es alternativ machen?

Und warum sollte der gcc stanardkonformer als der msvc7.1 sein?

Comeau Compiler kannste noch testen.

CMatt

Artchi schrieb:

Was sollte da jetzt nicht Standardkonform sein?

Keine ahnung, um das rauszufinden hab ich den post gemacht, also kann ich dir jetzt, nach deiner aussage, sagen: nichts

Artchi schrieb:

Anders würde ich es auch nicht machen. Bzw. wie würdest du es alternativ machen?

Da es VC++ 6 nicht schluckt, über unter-objekte...

Artchi schrieb:

Und warum sollte der gcc stanardkonformer als der msvc7.1 sein?

Hab ich das behauptet? Gibt nur hin und wieder ein paar c++ konstrukte die auf 50% der compiler laufen und auf 50% nicht. Auf VC++ 6 läuft das oben schon mal nicht. Wollte nur wissen ob es GNU schluckt, oder ob die auch rumziecken

Braunstein

Hallo,

Mein MinGW spuckt Fehlermeldungen aus
"cannot declare member function 'base1::foo' within 'imp1'"
"cannot declare member function 'base2::foo' within 'imp1'"

shapeless

Braunstein schrieb:

Hallo,

Mein MinGW spuckt Fehlermeldungen aus
"cannot declare member function 'base1::foo' within 'imp1'"
"cannot declare member function 'base2::foo' within 'imp1'"

das gleiche bekommt man bei gcc version 3.3.5

HumeSikkins

Artchi schrieb:

Was sollte da jetzt nicht Standardkonform sein?

Ganz einfach, das:

class impl : public base1, public base2
{
public:
  virtual void base1::foo() {
     //...
   }

   virtual void base2::foo() {
    //...
  }
};

Anders würde ich es auch nicht machen.

Was leider nichts an den Tatsachen ändert

Bzw. wie würdest du es alternativ machen?

In Standard-C++ müsse die siamesischen Zwillinge durch eine explizite Indirektion getrennt werden:

class base1
{
public:
   virtual void foo() = 0;
};

class base2
{
public:
  virtual void foo() = 0;
};

// Indirektion:
class Base1Indirect : public base1 {
public:
    void foo() {
       base1Foo();
    }
   virtual void base1Foo() = 0;
};

class Base2Indirect : public base2 {
public:
   void foo() {
       base2Foo();
   }

   virtual void base2Foo() = 0;
};

class impl : public Base1Indirect, public Base2Indirect 
{
public:
  // foo wird nicht überschrieben

  virtual void base1Foo() {
     //...
   }
   virtual void base2Foo() {
    //...
  }
};

CMatt

Thx!
Wäre auch zu schön gewesen...