Perché i qualificatori const sono argomenti della funzione utilizzati per la risoluzione dell'overload?

Question

Eventuali duplicati:
Functions with const arguments and Overloading

Io sono bello confuso dal sovraccarico e le regole di dichiarazione const. Qui ci sono due cose che mi incuriosiscono, forse puoi aiutarmi a trovare l'incomprensione più profonda nella mia testa che mi fa sembrare sconcertante. ;)

Prima edizione:

mio compilatore permette questo:

void f(int & x) { 
    std::cout << "plain f" << std::endl; 
} 
void f(const int & x) { 
    std::cout << "const f" << std::endl; 
} 

Ma il seguente causa un errore di compilazione (funzione ha già un corpo):

void f(int x) { 
    std::cout << "plain f" << std::endl; 
} 
void f(const int x) { 
    std::cout << "const f" << std::endl; 
} 

che suppongo ha senso perché pensavo che il const fosse solo lì per dire al compilatore che l'oggetto che viene passato non è cambiato e nel secondo caso viene comunque copiato. Ma se questo è corretto, allora perché posso sovraccaricare le funzioni usando const?

In altre parole, perché se io uso la versione compilazione e chiamare le funzioni in questo modo:

int x1 = 5; 
    const int x2 = 5; 
    f(x1); 
    f(x2); 

ottengo "plain f" e "f const" invece di "f const" due volte? A quanto pare ora sto anche usando il const per dire al compilatore quale funzione chiamare non solo che il riferimento non cambia. Questo diventa più confuso perché se rimuovo la versione "semplice" funziona perfettamente e chiama la versione "const" due volte.

Ora qual è la mia domanda attuale? Mi piacerebbe sapere quali sono le idee dietro questo comportamento perché altrimenti memorizzarlo è molto difficile.

Answer 1

ho pensato che il const era lì solo per dire al compilatore che l'oggetto essendo passato non è cambiato e nel secondo caso esso viene copiato in ogni caso

Lei ha ragione. Perché nel secondo caso viene comunque copiato, e quindi lo const non fa alcuna differenza per il chiamante, lo standard definisce che void f(const int x) e void f(int x) hanno la stessa firma. Quindi si scontrano, stai cercando di definire la stessa funzione due volte.

Perché nel primo caso non è copiato in ogni caso, void f(const int &x) e void f(int &x) hanno diversi firme. Quindi sovraccaricano.

Nel primo caso, è vietato chiamare la versione di int&f con x2 come argomento, perché sarebbe creare un riferimento non const a un oggetto const senza alcun cast esplicito in vista. In questo modo si sconfigge lo scopo del sistema const (che è quello che se si vuole infrangere const-safety, bisogna farlo esplicitamente con un cast). Quindi ha senso avere sovraccarichi costanti e non costanti di funzioni con parametri di riferimento.

Nel secondo caso, non esiste alcuna relazione tra la costanza della sorgente di una copia e la costanza della destinazione. È possibile inizializzare una variabile const da una non const o da una const const. Questo non causa problemi e non infrange la sicurezza costante. Ecco perché lo standard lo rende utile definendolo definendo che le due versioni "diverse" di f sono in realtà la stessa funzione.

Answer 2

n3337 13,1

[Nota: Come specificato in 8.3.5, dichiarazioni di funzione che hanno dichiarazioni di parametri equivalenti dichiarare la stessa funzione e non può pertanto essere sovraccaricato: ffer solo in presenza o assenza

- Dichiarazioni di parametri che di3 di const e/o volatile sono equivalenti. Cioè, gli identificatori di tipo volatile const e per ogni tipo di parametro vengono ignorati quando determina quale funzione viene dichiarata, definita o chiamata. [ Esempio:

typedef const int cInt; 
int f(int); 
int f(const int); // redeclaration of f(int) 
int f(int) { /* ... */ } // definition of f(int) 
int f(cInt) { /* ... */ } // error: redefinition of f(int) 

- fine esempio] Solo il const e tipo-specificatori volatili a livello più esterno del tipo di parametro specifica dettagliata vengono ignorati in questo modo ; gli identificatori di tipo const e volatile sepolti all'interno di un parametro con le specifiche di tipo sono significativi e possono essere utilizzati per distinguere le dichiarazioni di funzioni sovraccaricate .124 In particolare, per qualsiasi tipo T, " " puntatore a T, "puntatore a const T" e "Puntatore a T volatile" sono considerati distinti tipi di parametri, come "riferimento a T", " ", riferimento a const T, "e" riferimento a T. volatile.”