Fehler:
[BCC32 Fehler] Unit1.cpp(12): E2027 Eine Speicheradresse muß verwendet werden

Ich versteh nicht wie das hier funktionieren soll.

#include <iostream>
using namespace std;

int call(int c);
int func ( int z1, int call (int c) );

int main(int argc, char* argv[])
{

func ( 2,  &call(2) );

system("PAUSE");
	return 0;
}
//---------------------------------------------------------------------------

int call ( int c )
{
	return c;
}

int func ( int z1, int call (int c) )
{
cout<< z1 << endl;
// Wie kann man hier auf den zweiten Parameter zugreifen?

return 0;
}

hi wie muss ich hier die Funktion func benutzen?

Fehler:
[BCC32 Fehler] Unit1.cpp(12): E2027 Eine Speicheradresse muß verwendet werden

Leider eine völlig unverständliche Fehlermeldung

#include <iostream>
using namespace std;

int call(int c);
int func ( int z1, int call (int c) );

int main(int argc, char* argv[])
{

func ( 2,  &call(2) );

system("PAUSE");
	return 0;
}

Offensichtlich soll func eine Funktion übergeben werden. Der Funktionsparameter lautet ja int call(int c) , d.h. erwartet wird eine Funktion (bzw. ein Zeiger auf eine Funktion), die einen int-Parameter hat und int zurückgibt. So siehts aus:

func(2, call);

Das was du hast, ergibt keinen Sinn. Vom Typ her würdest du einen Zeiger auf int übergeben, aber da call(2) ein rvalue ist, kannst du darauf keinen Zeiger zeigen lassen.

int func ( int z1, int call (int c) )
{
cout<< z1 << endl;
// Wie kann man hier auf den zweiten Parameter zugreifen?

return 0;
}

Per Name. Du kannst die Funktion einfach aufrufen:

cout << call(z1);

BTW das geht zwar so, aber ich meine häufiger sieht man es, dass Zeiger auf Funktionen auch als Zeiger deklariert werden:

int call(int c);
int func(int z1, int (*call)(int c))
{
  cout << call(z1);
}
...
func(2, call);

(Und der Name der Funktion und des Parameters müssen auch nicht übereinstimmen, falls das nicht ohnehin klar war)

void foo(int (*function) ())
{
  std::cout << function();
}

int bar()
{
  return 5;
}

int main()
{
  foo(bar);
}

Bei dir ist nicht mal die Deklaration von "func" korrekt. Zudem hast du bei dem Parameter einen Denkfehler, ein Funktionspointer kann auch nicht zaubern, der schleppt keine weiteren Parameter mit sich rum. oO

PS: Normalerweise kann man Funktionspointer in seinen Programmen vermeiden.

func ( 2, call );

Die Funtkion func(...) hat als zweites Argument bloss einen Zeiger auf eine Funktion, die einen int-Wert als Argument und einen int-Wert als Rueckgabewert hat.

Die Funtkion func(...) hat als zweites Argument bloss einen Zeiger auf eine Funktion, die einen int-Wert als Argument und einen int-Wert als Rueckgabewert hat.

Nein, die Deklaration von func ist kein gültiges C++.

Nein, die Deklaration von func ist kein gültiges C++.

Selbstverständlich ist das gültig. Wie kommst du denn auf sowas?

Jedoch hab ich jetzt noch 2 Fragen.

Geht das auch so? int func ( int z1, int call (int c) );

Oder MUSS ich den Pointer verwenden wie hier:
int func ( int z1, int (*call) (int c) );

2. Müsste das ganze theoretisch nicht auch so gehen?
Wenn ich das: func ( &call) ); rauslassen dann Kompiliert es zumindest.

[BCC32 Fehler] Unit1.cpp(12): E2034 Konvertierung von 'int ()(int)' nach 'int ()()' nicht möglich
[BCC32 Fehler] Unit1.cpp(12): E2342 Keine Übereinstimmung des Typs beim Parameter 'functocall' ('int ()()' erwartet, 'int ()(int)' erhalten)
[BCC32 Fehler] Unit1.cpp(12): E2379 In Anweisung fehlt ;

#include <iostream>
using namespace std;

int call(int c);
int func ( int (*functocall) () );

int main(int argc, char* argv[])
{

func ( &call) );

system("PAUSE");
	return 0;
}
//---------------------------------------------------------------------------

int call ( int c )
{
	cout<<"call parameter: " << c << endl;
	return c;
}

int func ( int functocall () )
{
functocall(); // Soll call(); aufrufen
return 0;
}

Jedoch hab ich jetzt noch 2 Fragen.

Geht das auch so? int func ( int z1, int call (int c) );

Oder MUSS ich den Pointer verwenden wie hier:
int func ( int z1, int (*call) (int c) );

Laut Standard geht beides -- bei Funktionsparametern werden Funktionstypen automatisch als Funktionszeigertypen angesehen. Das zweite ist aber expliziter, das würde ich aus Stilgründen bevorzugen.

Beim Aufruf geht auch beides:

call(10);
// oder
(*call)(10);

Hier würde ich das erste bevorzugen. Alles Geschmackssache.

2. Müsste das ganze theoretisch nicht auch so gehen?

Nein. func ruft functocall ohne Argument auf. call erwartet aber ein Argument. Wo soll das herkommen?

Dieses Problem wird schon durch die Signatur der Funktionen erfasst. Der Compiler sagt dir, dass die Typen nicht übereinstimmen.

@Bashar & icarus2
Tja.. ehrlich gesagt wusste ich das nicht. Man lernt scheinbar nie aus.