Ich würde gerne eine Klasse erzeigen, die ein paar Eingabe kontrolliert, und wenn diese richtig sind einen Code ausführt. Allerdings soll dieser Code nicht in der Klasse sein, sondern per Parameter übergebe werden.
Ist soetwas irgendwie möglich?
Ich hoffe ihr versteht, was ich meine und könnt mir helfen.

class TestKlasse
{
public:
 int x;
 code Code;

private:
 TestKlasse(int x, code Code)
 {
  if(x >= 5)
   code;
 }
};

main
{
 TestKlasse tk1(7 ,printf("größer als Fünf"));
 TestKlasse tk2(2 ,while(1){printf("Test")});
 TestKlasse t3(0 , if(x==2){Funktion();};
}

void (*funcPtr)();
class TestKlasse
{
public:
 int x;
 code Code;

private:
 TestKlasse(int x, funcPtr)
 {
  if(x >= 5)
   funcPtr();
 }
};

void printFunc()
{
    printf("größer als Fünf");
}

void whileFunc()
{
    while(1) {
        printf("Test");
    }
}

main
{
 TestKlasse tk1(7 , printFunc);
 TestKlasse tk2(2 , whileFunc);
}

#include <functional>

class TestKlasse
{
public:
 TestKlasse(int x, const std::function<void()>& code )
 {
  if(x >= 5)
   code();
 }
};

main
{
 TestKlasse tk1(7 ,[](){printf("größer als Fünf")} );
 TestKlasse tk2(2 ,[](){while(1){printf("Test")}} );
 TestKlasse t3(0 , [](){if(x==2){Funktion();} } );
}

Siehe auch den Artikel zu C++0x im Magazin (da steht glaubich noch C++09).

Ahja, GCC 4.3 bzw MSVC++ 2010 können das.

#include <map>
#include <iostream>
#include <boost/smart_ptr.hpp>

// abstrakte Basisklasse für alle Actions
class IAction
{
public:
   virtual ~IAction();

   // abgeleitete Klassen implentieren execute() mit sinnvollem Code
   virtual void execute() = 0;
};

// Typdefinition für shared_ptr, können auch TR1::shared_ptr sein
typedef boost::shared_ptr<IAction> ActionPtr_t;

// Konkrete Action Klasse 1
class ActionOne : public IAction
{
public:
   static const unsigned int ID = 0;

   void execute()
   {
      // Verhalten von Action One
      std::cout << "Action one";
   }
};

// Konkrete Action Klasse 1
class ActionTwo : public IAction
{
public:
   static const unsigned int ID = 1;

   void execute()
   {
      // Verhalten von Action Two
      std::cout << "Action two";
   }
};

// Action, die einfach nix tut
class NullAction : public IAction
{
public:
   void execute()
   {
      // NullAction macht nix
   }
};

// Funktionen zum Erzeugen konkreter Action Objekte
ActionPtr_t create_action_1()
{
   // neues ActionOne Objekt in shared_ptr verkapseln und zurückgeben
   return ActionPtr_t( new ActionOne() );
}

ActionPtr_t create_action_2()
{
   // neues ActionTwo Objekt in shared_ptr verkapseln und zurückgeben
   return ActionPtr_t( new ActionTwo() );
}

// Action Factory zum Erzeugen konkrete Action Objekte
class ActionFactory
{
   // Typdefinition für Funktionspointer
   typedef ActionPtr_t (*func)(void);
   typedef std::map<unsigned int, func> ActionCreatorMap_t;

   // Map mit Zuordnung ActionID -> Erzeugerfunktion
   ActionCreatorMap    CreatorMap_; 

public:
   // Implementation als Singleton
   static const ActionFactory& instance()
   {
      // das einzige Factory Objekt
      static ActionFactory theFactory;
      return theFactory;
   }

   ActionPtr_t create( unsigned int ActionID ) const
   {
      ActionCreatorMap::const_iterator it = CreatorMap_.find( ActionID );
      if( CreatorMap_.end() != it )
      {
         // Eintrag für übergebene Funktion gefunden, Funktion erzeugt Action
         return it->second();
      }
      // kein Treffer für übergebene ID, NullAction zurückgeben
      return ActionPtr_t( new NullAction() ); 
   }

private:
   ActionFactory()
   {
      // Erzeugerfunktionen unter ihrer ID in map eintragen
      CreatorMap_[ActionOne::ID] = create_action_1;
      CreatorMap_[ActionTwo::ID] = create_action_2;
   }
   // keine Kopien erlauben, CCtor und Assignment privat
   ActionFactory::ActionFactory( const ActionFactory& );
   ActionFactory& operator=( const ActionFactory& );
};

int main()
{
   // Action 1, Action 2 und ungültige ID ausführen
   ActionFactory::instance().create( ActionOne::ID )->execute();
   ActionFactory::instance().create( ActionTwo::ID )->execute();
   ActionFactory::instance().create( 400 )->execute();
}

Code ist nicht getestet, dient lediglich zur Veranschaulichung der Idee

... und ist häßlich, unübersichtlich, beschissen zu warten und umständlich. Meine bescheidene Meinung.

Argumente? Oder nur subjektiv?

p.S.: vielleicht damit du eine Singleton-Klasse mit all ihren Problemen (z.B. mit vielen Compilern nicht threadsafe) einführen kannst, die man sonst nicht bräuchte?

Ahja, GCC 4.3 bzw MSVC++ 2010 können das.

Woher hast du die Info das GCC 4.3 Lambda's kann?

Idealerweise vermeidet man das wenn es geht. Aber das hat natürlich nichts mit boost::function zu tun, sondern eher damit, dass stateless "immer" besser ist als "stateful". Gerade bei Funktoren.

boost::function hat allerdings - wenn ich mich richtig erinnere - "value semantics", d.h. das darin verpackte Funktions-Objekt wird bei Zuweisung kopiert und nicht referenziert. Was man allerdings wieder schön mit shared_ptr umgehen kann.

Nochwas: wenn man Templates verwenden kann, braucht man natürlich gar kein boost::function/std::function/was-auch-immer, sondern kann den Funktor einfach als beliebigen Typ übergeben:

class Foo
{
public:
    template <class Functor>
    Foo(..., Functor functor)
    {
        ...
        functor(123,456);
    }
};

Spart wieder ein wenig Overhead ein.

Badestrand_ schrieb:

Ahja, GCC 4.3 bzw MSVC++ 2010 können das.

Woher hast du die Info das GCC 4.3 Lambda's kann?

Kann laut http://gcc.gnu.org/projects/cxx0x.html erst GCC 4.5