# include<iostream>
using namespace std;

int f1(int (*) (int), int);
int f2(int);
int f3(int);

int main()
{cout<< f1( f2, 5) <<endl;
cout<< f1( f3, 5) <<endl;
system("pause");
return 0;
}

int f1(int (*pf) (int k), int n)

{	int s=0;
	for(int i=1; i<=n; i ++)
	s+= ( *pf) (i); // s=s +((*pf)
	return s;
}

int f2( int k)
{
return k*k;
}

int f3 (int k)
{
return k*k*k;
}

Ausgabe :

55
225

Was genau passiert an dieser Stelle ?

s+= ( *pf) (i);

Mein Ansatz: der Pointer greift auf k zu aus den Funktionen f2 und f3. Und umformuliert steht da : s= s+((*pf) (i)), aber kein "mal" zeichen zwischen den beiden. Deshalb meine Frage welche operation findet zwischen (*pf)(i) statt ?

s+= pf(i);

Ist es jetzt klar?

nicht so wirklich :S ich erkenne den nutzen der Variablen (i) nicht ?

i ist das Argument für die Funktionen f2 und f3. Immerhin wollen die beiden ein int, dann muss da auch ein int reingesteckt werden.

da steht eigentlich nichts anderes wie die Summe aus i*i

1*1 + 2*2+3*3+4*4+5*5 = 55

i*i*i

1*1*1+2*2*2+....= 225

danke für eure Hilfe

Mich irritieren immer diese Variablennamen.

Wer in realen Programmen solche Variablennamen nutzt, gehört vor die Tür gesetzt.

vatan89 schrieb:

Und ich wusste auch nicht dass man in dieser Form (*pf)(i) werte dem Pointer mitgibt.

Du gibst nicht den Pointer mit.

Nehmen wir mal ein einfaches Beispiel:

int i = 4;
int pi = &i; // in pi steht nun die Speicheradresse von pi.
// pi  = Speicheradresse
// *pi = Dereferenzierter Zeiger => Wert auf den die Speicheradresse zeigt, hier 4

Nun gehen wir ein Stück weiter, und wenden dieses wissen auf Funktionszeiger an:

int f2(int k)    // Funktion die ein int als Parameter annimmt, und einen int
{                // zurückgibt... dies solltes du inzwischen verstanden haben nach
    return k*k;  // den ewigen Threads
}

int main() {
    int (*pf)(int /*k*/); // <-- Funktionszeiger namens pf, der auf eine
                          //     Funktion zeigen kann, die ein int annimmt und
                          //     int zurückliefert.
    pf = &foo;            // pf enthält nun die Speicheradresse der Funktion foo
    // pf => Speicheradresse
    // *pf => Funktion auf den die Speicheradresse zeigt

    // Aufruf geht nun in 2 Formen:
    (*pf)(1); // foo mit Argument 1 aufrufen.
    pf(1);    // foo mit Argument 1 aufrufen.
}

Danke für die ausführliche Erklärung, hat gut geholfen.