Perché C ++ ha auto, invece di fare semplicemente la cosa giusta quando non ci sono dichiarazioni di tipo esplicite?

Non credo che una tale possibilità sia mai stata presa in considerazione dal comitato del C ++.

Inoltre, sebbene FORTRAN avesse un tipo di sistema di tipo implicito (le variabili che iniziano con "I" e "N" erano interi, tutto il resto era reale) Non riesco a capire come una cosa del genere possa funzionare in un blocco linguaggio strutturato come C ++. Ad esempio, considera un codice come questo:

int f() { 
    int i;

    if (something) {
        i = 2.0;

In C o C ++ come attualmente definito il significato di questo è abbastanza chiaro: il i = 2.0 sta prendendo 2.0 , convertendolo in int , e quindi assegnando il risultante 2 a i che è stato dichiarato nell'ambito esterno.

Se, tuttavia, hai permesso di omettere auto , questo apparentemente definisce una nuova variabile nell'ambito del blocco controllato dall'istruzione if , e tale variabile ( a quanto pare) hanno tipo double , e i nello scope esterno manterrebbe il suo valore precedente.

Ora ammetto apertamente che a seconda della conversione implicita da double a int qui è probabilmente una cattiva idea - ma è stato parte del linguaggio per così tanto tempo (decenni) che è effettivamente impossibile cambialo ora.

In breve, se si lascia omettere auto , si otterrebbe quasi certamente una quantità sconosciuta (ma quasi certamente abbastanza grande) di codice esistente. Data l'importanza della retrocompatibilità in C ++, questo sarebbe sufficientemente inaccettabile che non riesco a immaginare che il comitato possa mai dare una seria considerazione.

Nel 1963, Tony Hoare propose di aggiungere regole di tipo implicito ad ALGOL. Il comitato ALGOL ha chiuso le orecchie, HARD. Era necessario conoscere le variabili da dichiarare esplicitamente, EVEN THEN, per ridurre gli errori di programmazione.

Tony lo menzionò nel suo discorso su Turing, e disse che era PRIMA della probabile storia apocalittica di Venus sulla sonda FORTRAN, in cui un errore di battitura in un'istruzione DO FORTRAN invece creava una variabile nuova di zecca e gli assegnava un valore. Diverse versioni di quella storia si susseguono: la più credibile dice che è stata catturata in una recensione e, se non fosse stata catturata, avrebbe comportato la perdita totale di una (molto costosa) navicella spaziale.

Questo era 53 anni fa.

Consentire tipi opzionali dove erano richiesti può rendere ambigua la sintassi. È più facile aggiungere una parola chiave (o riutilizzarne uno in questo caso) rispetto alla modifica della grammatica.

La sintassi C ++ è progettata in modo tale che una dichiarazione abbia sempre bisogno di un tipo per distinguerla dall'assegnazione. Non puoi semplicemente omettere il tipo, perché questo ha già un significato diverso:

int i = 1;
// Leaving out the type turns it into assignment:
i = 1;

int i;
// Leaving out the type turns it into evaluation:
i;

Hai semplicemente bisogno di un'annotazione di tipo esplicito che dice al compilatore che non vuoi un tipo esplicito. Sembra pazzesco, ma è quello che è.

La sintassi di altri linguaggi è progettata in modo diverso, ad es. in Scala:

val i: Int = 10
// without type:
val i = 10