das sind meine Dateien:

// myclass.hpp
class MyClass {
private:
    // Member-Variablen
    // ...
    int m_foo;

public;
    // Klassenmethoden
    // ...

    // friend-Operator für Vergleiche
    friend bool operator < (const MyClass& left, const MyClass& right);
};

// myclass.cpp
#include "myclass.hpp"

bool operator < (const MyClass& left, const MyClass& right) {
    return left.m_foo < right.m_foo;
}

Mein Compiler sagt mir die ganze Zeit nur, dass der less-than-Operator nicht auf die private-Daten von MyClass zugreifen darf...
Aber ich habe ihn doch als friend gekennzeichnet oder?
Mache ich etwas falsch?

ich benutze VC90

Mein Compiler sagt mir die ganze Zeit nur, dass der less-than-Operator nicht auf die private-Daten von MyClass zugreifen darf...
Aber ich habe ihn doch als friend gekennzeichnet oder?

Mit Code::Blocks funktioniert der Code auch. Ich hab ihn jetzt Mal so getestet:

#include <iostream>

class MyClass
{
    private:
        int m_foo;
    public:
        MyClass(int setter) : m_foo(setter) { }
        friend bool operator < (const MyClass& left, const MyClass& right);
};

bool operator < (const MyClass& left, const MyClass& right)
{
    return left.m_foo < right.m_foo;
}

int main()
{
    MyClass first(5);
    MyClass second(10);
    if(first < second)
        std::cout << "funzt";
}

bool ::operator < (const MyClass& left, const MyClass& right) {
    return left.m_foo < right.m_foo;
}

das funktioniert jetzt auch.

Danke trotzdem

habe gleich noch eine Frage:
könnte ich im Namespace der Header-Datei einen Prototyp des Operators anlegen, der dann eben nur im Namespace aber nicht global vorhanden ist?

Nochmals Hallo,

habe gleich noch eine Frage:
könnte ich im Namespace der Header-Datei einen Prototyp des Operators anlegen, der dann eben nur im Namespace aber nicht global vorhanden ist?

Meinst du so:

namespace Foo {

class MyClass {

   // ....

};

bool operator<(const MyClass &lhs, const MyClass &rhs);

}   // namespace

Das geht - und es ist auch kein Unsinn. Ich würde sagen, das ist gängige Praxis.
Was allerdings meinst du mit: "...nur im Namespace aber nicht global vorhanden ist"?
Man kann den Operator durchaus so verwenden:

int main() {

   Foo::MyClass c1;
   Foo::MyClass c2;
   // ...
   if(c1 < c2) {
      // ...
   }
   // ...
   return 0;
}

Also könnte man irgendwie schon sagen, dass der Operator "global vorhanden" ist.

Stefan.

@DStefan:
Nein, der operator ist trotzdem global nicht vorhanden.
Er wird nur über ADL gefunden.
Das ist ein Unterschied.

Schon klar. Ich wusste nur nicht, ob mit "global nicht vorhanden" nicht vielleicht doch "global nicht zu finden" gemeint war. Deswegen meine ziemlich vorsichtige Formulierung. Man weiß ja nie, was die Jungs so vorhaben

Stefan.