Error del compilador al utilizar la sobrecarga de operadores anidados en C ++

Question

Tengo una clase de URL que sobrecarga los operadores ==, < ;, > ;, y! = para una comparación simple. La clase URL tiene un miembro de datos de cadena y algunas funciones para actuar en la cadena. Los operadores funcionan bien cuando se prueban con la clase URL.

También tengo una clase de página que tiene un miembro de datos URL. Estoy tratando de sobrecargar los mismos operadores en la clase de página. La igualdad en la clase de página se basa en la igualdad de sus URL respectivas, por lo que utilizo los operadores booleanos de la clase de URL al comparar páginas. Esto crea algunos errores de compilación que no puedo entender. Código para operadores de URL:

bool URL::operator ==(URL & u) const {
    //url is the string instance variable
    return url == u.GetURL();
}

Código para operadores de página:

bool Page::operator ==(Page & p) const {
    //url is the URL instance variable of the Page class
    return url == p.GetURL();
}

Esto produce errores así:

src/Page.cpp: In member function ‘bool Page::operator==(Page&) const’:
src/Page.cpp:21: error: no match for ‘operator==’ in ‘((const Page*)this)->Page::url == Page::GetURL()()’
inc/URL.h:118: note: candidates are: bool URL::operator==(URL&) const

Predigo que es algo tonto que estoy olvidando. ¿Me demostrarás que tengo razón?

editar: la corrección de Const me ha mordido en el trasero. Gracias por la ayuda.

Answer 1

Debería haber sido:

bool URL::operator ==(const URL & u) const {
    //url is the string instance variable
    return url == u.GetURL();
}

Y análogamente para los otros operadores.

Si aún recibe errores del compilador, quizás no haya realizado también GetURL() const:

std:string URL::GetURL() const {
    // whatever...
}

Answer 2

También me gustaría señalar que los métodos (es decir, la interfaz pública) están ahí para proteger a las entidades externas de los cambios en los detalles de implementación. También que una clase es automáticamente amiga de sí misma (por la misma razón) y, por lo tanto, solo acceder a los miembros del otro objeto está bien.

bool URL::operator ==(URL & u) const {
    //url is the string instance variable
    return url == u.GetURL();
}

Se puede escribir como:

bool URL::operator ==(URL & rhs) const
{
    return url == rhs.url;  // No need to use GetURL()
}

En mi opinión, esto hace que el código sea más claro (pero esta es una opinión que sus gustos pueden variar)