Pfeil-Operator -> überladen

[Andreas79]

Hallo,

leider bin ich über die Such-Funktion nicht fündig geworden, deshalb stelle ich jetzt folgende Frage.

Ich habe folgende Struktur

struct Test                                                
{                                                                
  Test1Ptr ptest1;                                    
  Test2Ptr ptest2;     
};

dann habe ich Funktionen

void fkt_test1_funktion(...)
{
  Test1Ptr Hans

  // Zeiger auf die Struktur       
  struct Test ptest;                                         
  struct Test * ptest = &test;

  // Test1objekt anlegen
  ptest->ptest1 = getTest1objekt();

  // Werte setzen
  fkt_setzen_test1(ptest)
}

void fkt_setzen_test1(struct Test * ptest)
{
  ptest->ptest1->setGroesse(groesse);
}

//////////////////////////////////////////////////////////////////////////

void fkt_test2_funktion(...)
{
  Test2Ptr Gretl

  // Zeiger auf die Struktur       
  struct Test ptest;                                         
  struct Test * ptest = &test;

  // Test2objekt anlegen
  ptest->ptest2 = getTest2objekt();

  // Werte setzen
  fkt_setzen_test2(ptest)
}

void fkt_setzen_test2(struct Test * ptest)
{
  ptest->ptest2->setGroesse(groesse);
}

wie man erkennt wird sowohl bei Test1 als auch bei Test2 jeweils im Grunde dasgleiche gemacht, deshalb habe ich mir eine Art übergeordnete Funktion vorgestellt. Bei dieser soll der Pfeil-Aufruf überladen werden, so in der Art wie

void fkt_test_funktion(...)
{
  Test1Ptr Hans
  Test2Prt Gretl

  // Zeiger auf die Struktur       
  struct Test ptest;                                         
  struct Test * ptest = &test;

  // Test1objekt anlegen
  if (bla)
  {
    ptest->ptest1 = getTest1objekt();
    // Überladen
    ptest->ptest_global = ptest->ptest1;
  }
  else
  {
    ptest->ptest2 = getTest2objekt();
    // Überladen
    ptest->ptest_global = ptest->ptest2;
  }

  // Werte setzen
  fkt_setzen_test(ptest)
}

// Somit kann man mit einer einzigen Funktion fkt_setzen arbeiten

void fkt_setzen_test(struct Test * ptest)
{
  ptest->ptest_global->setGroesse(groesse);
}

Ist dies so möglich? Ich hoffe ich habe mich gut ausgedrückt und es ist herausgekommen, was ich haben will. Für Tipps und Hinweise hierzu wäre ich sehr dankbar.

Viele Grüße
Andreas

[CStoll]

Bei deinen Funktionen blicke ich jetzt nicht mehr durch - was hast du vor?

(nebenbei hat das wenig mit op-> zu tun - der kommt eher dann zum Einatz, wenn du Smart-Pointer oder Iteratoren entwickeln willst)

[Andreas79]

Hallo, ich dachte mir schon fast, dass ich mich schlecht ausgedrückt habe;-)
mein Hauptanliegen ist eben, dass ich die Funktionen fkt_setzen_test1 und fkt_setzen_test2 zu einer Funktion fkt_setzen_test zusammenfassen will. Nur arbeitet man einmal mit dem Objekt Test1 und zu anderen mit dem Objekt Test2. Somit würde ich mir sehr viel arbeit sparen, wenn ich nicht für jedes Objekt eine eigene Funktion fkt_setzen_test schreiben muß, sonsdern eine fkt_setzen_test die mit beiden Objekten zurecht kommt, es soll immer nur eines der beiden Objekte angelegt werden und nicht beide gleichzeitig.

[CStoll]

Wenn Test1 und Test2 von einer gemeinsamen Basisklasse abstammen, könntest du ja diese Basisklasse verwenden, ansonsten eventuell eine Template-Funktion:

template<typename T>
void setze_whatever(T* ptr)
{
  ptr->setGroesse(groesse);
}

...
Test objekt;
setze_whatever(object.ptest1);
setze_whatever(object.ptest2);
...

[Andreas79]

Hallo CStoll, danke für den Tipp mit der Basisklasse, da hätte ich eigentlich auch gleich draufkommen können.

Gruß
Andreas