Vererbung von Funktionen

Reply to Vererbung von Funktionen on Mon, 19 Sep 2011 17:08:40 GMT

vererber — Mon, 19 Sep 2011 17:08:40 GMT

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.
}

Reply to Vererbung von Funktionen on Mon, 19 Sep 2011 17:19:00 GMT

[[global:guest]] — Mon, 19 Sep 2011 17:19:00 GMT

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...

Reply to Vererbung von Funktionen on Mon, 19 Sep 2011 17:18:12 GMT

vererber — Mon, 19 Sep 2011 17:18:12 GMT

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

Reply to Vererbung von Funktionen on Mon, 19 Sep 2011 17:33:18 GMT

[[global:guest]] — Mon, 19 Sep 2011 17:33:18 GMT

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 ?

Reply to Vererbung von Funktionen on Mon, 19 Sep 2011 17:38:00 GMT

7xCore — Mon, 19 Sep 2011 17:38:00 GMT

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.

Reply to Vererbung von Funktionen on Tue, 20 Sep 2011 06:52:46 GMT

brotbernd — Tue, 20 Sep 2011 06:52:46 GMT

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 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;
}

Reply to Vererbung von Funktionen on Wed, 21 Sep 2011 12:35:28 GMT

Helmut.Jakoby — Wed, 21 Sep 2011 12:35:28 GMT

Ü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ß

Reply to Vererbung von Funktionen on Wed, 21 Sep 2011 13:39:34 GMT

Panke — Wed, 21 Sep 2011 13:39:34 GMT

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!"; }
}