S   T
  / \ /
 P   N

Ich will nun folgendes realisieren:

1. Suche in einem ptr_vector<S> mit max_element nach dem größten Element. Dabei sollen nur solche Elemente aus dem vector untersucht werden, die ein N und damit ein T sind. Das größte Element soll als T angegeben werden.
2. Suche nun alle Vorkommnisse von dem größten Elemten im vector, wieder nur unter den N's.

Kann man das sinnvoll ohne RTTI realisieren?

Kann man das sinnvoll ohne RTTI realisieren?

Du willst zur Laufzeit einen Typ Identifizieren - dh du brauchst eine Laufzeit Typ Identifizierung (Runtime Type Identification). Also nein.

Du kannst aber zB garnicht erst die Typen mischen die nicht gemischt werden sollen... Oder natürlich jedem Typen eine ID mitgeben und die abfragen.

idR zeigt dies einen Designfehler an wenn man sowas braucht - nicht immer, ist aber ein guter Indiz.

virtual int S::GetValue() const = 0;

Dabei kannst du die Implementierungen in P so schreiben, dass ein sicher kleinerer Wert als unter N herauskommt.

virtual int P::GetValue()
{
    return -1; // Falls N::GetValue() immer ints >= 0 zurückgibt.
}

Die virtuelle Funktion GetValue() wird dann von std::max_element() aufgerufen, um das Maximum zu finden. Schau dir dazu den dritten Parameter des STL-Algorithms an.

Allerdings ist std::max_element() etwas ungeeignet, da es dir nur ein Maximum zurückgibt, und nicht alle Vorkommen. So musst du den Container mehrmals durchlaufen, zusätzlich mit std::find() . Die Alternative wäre, selbst eine Maximumsfunktion zu schreiben, die Indizes/Zeiger/Iteratoren auf alle maximalen Elemente in einem std::vector speichert und diesen zurückgibt.

Satzzeichen   Tonhoehe
      /    \ /
   Pause   Note

Und ich definiere

typedef boost::ptr_vector<Satzzeichen> Stimme;

Jetzt will ich herausfinden, ob in einer Stimme die höchste Note (d.h. ignoriere Pausen) mehrfach vorkommt.

Nexus' Idee wäre ja, der Pause eine Tonhoehe = -10000 zuzuordnen. Geht das eleganter?

Tonhoehe
  /
Note

unklug ist. Eine Note hat eine Tonhöhe, ist aber keine.

Ich weiss nicht, wie viel eleganter dein Problem gelöst werden kann, ohne Shade Of Mines Vorschlag zu berücksichtigen.

@ drakon: Das sagt uns nun sehr viel...

Hat noch jemand eine andere Idee?

Hör auf Nexus. Dein Problem liegt in vermurkstem Design. Anstatt dies jetzt mit diesem Design irgendwie hinzufrickeln solltest du lieber noch einmal über die Beziehungen zwischen deinen Klassen nachdenken. Wenn das Design gut ist, dann sind dieses und andere Probleme viel einfacher zu lösen.

@ drakon: Das sagt uns nun sehr viel...

Das soll heissen, dass ich die gleiche Idee schreiben wollte, dann aber gesehen habe, dass du das genau so machst und meinen Post wieder entfernt. Ich hätte auch die gleiche Idee nochmal beschreiben können, was mir aber ein wenig unsinnig erscheint, darum die Zustimmung, dass ich das gleiche vorgeschlagen hätte, aber dass ich grundsätzlich Shades Meinung bin, dass da wohl etwas mit dem Design falsch läuft.

Eine Note hat eine Tonhöhe, ist aber keine.

hat vielleicht eine Tonhöhe. Schlagzeugnotation ist da sowas was ziemlich aus der Reihe tanzt. Und in gewissem Maße auch der Generalbass.

bool is_T_derived(const T&) { return true; }
bool is_T_derived(...) { return false; }

struct Pred
{
    bool operator<(const U& lhs, const U& rhs)
    {
        if(!is_T_derived(lhs))
             return is_T_derived(rhs);
        return is_T_derived(rhs) && lhs.tonhoehe < rhs.tonhoehe;
    }
};

@Michael E.: Rat mal was bei is_T_derived(*(static_cast<Satzzeichen *>(new Tonhoehe()))); passiert.

@Michael E.: Rat mal was bei is_T_derived(*(static_cast<Satzzeichen *>(new Tonhoehe()))); passiert.

Was willst du mir sagen?

error C2440: 'static_cast': 'Tonhoehe *' kann nicht in 'Satzzeichen *' konvertiert werden
Die Typen, auf die verwiesen wird, sind nicht verknüpft; die Konvertierung erfordert einen reinterpret_cast-Operator oder eine Typumwandlung im C- oder Funktionsformat.