C è fortemente tipizzato?

Per citare Wikipedia :

Due linguaggi comunemente usati che supportano molti tipi di conversione implicita sono C e C ++, e talvolta si afferma che si tratti di linguaggi di tipizzazione debole. Tuttavia, altri sostengono che queste lingue pongono sufficienti restrizioni su come gli operandi di diversi tipi possono essere mescolati, che i due dovrebbero essere considerati come linguaggi fortemente tipizzati.

C'è una risposta più definitiva?

"Fortemente digitato" e "debolmente digitato" sono termini che non hanno un significato tecnico ampiamente concordato. I termini che hanno un significato ben definito sono

• Tipizzato dinamicamente significa che i tipi sono associati ai valori in fase di esecuzione e un tentativo di combinare valori di tipi diversi può causare un "errore di tipo in fase di esecuzione". Ad esempio, se in Scheme si tenta di aggiungerne uno a true scrivendo, (+ 1 #t)ciò causerà un errore. Si verifica l'errore solo se si tenta di eseguire il codice offensivo.

• Digitato staticamente significa che i tipi vengono controllati in fase di compilazione e un programma che non dispone di un tipo statico viene rifiutato dal compilatore. Ad esempio, se in ML si tenta di aggiungerne uno a true scrivendo 1 + true, il programma verrà rifiutato con un messaggio di errore (probabilmente criptico). Ricevi sempre l'errore anche se il codice potrebbe non essere mai eseguito.

Persone diverse preferiscono sistemi diversi a seconda di quanto apprezzano la flessibilità e quanto si preoccupano degli errori di runtime.

A volte "fortemente tipizzato" viene usato liberamente per significare "tipizzato staticamente" e "tipizzato debole" viene usato in modo errato per indicare "tipizzato dinamicamente". Un uso migliore del termine "fortemente tipizzato" è che "non è possibile aggirare o sovvertire il sistema dei tipi", mentre "debolmente tipizzato" significa "ci sono delle scappatoie nel sistema dei tipi". Perversamente, la maggior parte delle lingue con sistemi di tipi statici presenta scappatoie, mentre molti linguaggi con sistemi di tipi dinamici non hanno scappatoie.

Nessuno di questi termini è in alcun modo connesso al numero di conversioni implicite disponibili in una lingua.

Se vuoi parlare precisamente di linguaggi di programmazione, è meglio evitare i termini "fortemente tipizzato" e "debolmente tipizzato". Direi che il C è un linguaggio tipizzato staticamente ma che ha molte scappatoie. Una scappatoia è che puoi lanciare liberamente qualsiasi tipo di puntatore a qualsiasi altro tipo di puntatore. Puoi anche creare una scappatoia tra due tipi qualsiasi di tua scelta dichiarando un'unione C che ha due membri, uno per ciascuno dei tipi in questione.

Ho scritto di più sulla digitazione statica e dinamica sul perché-le-lingue-interpretate-sono-per lo più-dattilografate-mentre-compilate-hanno-digitazione-forte .

È difficile classificare ogni lingua in una digitazione "debole" o "forte": è più un continuum. Ma, rispetto ad altre lingue, C è tipizzato abbastanza fortemente. Ogni oggetto ha un tipo in fase di compilazione e il compilatore ti farà sapere (ad alta voce) se stai facendo qualcosa con un oggetto che il suo tipo non ti consente di fare. Ad esempio, non puoi chiamare funzioni con i tipi di parametri sbagliati, accedere a membri di struct / union che non esistono, ecc

Ma ci sono alcuni punti deboli. Uno dei principali punti deboli sono i typecast: essenzialmente dicono che stai andando a perdere tempo con i tipi di oggetti e il compilatore dovrebbe essere silenzioso (quando può). void*è anche un altro punto debole: è un puntatore generico a un tipo sconosciuto, e quando li usi, devi stare molto attento a fare la cosa giusta. Il compilatore non può controllare staticamente la maggior parte degli usi di void*. void*può anche essere convertito in un puntatore a qualsiasi tipo senza cast (solo in C, non in C ++), che è un altro punto debole.

La letteratura non è chiara su questo. Penso che fortemente digitato non sia sì / no, ci sono vari gradi di digitazione forte.

Un linguaggio di programmazione ha una specifica di come esegue i programmi. A volte non è chiaro come eseguire con determinati programmi. Ad esempio, programmi che tentano di sottrarre una stringa da un numero. O programmi che dividono per zero. Esistono diversi modi per affrontare queste condizioni. Alcune lingue hanno regole per gestire questi errori (ad esempio, generano un'eccezione). Altre lingue semplicemente non hanno regole per affrontare queste situazioni. Questi linguaggi hanno generalmente sistemi di tipi per impedire la compilazione di programmi che portano a comportamenti non specificati. E esistono anche linguaggi che hanno un comportamento non specificato e non hanno un sistema di tipi per prevenire questi errori in fase di compilazione (se scrivi un programma che ha un comportamento non specificato potrebbe lanciare i missili).

Così:

Le lingue che specificano ciò che accade in fase di esecuzione in ogni caso (come l'aggiunta di un numero a una stringa) sono chiamate digitate dinamicamente. I linguaggi che impediscono l'esecuzione di programmi con errori in fase di compilazione sono tipizzati staticamente. Le lingue che non specificano cosa succede e che non dispongono di un sistema di tipi per evitare errori sono chiamate debolmente tipizzate.

Quindi Java è tipizzato staticamente? Sì, perché il suo sistema di tipi non consente di sottrarre una stringa da un numero. No, perché ti permette di dividere per zero. È possibile impedire la divisione per zero in fase di compilazione con un sistema di tipi. Ad esempio creando un tipo di numero che non può essere zero (ad esempio NonZeroInt) e consente solo di dividere per numeri che hanno questo tipo.

Quindi il C è fortemente tipizzato o debolmente tipizzato? C è fortemente tipizzato perché il sistema di tipi non consente alcuni errori di tipo. Ma è debolmente digitato in altri casi quando non è definito ciò che accade (e il sistema di tipi non ti protegge).

C è considerato debolmente tipizzato, perché puoi convertire qualsiasi tipo in qualsiasi altro tipo tramite un cast, senza un errore del compilatore. Puoi leggere di più sul problema qui .

C è più tipizzato di Javascript e meno tipizzato di Ada.

Direi che rientra maggiormente nel lato fortemente tipizzato del continuum. ma qualcun altro potrebbe non essere d'accordo (anche se si sbaglia).

Che ne dici di definitivo?

C è considerato tipizzato staticamente (non è possibile modificare la variabile da int a float). Una volta che una variabile è stata dichiarata, viene bloccata in questo modo.

Ma è considerato debolmente tipizzato perché i tipi possono essere flip flop.

Cos'è 0? "\ 0", FALSE, 0.0 e così via.

in molte lingue non è possibile dire IF (variabile) perché le condizioni prenderanno solo valori booleani da espressioni booleane. Questi sono tipizzati più fortemente. Lo stesso vale per il passaggio tra caratteri e numeri interi.

fondamentalmente c ha due principali tipi di dati semplici, interi e numeri in virgola mobile (sebbene varie precisioni). Tutto il resto booleane, enumerazioni (non semplici ma adatte), ecc. Sono implementati come uno di questi. Anche i caratteri sono fondamentalmente numeri interi.

Confronta con altri linguaggi in cui sono presenti tipi stringa, tipi enum che possono essere assegnati solo ai valori definiti, tipi booleani in cui possono essere utilizzate solo espressioni che generano booleani o vero / falso.

Ma si può sostenere che rispetto a Perl C è fortemente tipizzato. Quindi è uno di quei famosi argomenti (vi vs emacs, linux vs windows, ecc.). C # è un tipo più forte di C. Fondamentalmente puoi discutere in entrambi i modi. E le tue risposte probabilmente andranno in entrambe le direzioni :) Inoltre alcuni libri di testo / pagine web diranno che C è digitato in modo debole, e alcuni diranno che C è fortemente digitato. Se vai su wikipedia la voce C dice "tipizzazione parzialmente debole". Direi che rispetto a Python C è debolmente tipizzato. Quindi Python / C #, C, Perl sul continuum.

Molte buone risposte qui. Voglio sollevare un punto importante da Real World Haskell :

È utile essere consapevoli che molte comunità linguistiche hanno le proprie definizioni di "tipo forte". Tuttavia, parleremo brevemente e in termini generali della nozione di forza nei sistemi di tipi.

(snip)

I fuochi d'artificio attorno ai sistemi di caratteri hanno le loro radici nell'inglese comune, dove le persone attribuiscono nozioni di valore alle parole "debole" e "forte": di solito pensiamo alla forza come meglio della debolezza. Molti più programmatori parlano un inglese semplice rispetto al gergo accademico, e molto spesso gli accademici lanciano davvero blocchi contro qualsiasi tipo di sistema non si adatti alla loro fantasia. Il risultato è spesso quel popolare passatempo di Internet, una guerra con le fiamme.

Quindi, guarda le risposte su C e C ++, ma ricorda che "forte" e "debole" non si associano a "buono" e "cattivo".

Secondo Dennis Ritchie ( creatore di C ) e Brian Kernighan, il C non è un linguaggio fortemente tipizzato. Le righe seguenti sono tratte dal libro Il linguaggio di programmazione C pagina 3 paragrafo 5

Il C non è un linguaggio fortemente tipizzato, ma man mano che si è evoluto, il suo controllo del tipo è stato rafforzato.

A mio parere, C / C ++ sono fortemente tipizzati. I tipi di hack che consentono di convertire i tipi (void *) esistono a causa della vicinanza di C alla macchina. In altre parole, puoi chiamare comandi assembler da Pascal e manipolare puntatori e Pascal è ancora considerato un linguaggio fortemente tipizzato. Puoi chiamare l'assembler e gli eseguibili C da Java tramite JNI ma non rende Java debolmente tipizzato.

C ha semplicemente l'assembler "incorporato" in esso con puntatori grezzi e simili.

Il termine fortemente tipizzato non ha una definizione concordata. Pertanto, a meno che tu non definisca cosa intendi per "fortemente tipizzato", è impossibile rispondere alla tua domanda.

Nella mia esperienza, i termini "fortemente tipizzato" e "debolmente tipizzato" sono usati esclusivamente dai troll, perché la loro mancanza di definizioni consente ai troll di ridefinirli a metà argomento per adattarli alla loro agenda. Oltre a far partire le guerre con le fiamme, questi termini sono praticamente inutili.

Potresti anche dare un'occhiata a Quali sono gli aspetti chiave di un linguaggio fortemente tipizzato? qui su StackOverflow.

Esiste un continuum con molteplici vie parallele tra "debolmente tipizzato" e "fortemente tipizzato", due termini che non sono nemmeno ben definiti.

C è tipizzato staticamente , in quanto il compilatore sa qual è il tipo dichiarato di ogni variabile locale e membro della struttura.

I linguaggi tipizzati dinamicamente potrebbero ancora essere tipizzati fortemente, se ogni oggetto ha un tipo specifico ma non c'è modo per il compilatore di conoscere quel tipo.

Qual è il motivo della tua domanda? Il motivo per cui lo chiedo è che questa è una specie di piccola differenza e il tuo uso particolare di "fortemente tipizzato" potrebbe richiedere più o meno chiarimenti. Direi sicuramente che Java e altri linguaggi hanno restrizioni più rigide sulla conversazione di tipo implicito.

È difficile fornire una risposta concreta quando non esiste una definizione concreta di "fortemente tipizzato". Direi che C è fortemente tipizzato in quanto ogni variabile e ogni espressione ha un tipo ma debolmente tipizzato in quanto ti permette di cambiare tipo usando i cast e di reinterpretare la rappresentazione di un tipo come un altro.

Direi che C è fortemente tipizzato come impone il tuo compilatore / piattaforma. Ad esempio, se stai costruendo su una piattaforma rigida, è probabile che la dereferenziazione di un puntatore con punte di tipo si interrompa:

void m_free(void **p)
{
        if (*p != NULL) {
                free(*p);
                *p = NULL;
        }
}

....
char *str = strdup("foo");
m_free((void **) &foo);

Ora, se dicessi al compilatore di saltare l'aliasing rigoroso, non sarebbe un problema, ma non molto portabile. Quindi, in quel senso, spingersi oltre i limiti del linguaggio è possibile ma probabilmente non è l'idea migliore. Questo va un passo oltre il tipico casting, cioè casting int il più a lungo e mostra davvero una delle possibili insidie ​​del vuoto.

Quindi, direi che C è fondamentalmente strettamente tipizzato, ma i suoi vari compilatori presumono che il programmatore lo sappia meglio e consenta una certa flessibilità. Questo dipende davvero dal compilatore, alcuni non avrebbero capito quel potenziale oops. Quindi, in questo senso, il compilatore scelto gioca davvero un ruolo quando risponde alla domanda. Ciò che è corretto spesso è diverso da ciò con cui il tuo compilatore ti permetterà di cavartela.

c è debolmente tipizzato, b è privo di tipo.

Non fortemente digitato.

Considera cosa ti dice il seguente prototipo di funzione sui tipi di dati degli argomenti:

void func (int n, char ch, ...);

Niente. Quindi suggerisco che la digitazione forte non si applica qui.

Direi che è fortemente types poiché ogni espressione ha un tipo che non è una funzione del suo valore; ei può essere conosciuto prima del runtime.

OTOH Non sono sicuro che sia la descrizione corretta di fortemente digitato. L'unica affermazione più forte che posso vedere perché un linguaggio dovrebbe fare sarebbe la certezza che non è possibile sovvertire il sistema di tipi in fase di esecuzione reinterpretando cast di tipo, unioni, chiamate in altri linguaggi, puntatori, linguaggio assembly, ecc. Linguaggi come questo esistono ma sono così paralizzati che sembrano non interessare molto ai programmatori al di fuori dell'alta certezza e del mondo accademico. Come sottolineato da qualcuno, per farlo davvero nel modo giusto inizi a dover avere tipi come nonZeroInte quant'altro. Che schifo.