Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

1

16.12.2009, 15:09

Funktionszeiger (Vorteile?)

Hallo liebe Mitglieder,

bin gerade über das Listing 10.2 von Heiko gegangen. Da erklärt er Funktionszeiger. Ich verstehe aber nicht den Vorteil, den er mir da versucht nahe zu bringen. Er erzählt etwas von Schleifen und Switch-Konstrukten die wir benutzen müssten um zur Laufzeit zu entscheiden, welche Funktion gewählt werden soll (?).

Es geht hierbei um folgendes Listing:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// C++ für Spieleprogrammierer

// Listing 10.2

// Funktionszeiger

//


#include <iostream>

using namespace std;

// Prototypen

//

int addieren       (int a, int b);
int multiplizieren (int a, int b);

// Hauptprogramm

//

int main ()
{
  // Funktionszeiger

  //

  int (*pFunktion) (int a, int b);

  // Variablen zum Rechnen

  //

  int Ergebnis = 0;
  int Wert1 = 3;
  int Wert2 = 7;

  // Funktionszeiger auf Funktion "addieren"

  pFunktion = addieren;

  // Funktion "addieren" über Funktionszeiger aufrufen

  Ergebnis = pFunktion (Wert1, Wert2);

  cout << "Ergebnis: " << Ergebnis << endl;

  // Funktionszeiger auf Funktion "multiplizieren"

  pFunktion = multiplizieren;

  // Funktion " multiplizieren" über Funktionszeiger aufrufen

  Ergebnis = pFunktion (Wert1, Wert2);

  cout << "Ergebnis: " << Ergebnis << endl;

  return (0);
}

// Addieren

//

int addieren (int a, int b)
{
  return (a + b);
}

// Multiplizieren

//

int multiplizieren (int a, int b)
{
  return (a * b);
}


OK. Ohne Funktionszeiger würde es ja dann wahrscheinlich so aussehen:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
using namespace std;

int addieren(int Wert1, int Wert2);
int multiplizieren(int Wert1, int Wert2);

int main()

{
    
    int Ergebnis;
    int Wert1 = 3;
    int Wert2 = 7;
    
    Ergebnis = addieren(Wert1, Wert2);
    
    cout << Ergebnis << endl;
    
    Ergebnis = multiplizieren(Wert1, Wert2);
    
    cout << Ergebnis << endl;
    
    system("pause");
    return (0);
    
}

int addieren(int Wert1, int Wert2)
{
    int Ergebnis;
    
    Ergebnis = Wert1 + Wert2;
    
    return (Ergebnis);
}

int multiplizieren(int Wert1, int Wert2)
{
    int Ergebnis;
    
    Ergebnis = Wert1 * Wert2;
    
    return (Ergebnis);
}


Ich spare mir praktisch die Deklaration von Ergebnis in den jeweiligen Funktionen (OK, wenn man das als Vorteil sehen kann, dafür aber einen, meines erachtens, schwerer zu lesenden Code hat).

Aber selbst wenn ich Funktionszeiger benutze müßte ich doch Bedingungen setzen, welche der beiden Funktionen unter welchen Umständen gewählt werden (Bspw. Bekommt der Spieler die einfache Punktezählung mit "addieren" oder ist es ein Bonuslevel in dem es ein vielfaches um Punkte geht mit "multiplizieren").

Kann mir das bitte einer verständlich erklären, Heiko hält sich da nämlich sehr zurück und ich würde solche Probleme eher mit einfachen Funktionen lösen. Wann also sind Funktionszeiger wirklich sinnvoll?

2

16.12.2009, 15:16

Der Vorteil ist der, dass du zur Laufzeit entscheiden kannst was denn aufgerufen wird, und das ganze Flexibler ist.

Auch sehr nützlich ist das ganze für jede art von Callback-Funktionen.

3

16.12.2009, 15:27

Genau diesen Satz verstehe ich ja nicht. Das könnte ich doch auch mit Normalen Funktionen, oder?

Und Bedingungen müßte man eh einbinden, damit das System überhaupt das Ergebnis ausspuckt, mit dem wir weiter arbeiten können?

Zur Laufzeit heißt ja "während des Spiels" (z. Bsp. wenn ich da jetzt das richtig verstanden habe).

Und zur Laufzeit entscheiden wir doch auch, welche "normalen" Funktionen benutzt werden können. Also hat für mich ein Funktionszeiger kein Vorteil gegenüber einfachen Funktionen.

Also vereinfacht ausgedrückt:


Wenn Normales Level dann mache:
pFunktion = addieren
Ergebnis = pFunktion(Wert1, Wert2)

Alternativ mit einfachen Funktionen:
Wenn Normales Level rufe auf:
Ergebnis = addieren(Wert1, Wert2);

Wenn Bonuslevel dann das gleiche wie oben, nur halt mit multiplizieren.



Ich steige dort irgendwie nicht durch :?

4

16.12.2009, 15:35

Also, wir nehmen an, du schreibst eine Bibliothek für buttons und was weis ich noch.

Dann stellt sich dir die Frage, was machen, wenn man auf den Button klickt.

Das muss der User doch irgenwie entscheiden können.

Da liegt die Stärke von Funktionszeigern:
Der User übergibt dir einfach einen Zeiger auf eine von ihm Gemachte Funktion, in der er Entscheidet, was passiert, wenn der Button gecklickt wird.

Mit normalen funktionen müsstest du ja 100 Standard-Möglichkeiten anbieten. ;)

5

16.12.2009, 15:39

Falls dir das Beispiel von E122 nicht helfen sollte, warte vllt. einfach mal ab, bis du irgendwann mal ein Tutorial oder whatever liest, das Funktionszeiger verwendet. Irgendwann sieht man es schon.

Zitat

Ich spare mir praktisch die Deklaration von Ergebnis in den jeweiligen Funktionen

Die Deklaration von Ergebnis ist auch in der Version ohne Zeiger überflüssig.

6

16.12.2009, 15:50

Zitat von »"defaultplayer^^

warte vllt. einfach mal ab, bis du irgendwann mal ein Tutorial oder whatever liest, das Funktionszeiger verwendet. Irgendwann sieht man es schon.


Das ist das, was ich gerade sagen wollte. Ich lese erst einmal das Buch zuende und schaue mir dann mal einige Beispiele an, denn mir erschließt sich da wirklich noch nicht der Vorteil. Ich denke, ich werde vieles besser verstehen, wenn ich mich an das erste größere Projekt ran wage.

Zitat von »"defaultplayer^^


Zitat

Ich spare mir praktisch die Deklaration von Ergebnis in den jeweiligen Funktionen

Die Deklaration von Ergebnis ist auch in der Version ohne Zeiger überflüssig.


Stimmt :)

Wahrscheinlich reicht es vollkommen aus, wenn man als return z. Bsp. (Wert1 + Wert2) zurück gibt.

Ich danke für die Antworten soweit und versuche erst einmal den Rest des Buches aufzuarbeiten, bevor ich mich an das Feintuning ran mache :D

K-Bal

Alter Hase

Beiträge: 703

Wohnort: Aachen

Beruf: Student (Elektrotechnik, Technische Informatik)

  • Private Nachricht senden

7

16.12.2009, 18:16

Wie bei vielen Dingen in der Programmierwelt gibt es nicht immer DIE Lösung. Mit Funktionszeigern kann man das ein oder andere Problem geschickt lösen. Das heißt aber nicht, dass man nicht auch einen anderen Weg gehen könnte.

Werbeanzeige