Funktionszeiger

freakC++

Hallo zusammen,

kann mir jemand sagen, warum beim folgenden Code der Fehler "reference to plus is ambiguous" erscheint? Irgendwie steh ich aufm Schlauch.

#include <iostream>
using namespace std;

void (*foo)(int&);

void plus(int& x) {
	x++;
}

void minus(int& x) {
	x--;
}

int main() {

	int a = 10;
	foo = plus;
	foo(a);
	cout << a << endl;

	return 0;
}

Vielen Dank
LG, freakC++

Mach das using namespace std; weg, das ist nie eine gute Idee.

freakC++

Tatsächlich! Daran lag es. Was hat den std damit zu tun?

edit: Kann mir noch jemand erklären, wie man den Parameter dieser Funktion zu intepretieren hat?

float (*e)(float (const int&));

Danke

KN4CK3R

im std Namensraum gibt es eine struct die "plus" heißt, deswegen weiß der Compiler nicht, was du meinst
Der Parameter ist selbst wieder eine Funktion, die einen const int& nimmt und float zurückgibt.

greetz KN4CK3R

freakC++

Ok, danke! Noch eine letzte Frage. Wie ist die Aufrufkonvention einer solcher Funktion. So, kommt nämlich ein Castingfehler:

#include <iostream>

float (*e)(float (const int&));

float plus(const int& x) {
	return 1 + x;
}

float foo(float x(const int&)) {
	return 1 + x(1);
}

int main() {

	float a = 10.0;
	e = foo;
	std::cout << e(plus(a)) << std::endl; //Fehler!

	return 0;
}

Danke

Pass mit den Fachwörtern auf:
Aufrufkonvention (calling convention): bedeutet etwas anderes
Castingfehler: Du verwendest keinen Cast, das ist wenn schon ein Typfehler.

Was denkst du denn, was

plus(a)

für einen Typ hat?

Swordfish

#include <iostream>

float plus( const int & x )
{
    return 1 + x;
}

typedef float ( *plus_t )( const int & );

float foo( plus_t x, float a )
{
    return 1 + x( a );
}

typedef float ( *foo_t )( plus_t, float );

int main()
{ 
    float a = 10.0f;
    foo_t e = foo;

    std::cout << e( plus, a ) << '\n';
}

Sone

freakC++ schrieb:

edit: Kann mir noch jemand erklären, wie man den Parameter dieser Funktion zu intepretieren hat?
float (*e)(float (const int&));

Der Parameter dieser Funktion ist ein Funktionszeiger auf eine Funktion die

einen float zurückgibt
und eine Const-Referenz auf einen int als Parameter nimmt.

Edit³:
Vielleicht wird es deutlicher wenn du den Funktionsparameter mal aus der Definition rausnimmst:

float (const int&)

Dann ist es nur noch eine leicht zu lesene Signatur.