Pointer auf Funktion eine Adresse zuweisen

[Fischle (Gast)]

Hi,

ist es möglich in C einem Funktionspointer eine fixe Adresse zuzuweisen?

Ich möchte zur Laufzeit den Code in einem reservierten Ram Bereich 
ändern und benötige einen Einsprungpunkt. Zum Beispiel die Adresse 
0x1234, die sich ebenfalls in einem reservierten Ram Bereich befindet.

//So würde ich es bei Variablen machen:
int* ptr;
ptr=(int*) 0x1234;

Aber wie funktioniert es bei ganzen Funktionen?
vielleicht so:

//.h Datei
void funktion(void);

//.c Datei
void funktion ()
{
// tu was
}

void main()
{
void (*funktionsPointer)(void) = (void*) 0x1234

funktionsPointer=funktion;
//Aufruf von "funktion" über einen Pointer, der fix an der Adresse 0x1234 abgelegt ist
(*funktionsPointer)();
}

Der Compiler sagt ich kann den Pointer so nicht initialisieren weil sich 
"void*" nicht eignet um den Typ "void(*)(void)" zu initialisieren ...
Kann mir jemand sagen ob das generell nicht geht, oder nur ein 
Syntaxproblem ist.

Liebe Grüße
Fischle

[user (Gast)]

Du kannst dem Linker sagen wo er welche Funktion hinlegen soll.

[Rainer B. (katastrophenheinz)]

Hi, Syntaxproblem.
so geht's:

typedef void ( *fPointer ) ( void );
...
fPointer func = ( fPointer ) 0x1234;
...
func();

Gruss, Rainer

[Sag ich nicht (Gast)]

Oder wenn du dich von der Es-muss-lesbar-sein Fraktion nicht erwischen 
lässt:
void (*funktionsPointer)(void) = (void (*)(void)) 0x1234;

[Fischle (Gast)]

Hi,

vielen Dank für eure Antworten!
Die Lösung für das Syntaxproblm funktioniert, es wird kompiliert.

Gruß
Fischle

[W.S. (Gast)]

Fischle schrieb:
> ist es möglich in C einem Funktionspointer eine fixe Adresse zuzuweisen?

na klar doch. Sogar richtige konstante (fixe) Strukturen kann man 
hinkriegen. Hier ein kleiner Ausschnitt aus dem menüsystem der Lernbetty 
(siehe Codesammlung..):

#define RCST  const struct TMenuItem
struct TMenuItem
{ struct TRect R;
  const struct TMenuItem *davor;
  const struct TMenuItem *danach;
  const struct TMenuItem *Owner;
  const struct TMenuItem *Members;
  dword Flags;
  void  *Data;
  void  (*OnKey)  (RCST* self, word *aKey);
  void  (*OnEvent)(RCST* self, word *aEvent);
  void  (*Draw)   (RCST* self);
};

und

RCST Appfinder_Liste =
{ /* l-t-r-b */ { 0, 20, 127, 159},
  /* davor  */  &Appfinder_Uhrzeit,
  /* danach */  &Appfinder_exit,
  /* Owner  */  &Appfinder_Mainmenu,
  /* Members*/  0,
  /* Flags  */  opaque | canFocus,
  /* *Data  */  0,
  /* OnKey  */  Appfinder_Liste_OnKey,
  /* OnEvent*/  Appfinder_Liste_OnEvent,
  /* Draw   */  Appfinder_Liste_Draw
};

und

void Appfinder_Liste_OnEvent (RCST *self, word *aEvent)
{.....
}



Die 3 Funktionen OnKey, OnEvent und Draw sind nette Beispiele, wie man 
sowas deklariert und wie man es benutzt.

UND: Ich meine, sowas ist durchaus lesbar und verständlich geschrieben - 
im dezenten Gegensatz zu
"void (*funktionsPointer)(void) = (void (*)(void)) 0x1234;"

gelle?

W.S.

[Rainer B. (katastrophenheinz)]

@Sag ich nicht: Da isses schon passiert :p !

[Fischle (Gast)]

Hi,

danke nochmals an alle Antwortenden! Dieses Forum ist klasse :)

Nochmals ein kurzer Raport meiner Lösung:
MSP430g2553 auf Launchpad an CCSEv4 (nammi) ....

//Im MeinFile.c File bei den globalen Variablen
#define IRGENDWASHALT
typedef void (*fktPtr)(void);
extern fktPtr ptr_MeineFunktion;

...

//Im msp430g2553.cmd File direkt unter den Includes
#include MeinFile.h
ptr_MeineFunktion = 0x0200 //Erste RAM-Adresse beim MSP430G2553

...

//Im MeinFile.h stehen die defines welche zur Aufteilung des 
//Speicherplatzes verwendet werden
#define FKTPTR_START_ADDR             (0x0200)
#define FKTPTR_END_ADDR               (0x020F)
#define FKTPTR_LEN                    (0x0010)//Platz für 8 Pointers
//Der Rest vom RAM beginnt dann natuerlich erst bei
#define RAM_START_ADDR                (0x0210)
//Und die Länge von NORAMLRAM_LEN muss um 16Bit gekürzt werden


...

//Wieder im msp430g2553.cmd File ersetzt man die eine Zeile
RAM               : origin = 0x0200, length = 0x0200
//Durch diese beiden Zeilen
FKTPTR            : origin = FKTPTR_START_ADDR, length = FKTPTR_LEN
NORAMLRAM         : origin = NORAMLRAM_START_ADDR, length =NORAMLRAM_LEN
//Dadurch wird der Speicherbereich für die Variablen vom "NormalenRAM"
//getrennt und die extra dort plazierten Vars werden nicht aus Versehen
//ueberschrieben

Gruß
Fischle

[Fischle (Gast)]

Hi,

nächstes Problem ;)
Kann sein, dass W.S. das in seinem Beitrag bereits erklärt hat, ich hab 
das BSP aber noch nicht ganz verstanden ...

Ich würde gerne -ebenfalls über den Funktionspointer- eine Funktion 
aufrufen, nur diesmal mit Parametern.
Ausgedacht hab ich mir das so:

//Probiert hab ich es so wie zuvor nur eben mit Parameter.
typedef void (*fkt_mit_ParameterPtr)(int*);
extern fkt_mit_ParameterPtr ptr_MeineFunktionMitParameter;//Ramadresse=0x0206

//Zeiger auf ein int, weil ich den übergebenen Wert 
//ebenfalls an einer festen Speicheradresse 
//zwischengelagert haben möchte.
extern int *Parameter;//Ramadresse=0x0208

//Funktionsdeklaration
void MeineFunktionMitParameter (int *Parameter)
{
Parameter++; //irgendwas
}

//Verknüpfung der Funktion mit dem Funktionsointer in main()
ptr_MeineFunktionMitParameter = MeineFunktionMitParameter;

//Funktionsaufruf im dynamischen Bereich
//Als Parameter soll ein Intwert verwendet werden 
//Diesen moechte ich da gern als Zahl eintragen können
(*ptr_MeineFunktionMitParameter)(7)

Aber der Compiler mag es nicht ...

Dann dachte ich an ein Call by Reference, also sowas wie:

(*ptr_MeineFunktionMitParameter)(&7)

Dafür komm ich wahrscheinlich in die Hölle, aber funktionieren tut es 
natürlich auch nicht ...

Weiß jemand Rat? (außer, dass ich noch viel zu lernen hab :D)

Gruß
Fischle

[Fischle (Gast)]

Der Aufruf des Funktionspointers braucht natürlich noch ein Semikolon

(*ptr_MeineFunktionMitParameter)(&7);

[Rainer B. (katastrophenheinz)]

Hi,
...aber in den heißesten Teil der Hölle.
Ist doch eigentlich einfach:
7 ist kein int, sondern eine Compilezeit-Konstante. 
Compilezeit-Konstanten belegen keinen Speicherplatz im Sinn von 
Variablen, also kann man sie auch nicht referenzieren. Was soll da 
rauskommen? D.h. du musst erst einen int-wert mit 7 initialisieren und 
dann kannst du mit & auf diesen int-Wert referenzieren.

Und das hier

//Funktionsdeklaration
void MeineFunktionMitParameter (int *Parameter)
{
Parameter++; //irgendwas
}

wird auch nicht das tun, was du erwartest. Überleg mal selbst, warum.

[Fischle (Gast)]

Hi,

Logisch, das ist Quatsch ...
Darf man das in C so machen?:

//Funktionsdeklaration
void MeineFunktionMitParameter (int *Parameter)
{
*Parameter++; 
}

Ich teste mal schnell das mit dem Funktionsaufrun und dem &-Operator ...

[Georg G. (df2au)]

Fischle schrieb:
> *Parameter++;

K&R, Kapitel 5

Setz Klammern, sonst passiert das, was du nicht willst.

[Rainer B. (katastrophenheinz)]

>Darf man das in C so machen?
Man darf alles das machen, was der Compiler nicht anmeckert.
Die eigentliche Frage ist "Was willst du machen?"
Zur weiteren Verwirrung:

*Parameter++; 
(*Parameter)++; 
*(Parameter++);

Alles syntaktisch ok, der Compiler frisst es.
Aber was ist der Unterschied? Und welche der unteren beiden 
Schreibweisen entspricht der oberen?
Gruss, Rainer

[Fischle (Gast)]

Das war nur ein Beispiel (mit einem dummen Fehler drin) was in der 
Funktion passieren soll ... aber ich lerne immer gerne was dazu :)
Also, hier meine Interpretation:

*Parameter++;//Keine Ahnung was hier passieren wird ...
//Die Punkt vor Strich Regel kann ich nicht anwenden oder? ;)
(*Parameter)++;//Increment des Inhalts vom ptr Parameter 
*(Parameter++);//Increment des ptr Parameter und dann ein Zugriff ohne Effekt?

wirklich verwenden möchte ich den Parameter nacher so:

switch(*Parameter)
{
   case 1:
         foo1();
         break;
   case 7:
         foo2();
         break;
   //usw...
}

Was mich aber auch noch beschäftigt, ist die Frage ob (Codeabschnitt von 
vorhin)

typedef void (*fkt_mit_ParameterPtr)(int*);
extern fkt_mit_ParameterPtr ptr_MeineFunktionMitParameter;//Ramadresse=0x0206

//Zeiger auf ein int, weil ich den übergebenen Wert 
//ebenfalls an einer festen Speicheradresse 
//zwischengelagert haben möchte.
extern int *Parameter;//Ramadresse=0x0208

//Funktionsdeklaration
void MeineFunktionMitParameter (int *Parameter)
{
//swich case anweisung mit Inhalt von Parameter
}

tatsächlich dafür sorgt, dass die 7 an die Speicheradresse 0x028 gelegt 
wird, wenn ich die Funktion mittels

i=7;
(*ptr_MeineFunktionMitParameter)(&i);

aufrufe.

[Rainer B. (katastrophenheinz)]

Hi, Interpretation der unteren beiden korrekt.
Um festzustellen, was der obere macht, brauchst du die Präzedenzregeln 
für unäre Operatoren, gibt's in dem bereits erwähnten K&R-Buch und 
bestimmt auch im Netz. Da ++ eine höhere Präzendenz als * hat, 
entspricht die Schreibweise ohne Klammern der unteren geklammerten. Aber 
denk dir nichts dabei, wenn du die nicht im Kopf hast, ich muss auch 
noch nachgucken.

Zu deiner Frage. Natürlich kannst du einen int-Pointer auf eine 
bestimmte Adresse zeigen lassen, genauso wie du das mit dem 
Funktionspointer gemacht hast. Du musst es nur tun (ich hab die Stelle 
zumindest nicht gesehen )

int *ptr = (int *)0x208; // Zeigt auf 0x208
(*ptr)++;                // Zählt die int-variable in 0x208 ff eins hoch

ptr kannst du nach der Zuweisung natürlich auch wieder als 
Funktionsparameter übergeben.

http://www.mikrocontroller.net/articles/Zeiger

Gruss, Rainer

[Fischle (Gast)]

Hi,

Die Adresszuweisung passiert hier:

extern int *Parameter;//Ramadresse=0x0208
//Im Linkerskript steht dann noch 
Parameter=0x0208; //hab ich oben nicht extra dazugeschrieben ...

Der Kniff mit dem

int i=7;
(*ptr_MeineFunktionMitParameter)(&i);

beim Aufruf des Funktionspointers funktioniert zwar, nur passiert da 
etwas, dass ich nicht will ...
Die Deklaration

int i=7;

passt bei mir nicht ins Konzept, da ich zur Laufzeit meinen Ramspeicher 
löschen will und komplett andere Funktionen da hineinkopieren möchte. 
(ich weiß, dass man so nicht seine Freitagabende zubringen sollte ...)
Deshalb sind im "Laufzeitdynamischen" (ich nenn das mal so) Code keine 
Deklarationen möglich.

Natürlich könnte ich das auch über:

//Ein globaler Pointer für die Werteübergabe
*Pointer=7;
//Aufruf einer Voidfunktion
(*MeineFunktion)();

//und spaetere Verarbeitung des globalen Pointers machen
void MeineFunktion(){
//swich case Verarbeitung von *Pointer
}

machen, aber

(*ptr_MeineFunktion)(7);

wäre natürlich wesentlich schöner und benutzbarer ...

Zum Beispiel wäre das ne Lösung:

void Meine Funktion (int wert){
&wert=Pointer; //die Adresse von wert soll 0x0208 sein
}

Mal abgesehn davon, dass ich dafür wieder in die C-Hölle komme und es 
nich kompiliert wird, könnte ich so zur Laufzeit erstellte Variablen auf 
Fixadressen umbiegen und so den Crash vermeiden, wenn ich meinen Ram 
lösche und mit anderen Funktionen (und Variablen) beschreibe.

Wie könnte ich das angehen?

[Karl H. (kbuchegg)]

Fischle schrieb:

> Was mich aber auch noch beschäftigt, ist die Frage ob (Codeabschnitt von
> vorhin)
>

> typedef void (*fkt_mit_ParameterPtr)(int*);
> extern fkt_mit_ParameterPtr 
> ptr_MeineFunktionMitParameter;//Ramadresse=0x0206
> 
> //Zeiger auf ein int, weil ich den übergebenen Wert
> //ebenfalls an einer festen Speicheradresse
> //zwischengelagert haben möchte.
> extern int *Parameter;//Ramadresse=0x0208
> 
> //Funktionsdeklaration
> void MeineFunktionMitParameter (int *Parameter)
> {
> //swich case anweisung mit Inhalt von Parameter
> }
>

> tatsächlich dafür sorgt, dass die 7 an die Speicheradresse 0x028 gelegt
> wird, wenn ich die Funktion mittels

Was willst du wirklich?
Irgendwie hab ich das Gefühl dir ist noch nicht so ganz klar, was da 
eigentlich passieren soll.

Was soll jetzt eigentlich über die Funtkionsschnittstelle gehen?
Die Adresse an die der Wert hinsoll, oder der Wert selber.

Wenn zweiteres

  (*ptr_MeineFunktionMitParameter)(7);

void MeineFunktionMitParameter (int Wert)
{
  *Parameter = Wert;
}

Der erste Fall, eine Adresse wird übergeben, macht nur dann Sinn, wenn 
du auch etwas hast, was eine Adresse hat (oder die Adresse selber). 7 
hat keine Adresse. 7 ist eine Konstante und existiert als solches nicht 
im Speicher.

[Rainer B. (katastrophenheinz)]

Hmm, ich bin mir nicht sicher, ob ich dein Problem richtig verstehe.

Wenn das mit deinem Linkerskript funktioniert, dann hast du sofort, ohne 
dass du noch was dazu tun musst, mit der int*-Variablen "Parameter" 
einen int-Pointer, der auf 0x208 ff zeigt. Den kannst du sofort 
verwenden, als Parameter für deine Funktion, die einen int* erwartet 
oder als ganz normale int-Variable per Dereferenzierung: *Parameter=12

D.h. du schreibst dann einfach

ptr_MeineFunktionMitParameter(Parameter);

[Fischle (Gast)]

Hi,

anscheinend hab ich mal wieder im Kreis gedacht?

Mit der Funktionsdeklaration

void MeineFunktion(int Wert)
{
//verarbeite Wert
}

und dem Aufruf

(*ptr_MeineFunktion)(7);

tut der Code was er soll und auch beim Austausch des Ramspeicherinhalts 
kommt es zu keinem Absturz ...

Ist der Aufruf einer Funktion über ein Funktionspointer sozusagen ein 
"Call by Reference"?


Gruß
Fischlein

[Rainer B. (katastrophenheinz)]

Fischle schrieb:
> Ist der Aufruf einer Funktion über ein Funktionspointer sozusagen ein
> "Call by Reference"?
Nein, es macht überhaupt keinen Unterschied, ob du deine Funktion direkt
über MeineFunktion(7) oder ptrMeineFunktion(7) aufrufst. Du Musst es 
nicht einmal so komplex schreiben wie du es oben getan hast, d.h. 
explizite Dereferenzierung und Klammern kannst du auch weglassen. Das 
geht, weil auch "MeinFunktion" selbst aus Compliersicht schon ein Zeiger 
auf eine Funktion ist, Dereferenzierung und Aufruf macht der Compiler 
automatisch, wenn er Klammern und ggf Funktionsparameter hinter dem 
Funktionsnamen findet.

In C werden Aufrufparameter von Funktionen grundsätzlich immer als Kopie 
des Aufrufparameters übergeben, also call-by-value. D.h. für die Dauer 
der Funktionsausführung arbeitest du mit einer Kopie des übergebenen 
Wertes. Aus deiner Konstanten 7 wird während der Funktionsausführung ein 
Funktionsargument in Form einer int-Variable (weil du das im 
Funktionskopf so festgelegt hast)  mit dem Wert 7. Um das Ganze noch 
weiter zu komplizieren: Funktionsargumente unterscheiden sich in nichts 
von normalen Variablen, außer dem Umstand, dass sie nach jeder 
Funktionsausführung wieder gelöscht (=vom Stack geräumt) werden. Damit 
kannst du dann auch legal solche Sachen machen wie

void Keks(int param)
{
   for ( ; param > 0 ; param-- )
      printf("Param=%d\n",param);
}

int main(void)
{
   Keks(7);
   Keks(99);
}

Wenn du explizit festlegen willst, dass ein Funktionsparameter wie eine 
Konstante behandelt werden soll (in dem Fall als Laufzeitkonstante, denn 
der Aufrufmechanismus "Wertkopie" bleibt), dann kannst du das dem 
Compiler über das Wort "const" mitteilen, also im obigen Beispiel "const 
int param". Probier aus, was der Compiler dann sagt.

Gruss, Rainer