Vererbung von Funktionen

Kann ich irgendwie erreichen, dass bei einem Funktionsaufruf hintereinander alle gleichnamigen Funktionen aller Basisklassen aufgerufen werden? Also:

struct CA {
  virtual void print() {
    std::cout << "Hallo!\n";
  }
};

struct CB : public CA {
  virtual void print() {
    std::cout << "Welt!\n";
  }
};

int main() {
  CB b;
  b.print(); // Soll sowohl "Hallo" als auch "Welt" ausgeben.
}

struct CA {
  virtual void print() {
    std::cout << "Hallo!\n";
  }
};

struct CB : public CA {
  virtual void print() {
    CA::print();//Immer die Funktion der Vorhergehenden Klasse/Struktur
    std::cout << "Welt!\n";
  }
};

int main() {
  CB b;
  b.print(); // Wird sowohl "Hallo!" als auch "Welt!" ausgeben.
}

Ist aber nicht was du willst, oder...

Hmja, ich meinte halt schon, dass das automatisch passieren soll.. das scheint aber nicht zu funktionieren?

vererber schrieb:

Hmja, ich meinte halt schon, dass das automatisch passieren soll.. das scheint aber nicht zu funktionieren?

Nicht so wie ich glaube wie du dir das Vorstellst, nein.

Edit: Was hast du gegen die Methode weiter oben ?

7xCore

Wie denn auch ?
Durch

struct CB : public CA

bigst du ja nur alles was in CA steht an CB weiter , doch du rufst keine funktion auf.

brotbernd

Es ist zwar nicht das wonach du gefragt hast, aber ein ähnliches Verhalten kannst du mit einem Dekorator abbilden.

class CA
{
public:
    virtual void Print() const
    {
        std::cout << "Hallo ";
    }
    virtual ~CA() {}
};

class CADecorator : public CA
{
public:
    explicit CADecorator(CA* decorated)
        : decorated_(decorated)
    {    
    }

    void Print() const
    {
        decorated_->Print();
        DoPrint();
    }

private:
    virtual void DoPrint() const = 0;
    std::unique_ptr<CA> decorated_;
};

class CB : public CADecorator
{
public:
    explicit CB(CA* decorated)
        : CADecorator(decorated)
    {   
    }
private:
    void DoPrint() const
    {
        std::cout << "Welt! ";
    }
};

class CC : public CADecorator
{
public:
    explicit CC(CA* decorated)
        : CADecorator(decorated)
    {   
    }
private:
    void DoPrint() const
    {
        std::cout << "Ende ";
    }
};

int main(int argc, char* argv[])
{
    CC c(new CB(new CA));
    c.Print();

    return 0;
}

Helmut.Jakoby

Überlege Dir mal die Konsequenz, wenn dort etwas automatisch in der Oberklasse aufgerufen werden soll. Wenn festgelegt sein würde, dass immer zuerst die Methode der Oberklasse aufgerufen wird, dann würde "Hallo!" und "Welt!" in dieser Reihenfolge ausgegeben .
Das ist ggf. nicht für alle Fälle gewünscht. In anderen Fällen möchte man evtl. die überschriebene Methode in der Oberklasse gar nicht oder irgendwann (z.B. am Ende um "Welt!" "Hallo!" in dieser Reihenfolge auszugeben) in der überschriebenen Methode abarbeiten lassen.
Gruß

Panke

Eine Alternative wäre Non-Virtual-Interface und Template-Method.

class A {
  virtual void pre_print() {}
  virtual void post_print() {}

public:  
// final
  void print { 
	pre_print();
	std::cout << "Hallo"; 
	post_print();
  }
}

class B : A {
  virtual void post_print() { std::cout << " Welt!"; }
}