Ich habe eine Klasse Cmd, in der ich Kommandos erzeuge. Ein Attribut der Klasse ist als Funktionszeiger implementiert. Dieser Funktionszeiger soll auf die für den Kommando vorgesehende Funktion zugewiesen werden. In meinem Fall übergebe ich einem Objekt der klasse Cmd eine Funktion der Klasse Flash_cmd(diesse Klasse besitzt Funktionen zur Ansteuerung eines Flashspeichers). Die Klasse Flash-Cmds ist als Singleton-pattern implementiert und die Übergabe von Funktionen aus der Klasse Flash_cmds an den Funktionszeiger vom Objekt der Klasse Cmd funktioniert nicht:

Fehlermeldung:
Fehler 1 error C3867: "Flash_cmds::setStartaddr": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&Flash_cmds::setStartaddr", um einen Zeiger auf den Member zu erstellen. 17

main.cpp

#define flash_cmds Flash_cmds::getInstance()
void flash_init_52401 (Flash& fl);
void test(const int& ha){std::cout<<"hallo"<<ha;};

int main()
{
    Flash flash;

    Cmd* mass_erase= new Cmd("set_startaddr", 1, 1, Flash_cmds::getInstance().setStartaddr);
    mass_erase->Execute();

Cmd.h

#include <iostream>
#include <string>
#include "string.h"

#pragma once

class Cmd
{
private:

    std::string cmd_name;
    std::string cmd_arg;
    int cmd_id;
    int cmd_argcount;
    void (*cmd_exe)(void);
    void (*cmd_exe_arg)(const int& t );

public:
    Cmd(void);
    ~Cmd(void);
    Cmd(std::string name, int id, int argcnt, void (*execute_function)(void));
    Cmd(std::string name, int id, int argcnt, void (*execute_function)(const int&));

    std::string GetName(void)const;
    int GetArgCount(void)const;

    void setArg(const std::string& arg);

    void Execute (void) const;

    bool operator==(const std::string& cmd)const
    {
        return(this->GetName()==cmd);
    }
};

Cmd.cpp

#include "Cmd.h"

Cmd::Cmd(void)
{
}

Cmd::Cmd(const std::string name, const int id, const int argcnt,void (*execute_function)(void) )
: cmd_name(name), cmd_id(id), cmd_argcount(argcnt), cmd_exe(execute_function)
{
    if (argcnt<0)
    {   
        std::cout<<"Ungueltige Anzahl von Argumenten"<<std::endl;
        cmd_argcount=0;
    }

}

Cmd::Cmd(const std::string name, const int id, const int argcnt, void (*execute_function)(const int& t) )
: cmd_name(name), cmd_id(id), cmd_argcount(argcnt),cmd_exe_arg(execute_function)
{
    if (argcnt<0)
    {   
        std::cout<<"Ungueltige Anzahl von Argumenten"<<std::endl;
        cmd_argcount=0;
    }

}

Cmd::~Cmd(void)
{
}

std::string Cmd::GetName (void) const
{
    return Cmd::cmd_name;
}

int Cmd::GetArgCount (void) const
{
    return Cmd::cmd_argcount;
}

void Cmd::Execute (void) const
{
    if(cmd_argcount==1)
        cmd_exe_arg(500);
    else
        cmd_exe();
}

void Cmd::setArg(const std::string& arg)
{
    cmd_arg=arg;
}

Flash_cmds

//Die Klasse Flash-CMD ist als Singleton-Pattern implementiert. Es kann nur ein Objekt einer 
//Klasse erstellt werden

//#include flash.h
#include <iostream>
#include <fstream> //für ofstream
#include <sstream>
#include <string>
#include "Flash.h"
#include "headertest.h"
//#include "help.h" //für read_file
#pragma once

class Flash_cmds
{

private:
    Flash flash;
    static Flash_cmds* OBJ;
    bool prog_data_content;
    long int *flashbuf;
    long int *filebuf;
    long int * progcontent_arr;
    long int * readcontent_arr;
    char rchar[40];
    int startaddr;
    int endaddr;
    int flashmode;
    bool fdebug;
    std::ofstream prog_file;
    Flash_cmds(void)
    {
        progcontent_arr=0;
        readcontent_arr=0;
        std::cout << "test \n";
    }
    Flash_cmds(const Flash_cmds&);  //nicht kopierbar
    ~Flash_cmds(void);
//Konstante für Prog-Content
     static const int chess=0;
     static const int invchess=1; 
     static const int address=2; 
     static const int array0=3;
     static const int array1=4; 
     static const int data_content=5;

//Konstante für Flashmode
     static const int flash12k=12;
     static const int flash8k=8; 
     static const int flash4k=4; 

public:

    static Flash_cmds& getInstance();
    static void destroy();

    //Get & Set Methoden für Attribute

    int getStartaddr() const;
    int getEndaddr() const;
    int getFlashmode()const;

    void setFlash(const Flash& fl);
    void setStartaddr(const int& saddr);
    void setEndaddr(const int& eaddr);

    void setProgcontent(const int& pgcont);
    void setFlashmode(const int& fmode);

    void start_read(void);
    void start_program(void);
    void start_masserase(void);
    void start_verify(void);
    void start_compare(void);
};

Vielen Dank im Voraus!

Fehler:
Fehler 1 error C2276: '&': Ungültige Operation auf Ausdruck einer gebundenen Memberfunktion

Code

Cmd* mass_erase= new Cmd("set_startaddr", 1, 1, &Flash_cmds::getInstance().setStartaddr);

Was genau hast du denn eigentlich vor?

also: string wird empfangen -> string wird mit befehlen der klasse cmd verglichen -> die zum zum befehl passende funktion wird aufgerufen...

ich will einen parser bauen. über das netzwerk empfangene strings werden mit den objekten der klasse cmd verglichen. naja, und jeder befehl(objekt der klasse cmd) verweist auf eine für den befehl zugewiesende funktion, die mit execute dann ausgeführt wird.

also: string wird empfangen -> string wird mit befehlen der klasse cmd verglichen -> die zum zum befehl passende funktion wird aufgerufen...

Eine Möglichkeit das zu bewerkstelligen wären Funktionsobjekte oder boost::function, aber bleiben wir mal bei deiner Lösung. Um die Adresse einer Memberfunktion zu übergeben brauchst du kein Objekt der Klasse, sondern nur den Typen. Erst beim Aufruf durch den Funktionszeiger musst du ein gültiges Objekt bereitstellen:

struct Cmd
{
   ...
   // Konstruktor für Flash Memberfunktion 
   Cmd( std::string name, 
        int id, 
        int argcnt, 
        void (Flash::*execute_function)() );
   ...
}

int main()
{
   Flash Flash;
   Cmd c( "start_read", 1, 1, &Flash::start_read );
}

Gefällt mir allerdings nicht, für den Memberfunktionsauf musst du dem Cmd Objekt noch eine Flash Instanz in die Hand drücken, sonst weiß es nicht, auf welchem Objekt es die Funktion aufrufen soll. Und ein Cmd Objekt für verschiedene Funktionen (member/non-member) mit unterschiedlich vielen Parametern finde ich auch nicht toll. Damit wären wir dann bei boost::function oder müssten uns selbst was basteln (vermutlich mit Templates und Vererbung).

Gefällt mir allerdings nicht, für den Memberfunktionsauf musst du dem Cmd Objekt noch eine Flash Instanz in die Hand drücken, sonst weiß es nicht, auf welchem Objekt es die Funktion aufrufen soll. Und ein Cmd Objekt für verschiedene Funktionen (member/non-member) mit unterschiedlich vielen Parametern finde ich auch nicht toll.

da müsste ich auf jedenfall variabel bleiben. ich hab noch andere memberfunktionen aus anderen klassen, die ich dann einem befehl zuweisen will. (z.B. DAC/ADC-Funktionen)

Damit wären wir dann bei boost::function

hab einen mikrocontroller auf dem embedded linux läuft und kann bis jetzt nur auf die standart libary zugreifen oder ist das kein problem die libary zu erweitern?

oder müssten uns selbst was basteln (vermutlich mit Templates und Vererbung).

das wäre vllt die bessere option...wenn zitat↑ ein problem darstellt

Alternativ kannst Du auch z.B. das hier verwenden:
http://www.codeproject.com/KB/cpp/FastDelegate.aspx

Die Frage ist nur, ob deine Vorgaben die Benutzung externer Bibliotheken erlauben, oder darfst du benutzen, was du willst?

ich kann mich da ganz frei bewegen, aber mir persönlich wäre es lieber auf die standard libary zuzugreifen.

Die Frage ist nur, ob deine Vorgaben die Benutzung externer Bibliotheken erlauben, oder darfst du benutzen, was du willst?

ich kann mich da ganz frei bewegen, aber mir persönlich wäre es lieber auf die standard libary zuzugreifen.

Ev. ist deine Kompiler / Library schon so weit, dass er TR1 Dinge von C++11 unterstützt, z.B. std::function<...> bzw. std::tr1::function<...>

Cmd* mass_erase= new Cmd("set_startaddr", 1, 1, &Flash_cmds::getInstance().setStartaddr);

Da holst du dir die addresse von einer funktion einer instanz die du vom statischem context entnimmst.
Ich würde mal sage, wenn setStartAddr eine funktion von Flash_cmds ist: &Flash_cmds::setStartAddr()
Dann kannst du das so aufrufen:
(Flash_cmds::getInstance()->*setStartAddr)(arugumentenliste wie gewohnt);

http://www.parashift.com/c++-faq-lite/pointers-to-members.html

Hab mal was (nur so aus der Hüfte geschossen) gebastelt, was du benutzen könntest. Statt roher Zeiger wären smart pointer toll, eventuell kann man mit boost/TR1::function das noch schöner machen. Aber als Hinweis taugt´s allemal was.

Ev. ist deine Kompiler / Library schon so weit, dass er TR1 Dinge von C++11 unterstützt, z.B. std::function<...> bzw. std::tr1::function<...>

ich hab den gcc compiler drauf version 4.4.5

Da holst du dir die addresse von einer funktion einer instanz die du vom statischem context entnimmst.
Ich würde mal sage, wenn setStartAddr eine funktion von Flash_cmds ist: &Flash_cmds::setStartAddr()
Dann kannst du das so aufrufen:
(Flash_cmds::getInstance()->*setStartAddr)(arugumentenliste wie gewohnt)

das klappt nicht so ganz...

also bei

Cmd* set_startaddr= new Cmd("set_startaddr", 1, 1, &Flash_cmds::getInstance()->*setStartaddr);

kommt der fehler: Fehler 1 error C2065: 'setStartaddr': nichtdeklarierter Bezeichner

ist das so richtig implementiert....

Cmd.h

#include <iostream>
#include <string>
#include "string.h"
#include "Flash_cmds.h"

#pragma once

class Cmd
{
private:

	std::string cmd_name;
	std::string cmd_arg;
	int cmd_id;
	int cmd_argcount;
	void (*cmd_exe)(void);
	void (Flash_cmds::*cmd_exe_arg)(const int& t );

public:
	Cmd(void);
	~Cmd(void);
	Cmd(std::string name, int id, int argcnt, void (*execute_function)(void));
	Cmd(std::string name, int id, int argcnt, void (Flash_cmds::*execute_function)(const int&));

	std::string GetName(void)const;
	int GetArgCount(void)const;

	void setArg(const std::string& arg);

	void Execute (void) const;

	bool operator==(const std::string& cmd)const
	{
		return(this->GetName()==cmd);
	}
};

Cmd.cpp

#include "Cmd.h"

Cmd::Cmd(void)
{
}

Cmd::Cmd(const std::string name, const int id, const int argcnt,void (*execute_function)(void) )
: cmd_name(name), cmd_id(id), cmd_argcount(argcnt), cmd_exe(execute_function)
{
	if (argcnt<0)
	{	
		std::cout<<"Ungueltige Anzahl von Argumenten"<<std::endl;
		cmd_argcount=0;
	}

}

Cmd::Cmd(const std::string name, const int id, const int argcnt, void (Flash_cmds::*execute_function)(const int& t) )
: cmd_name(name), cmd_id(id), cmd_argcount(argcnt),cmd_exe_arg(execute_function)
{
	if (argcnt<0)
	{	
		std::cout<<"Ungueltige Anzahl von Argumenten"<<std::endl;
		cmd_argcount=0;
	}

}

Cmd::~Cmd(void)
{
}

std::string Cmd::GetName (void) const
{
	return Cmd::cmd_name;
}

int Cmd::GetArgCount (void) const
{
	return Cmd::cmd_argcount;
}

void Cmd::Execute (void) const
{
	if(cmd_argcount==1)
		;//cmd_exe_arg(500);
	else
		cmd_exe();
}

void Cmd::setArg(const std::string& arg)
{
	cmd_arg=arg;
}

...?

ich hab den gcc compiler drauf version 4.4.5

Der hat AFAIK std::tr1::function<..> drin. Die würde ich auch benutzen!

// Abstrakte Basisklasse für alle möglichen Commands
class Command
{
public:
	virtual ~Command()
	{
	}

	void operator()()
	{
		execute();
	}

private:
	virtual void execute() = 0;
};

// Implementation für non-member Funktion mit einem Argument
template<typename ResultType, typename ArgumentType>
struct CommandNM1 : Command
{
	typedef ResultType( *FuncPtr)( ArgumentType );

	ResultType 				Result;
	ArgumentType 			Argument;
	FuncPtr					Function;

	CommandNM1( FuncPtr Func, ArgumentType Arg ) :
		Function( Func ),
		Argument( Arg ),
		Result( ResultType() )
	{
	}

	virtual void execute()
	{
		Result = Function( Argument );
	}
};

// Spezialisierung für non-member Funktionen mit einem Argument und ohne Rückgabewert
template<typename ArgumentType>
struct CommandNM1<void,ArgumentType> : Command
{
	typedef void( *FuncPtr)( ArgumentType );

	ArgumentType 			Argument;
	FuncPtr					Function;

	CommandNM1( FuncPtr Func, ArgumentType Arg ) :
		Function( Func ),
		Argument( Arg )
	{
	}

	virtual void execute()
	{
		Function( Argument );
	}
};

template<typename ResultType, typename ArgumentType>
Command* make_command( ResultType (*Func)( ArgumentType ), ArgumentType Arg )
{
	return new CommandNM1<ResultType,ArgumentType>( Func, Arg );
}

// Implementation für member Funktion mit einem Argument
template<typename ObjectType, typename ResultType, typename ArgumentType>
struct CommandM1 : Command
{
	typedef ResultType( ObjectType::*FuncPtr)( ArgumentType );

	ResultType 				Result;
	ArgumentType 			Argument;
	FuncPtr					Function;
	ObjectType&				Object;

	CommandM1( ObjectType& Obj, FuncPtr Func, ArgumentType Arg ) :
		Function( Func ),
		Object( Obj ),
		Argument( Arg ),
		Result( ResultType() )
	{
	}

	virtual void execute()
	{
		Result = (Object.*Function)( Argument );
	}
};

template<typename ObjectType, typename ResultType, typename ArgumentType>
Command* make_command( ObjectType& Obj, ResultType (ObjectType::*Func)( ArgumentType ), ArgumentType Arg )
{
	return new CommandM1<ObjectType,ResultType,ArgumentType>( Obj, Func, Arg );
}

void x( double y )
{
	int z = 0;
}

int f( double x )
{
	return x;
}

struct t
{
	int f( double x )
	{
		return x;
	}
};

int main()
{
	t theT;
	Command* c1 = make_command( f, 101.101 );
	Command* c2 = make_command( theT, &t::f, 101.101 );
	Command* c3 = make_command( x, 101.101 );

	(*c1)();
	(*c2)();
	(*c3)();
}

Hab mal was (nur so aus der Hüfte geschossen) gebastelt, was du benutzen könntest. Statt roher Zeiger wären smart pointer toll, eventuell kann man mit boost/TR1::function das noch schöner machen. Aber als Hinweis taugt´s allemal was.

vielen dank docshoe....ich versuch mich da mal durchzuarbeiten. mit templates hab ich noch eher wenig erfahrung.

Result( ResultType() )

was passiert hier???

Zeile 32:

Result( ResultType() )

was passiert hier???

Es wird die Member Variable Result mit dem Default-Konstruierten Wert von ResultType initialisiert.

pat.de schrieb:

Zeile 32:

Result( ResultType() )

was passiert hier???

Es wird die Member Variable Result mit dem Default-Konstruierten Wert von ResultType initialisiert.

vielen dank....habe es einfach mal mit int getestet.

zeile 44:

struct CommandNM1<void,ArgumentType> : Command

ist mir auch nicht so ganz klar geworden...

Edit:
Zeilennummer korrigiert

Jetzt habe ich das Problem, das ich den operator() mit evtl. rückgabewert und einem parameter aufrufen will.

Command* c1 = make_command( set_startaddress, "set_startaddress" ); 
(*c1)(400);

hab dazu erstmal versucht am Code-Abschnitt "Implementation für non-member Funktion mit einem Argument" zu fummeln:

// Implementation für non-member Funktion mit einem Argument
template<typename ResultType, typename ArgumentType, typename IdType>
struct CommandNM1 : Command<ResultType, ArgumentType>
{
    typedef ResultType( *FuncPtr)( ArgumentType );

    ResultType					Result;
    IdType						Id;
    FuncPtr						Function;

    CommandNM1( FuncPtr Func, IdType _id ) :
        Function( Func ),
        Id( _id ),

    {
    }

	virtual ResultType execute(ArgumentType Arg)
    {

		return Function(Arg);
    }

};

hab dann anschließend die Basisklasse erweitert:

// Abstrakte Basisklasse für alle möglichen Commands
template<typename ResultType, typename ArgumentType>
class Command
{
public:
    virtual ~Command()
    {
    }

    virtual ResultType operator()( ArgumentType _Arg)
    {
       return execute(_Arg);
    }

private:
	virtual ResultType execute(ArgumentType Arg) = 0;

};

und das Funktionstemplate dementsprechend verändert:

template<typename ResultType, typename ArgumentType, typename IdType>
Command<ResultType, ArgumentType>* make_command( ResultType (*Func)( ArgumentType ), IdType _Id )
{
    return new CommandNM1<ResultType,ArgumentType, IdType>( Func, _Id);
}

Beim Kompilieren kommt dann folgender Fehler:
Fehler 1 error C2955: "Command": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.
Fehler 2 error C2440: 'Initialisierung': 'Command<ResultType,ArgumentType> *' kann nicht in 'Command *' konvertiert werden
Fehler 3 error C3848: Ausdruck mit Typ 'Command' verliert beim Aufrufen von 'ResultType Command<ResultType,ArgumentType>::operator ()(ArgumentType)' möglicherweise einige const-volatile-Qualifizierer

Weiss leider nicht mehr weiter und wäre über eure Hilfe sehr dankbar...

Abgesehen davon sind Bezeichner wie _Arg oder _Id , die mit Unterstrich und Grossbuchstaben beginnen, für die Implementierung reserviert. Du solltest sie nicht benutzen.

struct Command
{
   int Result;
   double Argument;
   FuncPtr Func; 

   void execute()
   {
      Result = (*FuncPtr)( Argument );
   }
};

int main()
{
   Command c;

   c.Argument = 101.101;
   c.execute();
   int Ergebnis = c.Result;
}

Die verschiedenen Ableitungen von Command garantieren, dass ich Command als Basisklasse verwenden darf. Dazu gehört leider auch, dass Command eine Signatur haben muss, über das es alle möglichen Funktionen aufrufen kann, und das ist nun mal void execute() . Die Behandlung von Rückgabewerten oder Aufrufparametern muss irgendwie durch die entsprechenden abgeleiteten Klassen durchgeführt werden, deshalb haben hat CommandNM1 die Elemente Result und Argument .

Zusätzlich will ich noch Funktionen ohne Rückgabewert und Argumente übergeben, habe dazu den Quelltext wie folg erweitert:

template<>
struct CommandNM1<void,void> : Command
{
    typedef void( *FuncPtr)( void );

	string					   Id;
    FuncPtr                    Function;

    CommandNM1( FuncPtr Func, string Id_c ) :
		Id(Id_c),
        Function( Func )
    {
    }

    virtual void execute(const int& arg)
    {
        Function(  );
    }

	virtual void execute()
    {
        Function();
    }

	virtual string getId()
    {
        return Id;
    }

};

und die Funktion Command make_command( ResultType (Func)( ArgumentType ), ArgumentType Arg, string Id )

überladen:

template<typename ResultType, typename ArgumentType>
Command* make_command( ResultType (*Func)( ArgumentType ), string Id )
{
    return new CommandNM1<ResultType,ArgumentType>( Func, Id );
}

wenn ich jetzt

void test(void ){std::cout<<"hallo"; }

int main()
{

	Flash flash52401;
	int t=12;
	flash_init_52401(flash52401);

	Command* c1 = make_command(test ,"hallo");  ...

aufrufe sagt der compiler:
Fehler 1 error C2780: 'Command *make_command(ObjectType &,ResultType (__thiscall ObjectType::* )(ArgumentType),ArgumentType,std::string)': Erwartet 4 Argumente - 2 unterstützt
Fehler 4 error C2780: 'Command *make_command(ResultType (__cdecl *)(ArgumentType),ArgumentType,std::string)': Erwartet 3 Argumente - 2 unterstützt
Fehler 2 error C2784: "Command *make_command(ResultType (__cdecl *)(ArgumentType),std::string)": template-Argument für "überladener Funktionstyp" konnte nicht von "überladener Funktionstyp" hergeleitet werden.
Fehler 3 error C2784: "Command *make_command(ResultType (__cdecl *)(ArgumentType),std::string)": template-Argument für "überladener Funktionstyp" konnte nicht von "überladener Funktionstyp" hergeleitet werden.

bin am verzweifeln....

Jetzt habe ich folgendes Problem: Ich habe auch Funktionen mit Verweise bspw.

void set_startaddress(const int &addr)

...muss ich dafür auch wieder extra eine template-kalsse erstellen??