Problem bei Funktionszeiger!

pat.de

du hattest den header vorher nur einmal eingebunden

aus irgendeinem grund hat vs2008 die source-datei(command.ccp), die command.h inkludiert, nicht kompiliert und deswegen auch keinen fehler angezeigt(weil

du hast den header mit der Definition einer nicht-inline, nicht-template Funktion in zwei Übersetzungseinheiten eingebunden und damit in beiden ÜEs eine Definition dieser Funktion.

)

VS2010 hat diese datei(command.cpp) kompiliert und erkannt dass, ich eine nicht-template Funktion in zwei Übersetzungseinheiten eingebunden habe und hat daraufhin einen fehler ausgegeben. fazit: template und nicht template funktionen in der header deklariert und in der source-datei definiert... jetzt klappts

pumuckl

pat.de schrieb:

fazit: template und nicht template funktionen in der header deklariert und in der source-datei definiert... jetzt klappts

Nur solange, bis du die template-Funktionen außerhalb der source benutzt, in der sie definiert werden. Von templates müssen nämlich bei der Instantiierung immer die kompletten Definitionen vorliegen.

pat.de

Ausserdem gehört Id in die Basisklasse Command, damit sparst du dir die virtuelle getId Methode und musst nicht in jeder Ableitung das Attribut Id bereitstellen. Ich würde auch keinen Vergleichsoperator für Command/std::string Vergleiche bereitstellen, dafür hast du doch die getId Methode.

habe jetzt getid entfernt und nur den == operator dringelassen, weil ich ja strings miteinander vergleichen will und dann bei gleichheit, soll das kommando(die funktion) ausgeführt werden.

Warum hast du in Command, CommandNM1 und Command die Methode execute( const int& arg ) eingefügt? Der Sinn hinter dem Ganzen Konstrukt ist doch, dass Command selbst keine Ahnung davon haben sollte, wie das tatsächliche konkrete Command ausgeführt werden soll und lediglich die execute() Methode aufruft. Wenn du jetzt wieder unterschiedliche Methoden für Aufrufe des konkreten Commands benutzt brauchst du den ganzen Aufwand nicht zu treiben.

ich hab im moment noch keine ahnung, wie ich über den basisklassenzeiger der kommandos auf die argumente zugreifen kann. die basisklasse weiss ja nicht, mit welchem typ das argument deklariert ist.

dann hat sich grad noch folgende frage ergeben: In manchen Templates(abgeleitete Klasse) kann ich den Member Id der basisklasse über die initialisierungsliste ohne Probleme initialisieren und in anderen muss ich den standartkonstruktor aufrufen....warum?

// Abstrakte Basisklasse für alle möglichen Commands
class Command
{
public:

	Command(const string& Id_c): Id(Id_c){}

    virtual ~Command()
    {
    }

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

	bool operator==(const string& sId)
    {
		if(sId.compare(Id))
			return false;
		else
			return true;
    }

private:

	string Id;
	virtual void execute() = 0;

};

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

    ResultType                 Result;
    ArgumentType			   Argument;
    FuncPtr                    Function;

    CommandNM1(const string& Id_c, FuncPtr Func, ArgumentType Arg  ) :
		Id(Id_c),				//WIESO IST DAS ELEMENT HIER DIREKT INITIALISIERBAR?
        Function( Func ),
        Argument( Arg ),
        Result( ResultType() )
    {
    }

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

};

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

    ArgumentType               Argument;
    FuncPtr                    Function;
    ObjectType&                Object;

    CommandM1(const string& Id_c, ObjectType& Obj, FuncPtr Func, ArgumentType Arg ) :
		Command(Id_c),//WIESO HIER NUR ÜBER KONSTRUKTOR?
		Object( Obj ),
        Function( Func ),
        Argument( Arg )

    {
    }

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

};

DocShoe

Weil das Template des ersten Beispiels nie instantiiert wird und der Code daher nie übersetzt wird.

Warum willst du auf die Argumente der Commands zugreifen? Alles, was ein Commandobjekt zur Ausführung braucht, besitzt es selbst (guck dir mal die Definition von CommandNM1::execute() an).

pat.de

die argumente sollen doch dynamisch sein... zur laufzeit sollen sich die werte des arguments ändern.

DocShoe

Die Command Objekte werden erzeugt, benutzt und anschließend zerstört. Wenn du also 2x eine bestimmte Funktion aufrufen möchtest erzeugst du zwei Command Objekte vom gleichen Typ, statt nur eins zu erzeugen und das wiederzuverwenden.

pat.de

ich hatte mir das so vorgestellt, dass ich zu beginn meine commando-objekte erzeuge

void cmd_init(void)
{
	Command* set_startaddr= make_command("set_startaddr",flash_cmds, &Flash_cmds::setStartaddr,0  );
	Command* set_endaddr= make_command("set_endaddr",flash_cmds,&Flash_cmds::setEndaddr, 0 );
	//Command* set_debug= make_command(flash_cmds,&Flash_cmds::set, 1,"set_debug");
	//Command* set_lock= make_command(flash_cmds,&Flash_cmds::,0 ,"set_lock");
	Command* set_progcontent= make_command("set_progcontent",flash_cmds,&Flash_cmds::setProgcontent,0 );
	Command* set_flashmode= make_command("set_flashmode",flash_cmds,&Flash_cmds::setFlashmode,0 );

	Command* start_read = make_command("start_read",flash_cmds,&Flash_cmds::start_read );
	Command* start_program = make_command("start_program",flash_cmds,&Flash_cmds::start_program );
	Command* start_masserase = make_command("start_masserase",flash_cmds,&Flash_cmds::start_masserase );
	Command* start_verfiy = make_command("start_verify",flash_cmds,&Flash_cmds::start_verify );
	Command* start_compare = make_command("start_compare",flash_cmds,&Flash_cmds::start_compare );

}

anschließend werden in einem empfangspuffer die empfangenen strings gespeichert. der erste string wird aus dem puffer geladen und überprüft, ob es sich um ein befehl oder argument handelt. falls befehl, dann prüfen ob befehl argument benötigt und nächsten string aus puffer holen und prüfen ob es wirklich ein argument ist. falls es zutrifft wird befehl+ evtl argument ausgeführt.

die befehlsüberprüfung soll mit dem vergleichsoperator durchgeführt werden
bspw.

if(empf.vec==set_startaddr)
{
set_startaddr.arg(++empf.vec);
set_startaddr();
}

DocShoe

Dann brauchst du den ganzen Firlefanz hier überhaupt nicht. Wenn du beim Eingang jedes Telegramms das Telegramm parst, um den Typ der aufgerufenen Funktion zu bestimmen, und dann die Funktion über einen Funktionspointer aufzurufen, dann kannst du die Funktion auch direkt aufrufen. Ich verstehe zwar, was du technisch vorhast, aber irgendwie verstehe ich die Absicht dahinter nicht.

pat.de schrieb:

if(empf.vec==set_startaddr)
{
set_startaddr.arg(++empf.vec);
set_startaddr();
}

Warum nicht sofort

if( empf.vec == set_startaddr )
{
   FlashDingens.set_startaddr( SomeArg );
}

Wofür Commands und Funktionszeiger?

pat.de

das hatte ich ja schon auch schon vorher... aber dann wollte ich das noch mit den funktionszeigern ausprobieren. zur übung ist ja sowas nicht schlecht, falls man später mal vor so einem problem steht und dann nicht weiter weiss.

pat.de

DocShoe schrieb:

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 .

ich weiss noch nicht so genau, wie ich jetzt an den result-member rankomme. klar könnte ich jetzt für jedes objekt

dynamic_cast

anwenden, aber ist das die einzige lösung???

...komme leider nicht weiter und wäre über eure hilfe sehr dankbar