qualification de type const peu après le nom de la fonction

Question

En C++, parfois je vois des déclarations comme ci-dessous:

return_type function_name( datatype parameter1, datatype parameter2 ) const 
{ /*................*/} 

Qu'est-ce qualificatif de type const faire exactement dans ce cas?

Answer 1

$ 9.3.1/3 Unis-

« Une fonction membre non statique Ces cvqualifiers affectent le type de ce pointeur peut être déclarée const, volatile ou const volatile. (9.3.2). Ils affectent également la type de fonction (8.3.5) de la fonction membre, une fonction membre déclarée const est une fonction membre const, une fonction membre déclarée volatile est une fonction membre volatile et une fonction membre déclarée const volatile est une fonction membre const volatile. "

Voici donc le résumé:

a) Un qualificatif const peut être utilisé que pour la classe non membres statiques fonctions

b) de qualification de cv pour la fonction participent à une surcharge

struct X{ 
    int x; 
    void f() const{ 
     cout << typeid(this).name(); 
     // this->x = 2; // error 
    } 
    void f(){ 
     cout << typeid(this).name(); 
     this->x = 2; // ok 
    } 
}; 

int main(){ 
    X x; 
    x.f();   // Calls non const version as const qualification is required 
        // to match parameter to argument for the const version 

    X const xc; 
    xc.f();  // Calls const version as this is an exact match (identity 
        // conversion) 
} 

Answer 2

Le qualificateur const à la fin d'une déclaration de fonction membre indique que la fonction peut être appelée sur des objets eux-mêmes const. Les fonctions membres const promettent de ne pas modifier l'état de tous les membres de données non modifiables.

Les fonctions membres const peuvent également, bien sûr, être appelées sur des objets non-const (et font toujours la même promesse).

Les fonctions membres peuvent également être surchargées sur la constance. Par exemple:

class A { 
    public: 
    A(int val) : mValue(val) {} 

    int value() const { return mValue; } 
    void value(int newVal) { mValue = newVal; } 

    private: 
    int mValue; 
}; 

A obj1(1); 
const A obj2(2); 

obj1.value(3); // okay 
obj2.value(3); // Forbidden--can't call non-const function on const object 
obj1.value(obj2.value()); // Calls non-const on obj1 after calling const on obj2 

Answer 3

Cela signifie qu'il ne modifie pas l'objet, vous pouvez donc appeler cette méthode avec un objet const.

-à-dire

class MyClass { 
public: 
    int ConvertToInteger() const; 

}; 

signifie que si vous avez

const MyClass myClass; 

vous pouvez appeler

int cValue = myClass.ConvertToInteger(); 

sans erreur de compilation, parce que la déclaration de méthode indique qu'il ne modifie pas la les données de l'objet.