C è fortemente digitato?

Per citare Wikipedia :

Due linguaggi comunemente usati che supportano molti tipi di conversione implicita sono C e C ++, e talvolta si sostiene che questi linguaggi sono tipizzati debolmente. Tuttavia, altri sostengono che questi linguaggi pongono restrizioni sufficienti 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 tipizzato” e “debolmente tipizzato” sono termini che non hanno un significato tecnico ampiamente concordato. I termini che hanno un significato ben definito sono

    • Digitando dynamicmente significa che i tipi sono associati ai valori in fase di esecuzione e un tentativo di mischiare valori di tipi diversi può causare un “errore di tipo run-time”. 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 incriminato.

    • La tipizzazione statica significa che i tipi vengono controllati in fase di compilazione e un programma che non ha 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). Si ottiene sempre l’errore anche se il codice potrebbe non essere mai eseguito.

    Diverse persone preferiscono sistemi diversi in parte in base a quanto apprezzano la flessibilità e quanto si preoccupano degli errori di runtime.

    A volte “fortemente tipizzato” viene utilizzato genericamente per indicare “staticamente digitato” e “debolmente tipizzato” viene utilizzato in modo errato per indicare “digitato dynamicmente”. Un uso migliore del termine “fortemente tipizzato” è che “non è ansible aggirare o sovvertire il sistema di tipi”, mentre “debolmente tipizzato” significa “ci sono scappatoie nel sistema dei tipi”. Perversamente, la maggior parte delle lingue con sistemi di tipo statico presenta lacune, mentre molte lingue con sistemi di tipi dinamici non hanno scappatoie.

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

    Se vuoi parlare con precisione dei linguaggi di programmazione, è meglio evitare i termini “fortemente tipizzato” e “debolmente digitato”. Direi che C è un linguaggio che è tipizzato staticamente ma che ha molte lacune. Una lacuna è che puoi liberamente lanciare qualsiasi tipo di puntatore a qualsiasi altro tipo di puntatore. Puoi anche creare una scappatoia tra due tipi qualsiasi di tua scelta dichiarando un sindacato C che ha due membri, uno per ciascuno dei tipi in questione.

    Ho scritto di più sulla tipizzazione statica e dynamic al perché -interpretato-langs-sono-per lo più -difficato-mentre-compilato-ho-forte-digitando .

    È difficile classificare tutte le lingue in “debolmente” o “fortemente” tipizzate – è più di un continuum. Ma, rispetto ad altri linguaggi, C è abbastanza fortemente digitato. Ogni object ha un tipo in fase di compilazione, e il compilatore ti farà sapere (a voce alta) se stai facendo qualcosa con un object che il suo tipo non ti permette di fare. Ad esempio, non è ansible chiamare funzioni con tipi di parametri errati, accedere a struct / union members che non esistono, ecc.

    Ma ci sono alcuni punti deboli. Una delle principali debolezze è rappresentata dalle tipografie: in sostanza, si dice che si sta andando in giro 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.

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

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

    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 cercano di sottrarre una stringa da un numero. O programmi che dividono per zero. Ci sono diversi modi per affrontare queste condizioni. Alcune lingue hanno regole per gestire questi errori (ad esempio lanciano un’eccezione). Altre lingue semplicemente non hanno regole per affrontare queste situazioni. Queste lingue generalmente dispongono di sistemi di tipi per impedire la compilazione di programmi che portano a un comportamento non specificato. Esistono anche linguaggi con un comportamento non specificato e che non dispongono di un sistema di tipi per prevenire questi errori in fase di compilazione (se si scrive un programma che presenta un comportamento non specificato potrebbe lanciare i missili).

    Così:

    Le lingue che specificano ciò che accade al runtime in ogni caso (come l’aggiunta di un numero a una stringa) sono chiamate digitate dynamicmente. Le lingue che impediscono l’esecuzione di programmi con errori in fase di compilazione sono tipizzate in modo statico. Le lingue che non specificano ciò che accade e inoltre non dispongono di un sistema di tipi per prevenire errori vengono chiamate digitate debolmente.

    Quindi Java è tipizzato staticamente? Sì, perché il suo sistema di tipo non consente di sottrarre una stringa da un numero. No, perché ti permette di dividere per zero. È ansible 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, C è fortemente tipizzato o debolmente tipizzato? C è fortemente digitato perché il sistema di tipo non consente alcuni errori di tipo. Ma è debolmente digitato in altri casi quando non è definito cosa succede (e il sistema di tipi non ti protegge).

    C è più fortemente digitato di Javascript e meno fortemente digitato di Ada.

    Direi che rientra maggiormente nel lato fortemente tipizzato del continuum. ma qualcun altro potrebbe non essere d’accordo (anche se hanno torto).

    Come è definitivo?

    C è considerato staticamente digitato (non si può avere una variazione variabile da int a float). Una volta che una variabile è dichiarata, è bloccata in quel modo.

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

    Cos’è 0? ‘\ 0’, FALSE, 0.0, ecc.

    in molte lingue non puoi dire IF (variabile) perché le condizioni prenderanno solo valori booleani dalle espressioni booleane. Questi sono più fortemente tipizzati. Lo stesso vale per passare tra caratteri e interi.

    fondamentalmente c ha due principali tipi di dati semplici, numeri interi e numeri in virgola mobile (sebbene varie precisioni). Tutto il resto, booleans, enum (non semplice ma si adatta), ecc. Sono implementati come uno di quelli. Persino i personaggi sono fondamentalmente interi.

    Confrontati con altre lingue in cui esistono tipi di stringhe, tipi di enumerazione 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 digitato. Quindi è uno di quei famosi argomenti (vi vs emacs, linux vs windows, ecc.). C # è più forte digitato di C. Fondamentalmente si può discutere in entrambi i modi. E le tue risposte probabilmente andranno in entrambe le direzioni 🙂 Anche alcuni libri di testo / pagine web diranno che C è debolmente digitato, e alcuni diranno che C è fortemente digitato. Se vai su wikipedia, la voce C dice “caratteri parzialmente deboli”. Direi che rispetto a Python C è debolmente tipizzato. Quindi Python / C #, C, Perl sul continuum.

    Un sacco di buone risposte qui. Voglio sollevare un punto importante da Real World Haskell :

    È utile essere consapevoli che molte comunità linguistiche hanno le loro 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 tipo hanno le loro radici nell’ordinario inglese, dove le persone attribuiscono nozioni di valore alle parole “debole” e “forte”: di solito consideriamo la forza come migliore della debolezza. Molti programmatori parlano un inglese semplice rispetto al gergo accademico, e molto spesso gli accademici lanciano mattoni di ogni tipo a qualunque tipo di sistema non sia adatto alle loro fantasie. Il risultato è spesso il passatempo Internet popolare, una guerra di fuoco.

    Quindi, guarda le risposte a C e C ++, ma ricorda che “forte” e “debole” non sono “buoni” e “cattivi”.

    A mio parere, C / C ++ sono fortemente tipizzati. Il tipo di hack che consente la conversione dei tipi (void *) è presente grazie alla vicinanza di C alla macchina. In altre parole, è ansible chiamare i comandi assembler da Pascal e manipolare i puntatori e Pascal è ancora considerato come un linguaggio fortemente tipizzato. È ansible chiamare assembler e eseguibili C da Java a JNI, ma ciò non significa che Java sia stato tipizzato debolmente.

    C ha solo l’assemblatore “incorporato” in esso con i puntatori grezzi e così via.

    Il termine fortemente tipizzato non ha una definizione concordata. Pertanto, a meno che tu non definisca cosa intendi con “fortemente tipizzato”, è imansible rispondere alla tua domanda.

    Secondo la 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 al loro ordine del giorno. Oltre a far partire flamewar, questi termini sono praticamente inutili.

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

    Secondo Dennis Ritchie ( creatore di C ) e Brian Kernighan, C non è un linguaggio fortemente tipizzato. Le seguenti righe sono tratte dal libro The C programming language page 3 paragraph 5

    C non è un linguaggio fortemente tipizzato, ma come si è evoluto, il suo tipo di controllo è stato rafforzato.

    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 struct.

    Le lingue digitate dynamicmente potrebbero essere ancora fortemente digitate, se ogni object ha un tipo specifico ma non è ansible per il compilatore conoscerne il tipo.

    c è debolmente tipizzato, b è senza tipo.

    Qual è il motivo della tua richiesta? Il motivo per cui lo chiedo è che questa è una specie di piccola differenza e il tuo particolare uso di “fortemente tipizzato” potrebbe richiedere più o meno chiarimenti. Direi sicuramente che Java e altre lingue hanno restrizioni più restrittive sulla conversazione di tipo implicita.

    È 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 digitata debolmente, che ti permette di cambiare i tipi usando i cast e di reinterpretare la rappresentazione di un tipo come un altro.

    Direi che C è fortemente digitato come il tuo compilatore / piattaforma impone. Ad esempio, se stai costruendo su una piattaforma rigida, il dereferenziamento di un puntatore punteggiato di tipo probabilmente si romperà:

     void m_free(void **p) { if (*p != NULL) { free(*p); *p = NULL; } } .... char *str = strdup("foo"); m_free((void **) &foo); 

    Ora, se hai detto al compilatore di ignorare il rigoroso aliasing, sarebbe un problema, ma non molto portabile. Quindi, in questo senso, spingere i limiti del linguaggio è ansible ma probabilmente non è la migliore idea. Questo va oltre il cast tipico, ovvero il casting int lungo e mostra davvero una delle possibili insidie ​​del vuoto.

    Quindi, direi che C è fondamentalmente tipizzato, ma i suoi vari compilatori presumono che il programmatore sappia fare meglio e permetta una certa flessibilità. Questo dipende molto dal compilatore, alcuni non prenderebbero su quel potenziale oops. Quindi in questo senso, il compilatore di scelta gioca davvero un ruolo nel rispondere alla domanda. Ciò che è corretto spesso differisce da ciò che il compilatore ti permetterà di farla franca.

    Non fortemente digitato

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

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

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

    Direi che è fortemente composto in quanto 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 tipizzata. L’unica affermazione più forte in cui posso vedere la ragione per un linguaggio è la certezza che non è ansible sovvertire il sistema di tipi in fase di esecuzione tramite reinterpretare cast di tipi, unioni, chiamate in altre lingue, puntatori, linguaggio assembly ecc. esistono ma sono così paralizzati che sembrano non interessare molto i programmatori al di fuori delle alte sfere di sicurezza e del mondo accademico. Come sottolineato da qualcuno, per farlo davvero bene inizi a dover avere tipi come nonZeroInt e quant’altro. Che schifo.