Problem bei Funktionszeiger!

DocShoe

Der Aufruf passt auch nicht zum Konstruktor der Klasse Cmd. Der nimmt nur freie Funktionszeiger entgegen, keine Zeiger auf Member Funktionen.

Was genau hast du denn eigentlich vor?

pat.de

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...

DocShoe

pat.de schrieb:

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).

pat.de

Vielen Dank für deine Hilfe....

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

theta

Einzelne Libraries aus Boost sollten auch unter embedded Linux laufen (wenn nicht sogar alle).

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

DocShoe

Das Problem ist nicht das Zielsystem, sondern der Compiler. Wenn der mit boost klarkommt enthält das Executable sämtlichen ausführbaren Code, da spielt das Target keine Rolle (vorausgesetzt, man linkt statisch).
Die Frage ist nur, ob deine Vorgaben die Benutzung externer Bibliotheken erlauben, oder darfst du benutzen, was du willst?

pat.de

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.

theta

pat.de schrieb:

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<...>

lk

pat.de schrieb:

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

DocShoe

// 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.

pat.de

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;
}

...?

theta

ich hab den gcc compiler drauf version 4.4.5

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

pat.de

DocShoe schrieb:

// 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.

pat.de

Zeile 32:

Result( ResultType() )

was passiert hier???

theta

pat.de schrieb:

Zeile 32:

Result( ResultType() )

was passiert hier???

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

pat.de

theta schrieb:

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...

DocShoe

Die Spezialisierung ist notwendig, weil das generische CommandNM1 Template eine Membervariable vom Typ ReturnType anlegt (siehe Z. 25). Wenn die aufzurufende Funktion keinen Rückgabewert hat (also void), dann würde ReturnType durch void ersetzt. Der Standard verbietet allerdings Variablen vom Typ void , und das verhindert die Spezialisierung.

Edit:
Zeilennummer korrigiert

pat.de

Vielen Dank nochmal....

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...

Nexus

Command ist kein Typ, sondern ein Template. Für einen gültigen Typen musst du die Template-Argumente angeben.

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

DocShoe

Die execute() Methode habe ich absichtlich ohne Rückgabewert und Parameter implementiert, dafür ist sie ja virtuell. Wenn du Parameter oder Rückgabewerte brauchst werden die als Member des konkreten Command Typen realisiert. Vereinfacht sieht das dann so aus:

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 .