Anfängerproblem mit friend-Operatoren

Hallo,

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?

Badestrand

Bis auf das Semikolon statt Doppelpunkt bei "public" sieht's ok aus und der Comeau-Compiler kompilierts auch anstandslos - was für einen Compiler nutzt du denn?

hallo,

ich benutze VC90

Badestrand

Beim VC 10 funktioniert's auch, es muss an etwas anderem liegen. Wenn der obige Code nur hier reingeschrieben ist, hol mal den Originalcode mit Copy&Paste her.

freaky

daersc schrieb:

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";
}

ich habe es inzwischen rausbekommen:
Das Problem war, das MyClas in einem Namespace definiert war, der in der cpp-Datei dann per using namespace importiert wurde.
ich habe jetzt mal in der cpp folgendes geschrieben:

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

das funktioniert jetzt auch.

Danke trotzdem

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?

Badestrand

Warum willst du das tun?

hast recht xD
Ist eigentlich Unsinn...

DStefan

daersc schrieb:

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.

hustbaer

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

DStefan

hustbaer schrieb:

@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.