3. verständnisfrage funktionspointer

verständnisfrage funktionspointer

  • W

    folgende aufgabenstellung:
    wir sollen mithilfe von tokens einen string aufteilen und berechnen abhängig vom trennoperator (123+456)!kein ding, hab die beiden zahlen ind token[0] und token[1] gespeichert und kann diese ja jetzt addieren!in der aufgabenstellung wird aber verlangt:

    "mit einem switch über den ASCII code des operator könnnen sie einem funktionpointer die passenden bearbeitungsfunktion zb int fplus(int,int) zuweisen und diese anschliessend ausführen!"

    wobei ich alles genauso gemacht hätte, via siwtch, einer funktion,etc...
    da ich vorher nie etwas von funktionspointern gehört habe (wohl schon von pointern)
    komme ich nicht dahinter, was der nutzen sein soll bzw wie das ganze überhaupt funktionieren soll?

    wäre dankbar für jede hilfestellung!

    0
  • M

    ein Funktionspointer ist sowas wie ein Zeiger auf eine Variable, nur dass er auf eine Funktion zeigt.

    Die Aufgabe ist also sozusagen:
    Erstelle eine Variable (funktionspointer) der auf eine Funktion zeigt. Die Funktion auf die er zeigt, soll abhängig sein vom opoerator in der mitte des ausdrucks 122+456. Funktionspointer definierst du so:

    typedef RÜCKGABEWERT (*TYP)(ARGUMENTLISTE)

// besispiel, ein Zeiger auf eine Funktion die zwei ints als parameter hat und ein float zurückgibt:
typedef float (*ZeigerAufFloatIntInt)(int, int);

float MyFunction(int a, int b)
{
  return (float)a / b;
}

ZeigerAufFloatIntInt functionPointer = &MyFunction;

// jetzt kannst du mit dem funktionspointer ganz normal umgehen wie mit einer funktion:
functionPointer(1,1); // ruft MyFunction(1,1) auf

    Hoffe, konnte helfen

    0
  • W

    die zuweisung wird bei uns im script etwas anderes beschrieben:

    void (*f_ptr)(int, char)=NULL;
void fkt(int a,char b)
{
tudiestudas
}

main
{

	f_ptr=fkt;
        f_ptr(c,d);	

}

    unterscheidet sich zu deinem

    ZeigerAufFloatIntInt functionPointer = &MyFunction;

    wieso?
    und was soll dieses =NULL?

    0
  • M

    ich hab das ganze mit einem typedef gelöst.
    Du hast quasi sowas hier gemacht, im übertragenen sinne:

    // Erstelle einen Zeiger auf ein Objekt
std::map<std::string, std::vector<std::string> >* mymap = NULL;

// und fülle zeiger
mymap = new std::map<std::string, std::vector<std::string> >;

    meine version:

    // erstelle neuen typ, der nicht so komplex aussieht.
typedef std::map<std::string, std::vector<std::string> > MyMapType;

// erstelle zeiger auf typ und fülle ihn
MyMapType* mymap = new MyMapType;

    Ich hab also den Funktionspointer als typedef definiert, damit wird es durchsichtiger, weil man eien Typ so besser lesen kann als das
    void (*myfunctionpointer)(int, int);

    Deshalb. Ansonsten hab ich das selbe gemacht. Das =NULL lässt deinen Funktionspointer f_ptr am Anfang auf nichts zeigen, ist eben guter standard zeiger erstmal mit NULL zu initialisieren, wenn sie nich gleich benutzt werden.

    so, pizza essen 🙂
    Maxi

    0
  • W

    ok den ersten teil muss ich nicht verstehen oder 😉

    also kann ich meinen code so auch verwenden?

    guten hunger

    0
  • M

    ja kannst du 🙂

    0
  • W

    und was genau sind jetzt die vorteile von funktionspointern?

    und wie schaffe ich es jetzt, an diese funktion meinen char array, mit den gespeicherten tokens, weiterzugeben?

    ich habe die beiden tokens von 123+456

    token[0] = strtok(string, separator);        
    token[1] = strtok(NULL, separator);

    hier gespeichert und will durch ne switch/case anweisung die entsprechende fkt aufrufen

    switch(separator)
	{
	case '+':  f_plus(token); break;
		case '-':  f_minus(token);  break;
			case '/':  f_div(token); break;
				case '*':  f_mal(token);break;
				     default: printf("falscher operator");

	}

    kann ich denn einfach so den token array weitergeben?bekomme nämliche eine fehlermeldung

    deklaration

    void (*f_plus)(char[])=NULL;

void fkt(char[])
{
tudiestudas
}

main

{
f_plus=fkt;
}
    0
  • M
     

    // deklaration von plus, minus, geteilt und multiplizieren-funktion
// alle mit signatur void fkt(char*)
int main()
{
  char separator;
  // ... separator irgendwie mit +, -, *, / befüllen

  // den funktionspointer erstellen
  void (*fktpointer)(char*);
  switch(separator)
  {
  case '+':
    fktpointer = &FunktionFuerPlus;
    break;
  case '-':
    fktpointer = &FktFuerMinus;
    break;
  // ...
  default:
    fktpointer = NULL;
  }

  // hier rufst du dann jetzt deine funktion auf, die du vorher berechnet hast.
  fktpointer(token);

  // Der vorteil davon ist jetzt, dass du an späterer Stelle im Programm 
  // die Funktion nochmal aufrufen kannst, ohne wieder die ellen
  // lange switch-anweisung zu haben.

  // mach noch was blalblabla

  // fjdkla fjdsaköl

  fktPointer(tokens);

  // Eine andere Anwendung ist auch, wenn du die selbe Funktion für mehrere
  // verschiedene Daten aufrufen willst, dann kannst du das mit funktions
  // pointern machen. Also du befüllst den pointer einmal mit der richtigen
  // funktion (ein switch) und rufst den pointer dann mit allen möglichen 
  // Daten auf.  
}

    Gruß, Maxi

    0
  • W

    hast du eine idee wie man die beiden token so umwandeln kann, bzw ihre werte, das man sie anhand von funktionen übergeben kann?ich meine ich will ja mit den beiden token rechnen, aber momentan sind sie ja nicht als int sondern als char gespeichert!

    0
Anmelden zum Antworten