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

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

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

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

Gruß
Andreas