3. Problem bei Funktionszeiger!

Problem bei Funktionszeiger!

  • P

    Hallo!

    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!

    0
  • B

    Was spricht denn dagegen, den Adress-Operator zu verwenden wies in der Fehlermeldung angegeben ist?

    0
  • P

    das funktioniert leider auch nicht. ich habe in meinem quellcode den ich oben gepostet habe in der main die funktion test mal probiert zu übergeben und das funktioniert ohne Probleme...per adresse sowie per variable. liegt das problem evtl beim singleton-pattern?

    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);
    0

  • 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?

    0
  • P

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

    0

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

    0
  • P

    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

    0
  • T

    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

    0

  • 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?

    0
  • P

    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.

    0
  • T

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

    0
  • L

    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

    0 

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

    0
  • P

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

    ...?

    0
  • T

    ich hab den gcc compiler drauf version 4.4.5

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

    0
  • P

    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.

    0
  • P

    Zeile 32:

    Result( ResultType() )

    was passiert hier???

    0
  • T

    pat.de schrieb:

    Zeile 32:

    Result( ResultType() )

    was passiert hier???

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

    0
  • P

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

    0

  • 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

    0
Anmelden zum Antworten