Also ich habe folgendes Szenario:
Ich habe ein und denselber Algorithmus, der eine Liste durchläuft, für jeden Listen-Eintrag ein Objekt der Klasse A erstellt und von all diesen Objekten die Property X (Typ int) abzurufen und aufzuaddieren. Meine Idee war jetzt mit so etwas wie Funktionszeigern auf Memberfunktionen zu arbeiten, da ich ja weiss, dass jede GetterFunktion die Signatur int X::Bla(void) hat. Leider klappt das bisher nicht wirklich... Also hier auf jeden Fall mal mein bisheriger Code:

.h

typedef int (A::*MyFunctionPtrType) (void);
...
int CallMyFunctionPtr(MyFunctionPtrType fPtr);

.cpp

int MyClass::CallMyFunctionPtr(TPChannelFunctionPtr fPtr)
{
    A* a = new A();
    int result = (a->*fPtr)();
}

int MyClass::CallProperty1()
{
    return CallMyFunctionPtr(&A::NameOfProperty1);
}

int MyClass::CallProperty2()
{
    return CallMyFunctionPtr(&A::NameOfProperty2);
}

Hierbei schlägt allerdings schon das Kompilieren fehl... Der Versuch den ÜbergabeParameter von CallMyFunctionPtr hart auf MyFunctionPtrType zu casten endete leider darin, dass meine CPU auf 100% ging und sich das Programm verabschiedete ;O) Hat irgendjemand eine Idee, wie ich explizit auf die Getter-Funktion des Properties zugreifen kann, oder hat jemand eine bessere Idee das ganze zu implementieren?

Viele Grüße
Der Christoph

Meine Idee war jetzt mit so etwas wie Funktionszeigern auf Memberfunktionen zu arbeiten, da ich ja weiss, dass jede GetterFunktion die Signatur int X::Bla(void) hat

Properties sind Borland-spezifisch, da kann man nicht von ausgehen das zu jeder Property wirklich eine Getter-Methode angelegt wird. Du müßtest schon selber eine (public) Gettermethode für die Membervariable erstellen. Diese kannst ja dann auch in der Property eintragen.
Von dieser Methode kannst du dann auch den Methodenpointer bzw. desen Adresse bekommen. Aber Achtung : Das ist kein klassischer Funktionspointer, den Methodenpointer sind im Gegensatz zu statischen Funktionen immer noch zu einem konkreten Objekt zugehörig.

Allerdings stelle ich mir die Frage, was das ganze soll? Warum benutzt die die Property nicht einfach wie vorgesehen?

bis bald
akari

Viele Grüße
Christoph

Für sowas sind Properties nicht geeignet, hier wäre es besser einen Wrapper zu schreiben der die Properties in ein Array mapt, so das über die Werte der Eigenschaften iteriert werden kann.

bis bald
akari

Meinst du zu jedem Objekt der Klasse A eine Wrapper, der in einem Array alle Eigenschaften auflistet also vom prinzip her sowas wie:

class MyAWrapper
{
public:
A a;
int[] myArray;
}

und in diesem Array dann alle Property-Werte aufführen, so dass ich meinem Algorithmus dann einen MyAWrapper, und die Stelle des Array an dem die gesuchte Property liegt übergebe? Oder war das jetzt völlig daneben?

Viele Grüße
Christoph

Du kannst entweder die Werte selber in so einen Array-Container packen.
Oder, was mir vorschwebte, die Zugriffe auf die Properties selber kapseln. Minimalbeispiel :

class TOriginal
{
...
  __property int Zahl1 = {...};
  __property int Zahl2 = {...};
  __property int Zahl3 = {...};
};

class TWrapper
{
  public :
    TWrapper(const TOriginal* Original);
    const int ZahlCount = 3;
    int GetZahl(int Index)
  private :
    const TOriginal* m_Original;
};

TWrapper::TWrapper(const TOriginal* Original) : m_Original(Original)
{
}
int TWrapper::GetZahl(int Index)
{
  switch (Index)
  {
    case 0 : return m_Original->Zahl1;
    case 1 : return m_Original->Zahl2;
    case 2 : return m_Original->Zahl3;
    default : throw Exception("Index nicht vorhanden");
  }
}

// Benutzen :
TOriginal* Original = ...;
TWrapper Wrapper(Original);
for (int Lv = 0; Lv < Wrapper.ZahlCount; ++Lv)
  Berechne(Wrapper.GetZahl(Lv));

Damit könnte man die Berechnung gut von der Wertequelle abkapseln, und sogar noch dynamische Anzahl von Werten berücksichtigen, wenn man entsprechend den Wrapper ausbaut.

bis bald
akari

das gefällt mir Vielen Dank für die Hilfe und viele Grüße!

Christoph

P.S. Ich hasse diese Borland spezifischen Konstrukte - wieso kann man nicht einfach ne Setter und ne Getter Methode schreiben und gut ist - dann weiss wenigstens auch jeder, dass da tatsächlich ne Methode ausgeführt wird...

wieso kann man nicht einfach ne Setter und ne Getter Methode schreiben und gut ist - dann weiss wenigstens auch jeder, dass da tatsächlich ne Methode ausgeführt wird...

Kann man ja. __property ist auch ja nur ein Überzug über (potentielle) Getter und Setter. Für ein möglichst flexibles Klassendesign sollte man also trotz __property immer noch mit public Getter und Setter einbauen.

bis bald
akari

P.S. Ich hasse diese Borland spezifischen Konstrukte - wieso kann man nicht einfach ne Setter und ne Getter Methode schreiben und gut ist - dann weiss wenigstens auch jeder, dass da tatsächlich ne Methode ausgeführt wird...

Weil man die Objekte dann nicht so ohne weiteres persistent machen, aus einer .dfm-Datei initialisieren und z.B. im Objektinspektor Initialwerte zuweisen kann.