Vuelva a declarar una función en C++ clase

Question

class arbit 
    { 
     int var; 
     public: 

     int method1(); 
     int method1() const; 

    }; 

¿Por qué g ++ no da ninguna advertencia mientras que declara la misma función dos veces aquí?

Answer 1

Porque uno es const y el otro no lo es. Estas son sobrecargas diferentes, con diferentes firmas. Se llama a uno u otro, dependiendo de si el objeto al que lo llamas es const.

Ejemplo:

arbit x; 
x.method1(); // calls the non-const version 
arbit const &y = x; 
y.method1(); // calls the const version 

Usted debe declarar un método como const si no modifica el estado (visible) del objeto. Eso le permite repartir objetos const arbit, y estar seguro¹ de que alguien no los modificará accidentalmente.

Por ejemplo, tendría que hacer una función setValue no const (porque modifica el objeto), pero getValue sería const. Así que en un objeto const, se podría llamar getValue pero no setValue.

---

¹ Cuando hay voluntad, hay un camino, y se llama const_cast. Pero olvida que te lo dije alguna vez.

Answer 2

También puede sobrecargar con volatile modificador y una combinación de los dos: const volatile

#include <iostream> 
using namespace std; 

class foo { 
public: 
    void bar()    { cout << "bar()" << endl; } 
    void bar() const   { cout << "bar() const" << endl; } 
    void bar() volatile  { cout << "bar() volatile" << endl; } 
    void bar() const volatile { cout << "bar() const volatile" << endl; } 
}; 

int main() { 
    foo f; 
    f.bar(); 

    foo const f_const; 
    f_const.bar(); 

    foo volatile f_volatile; 
    f_volatile.bar(); 

    foo const volatile f_const_volatile; 
    f_const_volatile.bar(); 
} 

Eso sería:

bar() 
bar() const 
bar() volatile 
bar() const volatile