Ueberladene Funktionen ...

Eric Cartman

Hallo

class MyClass
{
public:
	MyClass(const char*);			// Konstruktor
	friend bool Check(const MyClass&);	// friend-Funktion
	// mehr Methoden
private:
	bool Check(const char*);	// Funktion mit demselben Namen wie
					// die friend-Funktion
};

inline MyClass::MyClass(const char* s)
{
	assert(Check(s));	// klappt wunderbar
				// ruft die private Funktion bool Check(const char*)
				// auf
}

inline void MyClass::IrgendeineMethodeinMyClass()
{
	// s ist vom Typ MyClass
	if (Check(s)) return;	// gibt Compiler-Fehler
				// const MyClass& kann nicht in const char*
				// konvertiert werden
				// normalerweise muesste doch einfach die
				// friend-Funktion aufgerufen werden
				// wieso tut mein Compiler das nicht?
	// mehr Code
}

inline bool Check(const MyClass& s)	// friend-Funktion
{
	return Check("bla");		// Aufruf der privaten Funktion
}

inline bool MyClass::Check(const char*)	// Definition der privaten Funktion
{
	// viel Code
}

// zwar koennte man das Problem schnell loesen, indem man die private Funktion
// umbenennt, z.B. in Check2(), aber ich wuerde doch ganz gerne verstehen,
// warum der Compiler die friend-Funktion nicht findet und stattdessen vergeblich
// versucht die MyClass-Refernz zu const char* umzuwandeln

Steh grad irgendwie aufm Schlauch...

Gruss
Cartman

Dravere

Dies hat mit dem Scope zu tun. Mit der friend Definition holst du die globale oder freie Funktion nicht in den Scope der Klasse. In der Klasse überdeckt die bool Check(char const*) die andere Funktion. Wenn du die globale oder freie Funktion aufrufen willst, dann musst du in den entsprechenden Scope wechseln.

Also wenn die freie Funktion zum Beispiel im globalen Scope ist, dann musst du sie so aufrufen:

::Check(s);

Falls sie im Namensraum foo ist, dann so:

::foo::Check(s);

Überladung funktioniert nur im selben Scope, sonst wird überdeckt. Musste ich erst vor kurzem auch wieder schmerzlich lernen, allerdings in einem anderen Zusammenhang

Grüssli

Eric Cartman

@Dravere
Hatte das ja eigentlich schon gelernt, aber nur in Verbindung mit Variablen:

int a = 1;		// globales a
void foo()	// warum eigtl. immer "foo()"? is mir schon oefter
		// hier im Forum aufgefallen...
{
	int a = 2;
	std::cout << a;		// a aus foo()
	std::cout << ::a;	// globales a
}

ich hatte eben gedacht, der Compiler sucht sich anhand der Parameter schon die passende Funktion auf. An den Scope-Operator dachte ich gar nicht...

Danke fuer die Aufklarung.

Gruss
Cartman

Eric Cartman schrieb:

warum eigtl. immer "foo()"? is mir schon oefter
// hier im Forum aufgefallen...

http://de.wikipedia.org/wiki/Metasyntaktische_Variable

Dravere

Der Compiler sucht normalerweise schon die richtige Funktion, anhand der Parameter. Aber es gibt halt auch bei Funktionen einen Überdeckung. Der ganze Suchvorgang ist eigentlich relativ komplex. Da könnte man wohl einfach ein ganzes Kapitel in einem Buch füllen. Wenn man sogar in die Details geht, würde es vielleicht für ein ganzes Buch reichen

Zu Foo, Bar, Fubar und co:
http://de.wikipedia.org/wiki/Foo#Foo_in_der_IT-Branche
http://de.wikipedia.org/wiki/Metasyntaktische_Variable

Grüssli