perché la parola chiave overload è stata rimossa dal C++?

Question

Stavo leggendo this. La risposta data da @NPE parla di interessanti fatti storici & dice che,

• All'inizio del C++ ha usato per essere una parola chiave speciale (sovraccarico) che aveva per essere utilizzato per dichiarare un identificatore di sovraccarico;

Quindi, qual è la ragione che sta dietro la rimozione di sovraccarico parola chiave? Non ho Design and Evolution of C++ di Stroustrup. Cosa c'è di sbagliato con la parola chiave overload?

Answer 1

Stroustrup menzioni in D & E 11.2.4 "Il overload Parola chiave" che la parola chiave overload provoca problemi quando "fusione" (o utilizzando) due librerie che sia utilizzato lo stesso nome di funzione (senza namespace *). Ad esempio, sqrt nell'intestazione C math.h rispetto allo sqrt(complex) dall'intestazione C++ complex. Se uno di loro ha dichiarato la funzione di sovraccaricabile, ma l'altro no, si doveva includere le intestazioni in un tale ordine che il sovraccarico è stata attivata prima si è verificato:

// #include <complex> 
overload sqrt; 
complex sqrt(complex); 

// #include <math.h> 
double sqrt(double); // fine 

// --------------------------- 

// #include <math.h> 
double sqrt(double); 

// #include <complex> 
overload sqrt;   // ERROR: cannot allow overloading 
         //  of an already declared function 
complex sqrt(complex); 

Le possibili soluzioni sono "ingestibile in tutti tranne i casi più semplici ".

(*) La overload parola chiave è stata resa obsoleta con Cfront 2.0, rilasciato nel 1989. Gli spazi dei nomi sono stati introdotti nella proposta di standardizzazione nel 1993.

L'intento originale della parola chiave è stato quello di affrontare due paure:

1. Preoccupazioni che potrebbero verificarsi ambiguità non rilevate.
2. Preoccupato che un programma non possa essere collegato correttamente a meno che il programmatore non abbia dichiarato esplicitamente quali funzioni dovevano essere sovraccaricate .

L'ex paura si è rivelata largamente infondata. I pochi problemi riscontrati nell'uso effettivo sono trattati dalle regole di risoluzione di sovraccarico indipendenti dall'ordine. Quest'ultima paura ha dimostrato di non avere alcun fondamento in un problema generale con regole di compilazione C separate che non avevano nulla a che fare con l'overloading.