Funziona con argomenti const e overload

Stavo provando lo stackeroverflow qn quindi mi ha fatto pensare perché non sovraccaricare la funzione e ho trovato un codice leggermente diverso ma dice che la funzione non può essere sovraccaricata. La mia domanda è perché? o c’è un altro modo?

#include  using std::cout; class Test { public: Test(){ } int foo (const int) const; int foo (int ); }; int main () { Test obj; Test const obj1; int variable=0; do{ obj.foo(3); // Call the const function obj.foo(variable); // Want to make it call the non const function variable++; usleep (2000000); }while(1); } int Test::foo(int a) { cout<<"NON CONST"<<std::endl; a++; return a; } int Test::foo (const int a) const { cout<<"CONST"<<std::endl; return a; } 

Non è ansible eseguire il sovraccarico basandosi solo sulla costanza di un puntatore non di tipo non di riferimento.

Pensa ad esempio se tu fossi il compilatore. Di fronte alla linea:

  cout < 

quale funzione chiameresti?

Mentre passi di valore, il valore viene copiato in entrambi i modi. Il const sull'argomento è rilevante solo per la definizione della funzione.

§13.1 dove lo Standard discute su dichiarazioni che non possono essere sovraccarichi –

Le dichiarazioni dei parametri che differiscono solo per la presenza o l’assenza di const e / o volatile sono equivalenti. Cioè, gli specificatori di tipo const e volatile per ogni tipo di parametro sono ignorati […]

Solo gli specificatori di tipo const e volatile al livello più esterno della specifica del tipo di parametro vengono ignorati in questo modo; Gli identificatori di tipo const e volatile sepolti all’interno di una specifica del tipo di parametro sono significativi e possono essere utilizzati per distinguere le dichiarazioni di funzioni sovraccariche. […]

quando si determina quale funzione viene dichiarata, definita o chiamata. “In particolare, per qualsiasi tipo T,” puntatore a T “,” puntatore a const T “e” puntatore a T volatile “sono considerati tipi di parametri distinti, così come” riferimento a T “,” riferimento a const T “, e “riferimento a T. volatile”

MODIFICA 2:

Poiché il post è essenzialmente uguale al post reffered , eccetto che le funzioni sovraccaricate sono ora funzioni membro della class, sto tentando di illustrare un ulteriore aspetto che potrebbe essere utile per illustrare il concetto di overload che non è lo stesso del sovraccarico basato su la “costanza” degli argomenti (nell’ambito della class o dello spazio dei nomi). Tuttavia l’OP voleva sapere come differenziare i due sovraccarichi.

Un modo per sovraccaricarli dipende con successo dalla qualifica cv del primo parametro implicito in caso di chiamate di funzioni membro, come mostrato. La funzione membro ‘const’ può essere chiamata solo quando l’espressione object utilizzata per richiamare la funzione membro sovraccarico è anche una const. Quando un’espressione di object non const viene utilizzata per richiamare la chiamata della funzione membro overload, viene preferita la versione non const in quanto è una corrispondenza esatta (la chiamata al sovraccarico della funzione membro const richiederà la qualifica cv del primo argomento implicito)

 #include  using std::cout; class Test { public: Test(){} int foo (const int) const; int foo (int ); }; int main () { Test obj; Test const objc; // const object obj.foo(3); // calls non const overload, object expression obj is non const objc.foo(3); // calls const overload, object expression objc is const } int Test::foo(int a) { a++; return a; } int Test::foo (const int a) const { return a; } 

Come spiega la risposta all’altra domanda, i due punti non differiscono perché hanno definizioni di parametri equivalenti.