Überladen von Funktionen fehlschlagen: Warum haben diese Betreiber kollidieren?

Question

Ich habe eine große große Code-Basis bekommt, das zwei Hauptnamensraum beinhaltet: den Motor und die Anwendung.

Der Motor definiert eine vector3 Klasse als typedef einer anderen vector3 Klasse, mit Gleichheitsoperator, die nicht in der vector3 Klasse im Motornamensraum sitzen. Ich habe eine Klasse, um die Anwendung, die auch Gleichheitsoperator in der Anwendung Namespace hatte.

Als ich versuchte, zu kompilieren, die unabhängig, aber in der Nähe von vector3 Vergleichen gescheitert, weil es keinen angemessenen Gleichheitsoperator finden konnte. Ich vermutete, dass ich verursachte einen Konflikt so meine Gleichheitsoperatoren in die Klasse zog ich hinzugefügt und die Compilierung erfolgreich war.

// engine.h
namespace Engine
{
    class Vector3Impl { ... };
    typedef Vector3Impl Vector3;
    bool operator==(Vector3 const &lhs, Vector3 const &rhs) { ... }
}


// myfile.cpp
#include "engine.h"

namespace application
{
    class MyClass { ... };
    bool operator==(MyClass const &lhs, MyClass const &rhs) { ... }

    void myFunc(...)
    {
        if ( myClassA == myClassB ) { ... } // builds
    }

    void anotherFunc(...)
    {
        Engine::Vector3 a, b;
        ...
        if ( a == b ) { ... } // fails
    }
}

Doch nach darüber nachzudenken Ich kann nicht sehen, warum die Kompilierung fehlgeschlagen. Es gibt keine impliziten Konvertierungen von vector3s meine Klasse oder umgekehrt, und das Argument abhängigem Look-up sollte in dem Gleichheits-Operator aus dem Motor-Namespace und passender sie ziehen wird.

Ich habe diesen Fehler in einer Probe C ++ Projekt versucht reproduzieren, aber das sich weigert, zu brechen. Es muss etwas in der großen großen Code-Basis sein, das dieses Problem verursacht, aber ich bin nicht sicher, wo zu Beginn der Suche. Etwas wie das Gegenteil eines Schurken „mit Engine“? Jemand irgendwelche Ideen?

Answer 1

C ++ Standard 3.4.4.2 erklärt:

  

Für jedes Argument Typ T im Funktionsaufruf, gibt es eine Reihe von null oder mehr zugehörigen Namensraum und ein Satz von Null   oder mehr Klassen zugeordnet betrachtet werden. Die Sätze von Namespaces und Klassen werden vollständig durch die Art der bestimmt   die Funktionsargumente (und der Namespace eines Template-Argument Vorlage). typedef Namen und mit Klärungen   verwendet, um die Typen angeben zu diesem Set nicht beitragen.

ADL arbeitet nicht mit typedef ist.

Answer 2

Ich lief einmal in das gleiche Problem mit einem Compiler, das Argument abhängige Lookup nicht hat (Koenig Lookup - dank @igor) (VC6 glaube ich). Das bedeutet, dass, wenn es einen Operator sieht, sieht es nur in dem umschließenden Namensraum.

So können Sie uns sagen, welchen Compiler Sie verwenden?

Wechsel zu einem anderen Compiler löste es.

Sehr unbequem in der Tat.

Answer 3

bool operator==(Vector3 const &lhs, Vector3 const &rhs) { ... }

Die kanonische Definition eines Gleichheitsoperator auf eine Klasse definiert sollte nur ein Argument, nämlich die rechte Seite. Die LHS ist dies. Weiß nicht, ob dies obwohl eine Lösung für Ihr Problem sein würde.

Das ist, was ich schreiben würde:

Klasse Vector3 {  bool operator == (const Vector3 & rhs) const {...} };