Nouvelle déclaration d'une fonction dans la classe C++

Question

class arbit 
    { 
     int var; 
     public: 

     int method1(); 
     int method1() const; 

    }; 

Pourquoi g ++ ne donne pas d'avertissement lors de la déclaration de la même fonction deux fois ici?

Answer 1

Parce que l'un est const et l'autre ne l'est pas. Ce sont des surcharges différentes, avec des signatures différentes. L'un ou l'autre est appelé, selon que l'objet sur lequel vous l'appelez est const.

Exemple:

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

Vous devez déclarer un procédé tel que const si elle ne modifie pas l'état (visible) de l'objet. Cela vous permet de distribuer des objets const arbit et de vous assurer que personne ne les modifiera accidentellement.

Par exemple, vous feriez une fonction non setValueconst (car il modifie l'objet), mais getValue serait const. Donc, sur un objet const, vous pouvez appeler getValue mais pas setValue.

---

¹ Quand il y a une volonté, il y a un moyen, et il est appelé const_cast. Mais oublie que je t'ai déjà dit.

Answer 2

Vous pouvez également surcharger avec volatile modificateur et une combinaison des deux: 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(); 
} 

qui sortie:

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