OOP - hvordan kan jeg håndtere settings?

Hvis det virkeligt er det du vil, kan man kaste sig ud i nogen function pointere:

#include <iostream>

class MyClass
{
public:
   MyClass(int i)
   {
      if(i == 1)
      {
         Func1 = &MyClass::Func11;
         Func2 = &MyClass::Func12;
      }
      else
      {
         Func1 = &MyClass::Func21;
         Func2 = &MyClass::Func22;
      }
   }
   int (MyClass::*Func1)(int, int);
   int (MyClass::*Func2)(int, int);
private:
   int Func11(int, int)
   {
      std::cout << "Func11" << std::endl;
      return 11;
   }
   int Func12(int, int)
   {
      std::cout << "Func12" << std::endl;
      return 12;
   }
   int Func21(int, int)
   {
      std::cout << "Func21" << std::endl;
      return 21;
   }
   int Func22(int, int)
   {
      std::cout << "Func22" << std::endl;
      return 22;
   }
};

int main()
{
   MyClass C1(1);
   MyClass C2(1);
   (C1.*(C1.Func1))(1, 1);
   (C2.*(C2.Func2))(2, 2);
}

Bemærk den lidt specielle syntax.

Tak,
men bliver det ikke meget uoverskueligt bare jeg har 4 funktioner med 3 mulige implementeringer?
Jeg har et model-system, og det jeg er interesseret i er at afsøge hvordan adfærden af systemet ændrer sig når jeg ændrer på nogle forudsætninger (implementeringen).
Det svarer dybest set til den måde det kører i et klassisk GUI-program, hvor man kan flytte nogle flueben og så kører programmet på en anden måde (derfor tænker jeg på det som en 'settings'-boks). Derfor tænker jeg der må være en 'autoriseret' måde at gøre det på?
Jeg har været ude i at definere hver funktion som en (pointer til) en abstrakt klasse (måske som en functor) og så lave funktionerne ved nedarvning - men det virker bare som en meget stor konstruktion for at opnå relativt lidt.
Tror du der kunne være en nemmere måde at gøre det på; - eller har jeg bare rodet mig ud i noget der bliver for kompliceret at gøre i praksis?

Jeg er bange for at der ikke er nogen let måde at gøre det på.

Du kunne overveje at have en tabel (et array) med dine funktioner.

En almindelig måde at lave det på, er at gemme callback funktioner, som kaldes af dine metoder.

En helt anden metode, som er en del mere avanceret, men mere eller mindre transparant, efter den er implementeret korrekt vel og mærke, er overskrivning eller redigering af den virtuelle funktionstabel. Dette kræver, at du ved hvordan din kompiler gemmer funktionstabellen, og systemet ville ikke være cross-kompiler kompatibelt.

Har selv leget lidt med begge betoder, og den nemmeste er uden tvivl den første af de to.

OK,
en tabel er en god ide;så vidt jeg forstår ville det kunne spare mig for en masse switch-sætninger?
The Freak >> at pille ved funktionstabellen er klart over mit niveau
Hvis jeg forstår det med callback korrekt er det det samme som den mulighed vi snakker om med function pointers eller functors, eller hur?
Nå, jeg prøver at give mig i kast med det, tak skal i hava