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

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

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

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

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

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