In C # sono i termini “primitiva” e “letterale” intercambiabili?

StackOverflow https://stackoverflow.com/questions/2066035

Domanda

Una discussione prima di oggi mi ha portato a mettere in discussione o meno la mia comprensione di primtives e letterali è corretta.

La mia comprensione è che un tipo letterale è specificamente un tipo che può avere un valore assegnato utilizzando una notazione che sia umana e compilatore può capire senza dichiarazioni di tipo specifiche: 

var firstName = "John"; // "John" is literal

var firstName = (string)"John"; // *if* the compiler didn't understand that "John"
                                // was a literal representation of a string then I
                                // would have to direct it as such

La mia comprensione di primitive è che sono essenzialmente i tipi di dati elementari che il compilatore può capire, come int: 

int age = 25;

... un letterale potrebbe essere non primitivo, come il supporto di VB9 per letterali XML. Un esempio del mondo non reale sarebbe se System.Drawing.Point potrebbe essere assegnato con letterali: 

Point somePoint = 2,2; // both X and Y are primitive values, however Point is a
                       // composite value comprised of two primitive values

Infine (e questa è la domanda che a sua volta mi ha portato a fare le domande di cui sopra): La mia comprensione è che se un tipo è primitivo o letterale non v'è alcuna relazione diretta se si tratta di un tipo di valore o di riferimento.

Per esempio System.String è un tipo di riferimento che supporta letterali. strutture personalizzate definite dall'utente sono tipi di valore compositi che non supportano letterali.

è la mia comprensione (se non la mia spiegazione) corretta per la maggior parte?

Aggiornamento: Grazie per il grande informazioni e conversazioni! A chiunque trovare questo, assicuratevi di leggere i commenti e le risposte, ci sono alcuni grandi chiarimenti sparsi così come un paio di interessanti collaterali note.

A proposito: si tratta di un lancio-up tra le quali risposta è davvero meritevole di ottenere il grande segno di spunta verde. Sto dando alla risposta, purtroppo downvoted che contiene non solo una risposta decente, ma un sacco di chiarimenti e informazioni nel thread commenti. Per essere onesti, non c'è una risposta migliore qui, c'è almeno tre:)

È stato utile?

Soluzione

Credo che una cosa che non ha citato è lo spazio e l'allocazione. Primitive sono tipi di valore e sono allocate sullo stack (purché non sono associate ad un oggetto) eccetto il tipo stringa come avete accennato (classe stringa alloca il suo spazio sul mucchio).

Sebbene oggetti stessi contengono primitive ci stoccaggio risiede dove l'oggetto effettivo è allocato, che è sul mucchio.

Altri poi che la sua dichiarazione è abbastanza ben scritto. Avete una domanda specifica che mi mancava:?)

Altri suggerimenti

Volevo solo iniettare una breve nota qui.

La specifica del linguaggio C # definisce chiaramente "letterale" - un letterale è un il codice sorgente rappresentazione di un valore . Letterali sono cose come true, 10, 5.7, 'c', "hello" e null -. Sono testo , che rappresenta un valore specifico

La specifica del linguaggio C # usa la parola "primitivo" due volte; non è mai definita e completamente vaga di ciò che potrebbe significare.

Il # lingua spec C non ha bisogno di utilizzare o definire la parola "primitivo" e quindi non dovrebbe fare uso di questo termine vago. Ho avuto un colloquio con Mads e abbiamo concordato che le future edizioni del spec saranno riformulati per eliminare completamente questo utilizzo.

Come altri sistemi di tipo specifiche - la biblioteca di riflessione, la CLI, la VES, e così via - definire la parola "primitivo" è, naturalmente, spetta a loro.

Grazie per aver portato la questione.

  

è la mia comprensione (se non la mia spiegazione) corretta per la maggior parte?

Non sono d'accordo in un punto: Un letterale è una sorta di costante di tempo di compilazione (come "Hello World", 5 o 'A'). Tuttavia, non ci sono "letterali-Tipi"; il letterale è sempre il valore effettivo.

I tipi primitivi sono IMO tipi "di base" come stringa, int, double, float, insomma, ...

Quindi primitivi hanno i loro tipi di letterali ad esse collegate.

Sì, un letterale è un valore espresso in codice sorgente -. Così, mentre VB supporta data / ora e letterali XML, C # non lo fa

Dalla C # spec, sezione 2.4.4:

  

A letterale è un codice sorgente   rappresentazione di un valore.

Come dici tu, questo non è correlato al tipo di valore vs tipo di riferimento -. Stringa è infatti un tipo di riferimento

Un letterale che nessuno ha menzionato eppure null a proposito ...

E 'anche estranei a tipi primitivi - da Type.IsPrimitive :

  

I tipi primitivi sono booleano, Byte,   SByte, Int16, UInt16, Int32, UInt32,   Int64, UInt64, IntPtr, UIntPtr, Char,   Doppio e Singolo.

... la specifica C # in realtà non definisce l'idea di un tipo "primitivo", ma nota che String non è nella lista di cui sopra.

In termini di letterali di essere costanti in fase di compilazione di tempo ... in C # ogni letterale ha una rappresentazione che può essere cotto direttamente nel gruppo; i letterali supplementari in VB significa che non sono costanti come il CLR li avrebbe capito - non si può avere un const DateTime per esempio - ma sono ancora letterali

.

Qui è una pagina di MSDN , parlando dei CLS, che include stringa come un tipo primitivo:

  

La libreria di classi .NET Framework   comprende modelli che corrispondono ai   tipi di dati primitivi che i compilatori   uso. Di questi tipi, i seguenti sono   CLS-compliant: Byte, Int16, Int32,   Int64, Singolo, Doppio, booleano, Char,   Decimale, IntPtr, e String. Per più   informazioni su questi tipi, vedere la   Tabella dei tipi in .NET Framework   Panoramica libreria.

Non dimenticare esiste anche la ASP.Net classe letterale .

EDIT: Così, una risposta alla domanda nel titolo è no, in quanto non v'è una classe "primitivo" che fornisce la stessa funzionalità. Questo può essere visto come un po 'di una risposta alec intelligente, però.

Credo che la vostra comprensione è per lo più corretta. Come ha detto winSharp93, letterali sono valori che a loro volta hanno tipi, ma non c'è cosa come un "tipo letterale". Cioè, mentre si può avere stringhe letterali, le stringhe non sono un "tipo letterale". Come avete indovinato, ciò che definisce un letterale è che il valore è direttamente svalutato nel codice sorgente, anche se il vostro requisito che nessun tipo deve essere specificato sembra eccessivamente severe (ad esempio F # Ha letterali di array, e può dedurre il tipo di array letterale [| 1; 2; 3 |], ma non può necessariamente dedurre il tipo di matrice [| |] letterale vuoto).

Purtroppo, non credo che ci sia un ben concordato-upon-definizione di ciò che rende un primitivo. Certo, come sottolinea Jon Skeet, il CLR ha la propria definizione di primitività (Type.IsPrimitive), che esclude le stringhe. Tuttavia, altre fonti attendibili considerano string e anche object di essere tipi primitivi all'interno di C #. Io preferisco questa definizione, poiché non v'è supporto incorporato in C # per le stringhe, come ad esempio l'utilizzo dell'operatore + per la concatenazione e l'uso di == come uguaglianza valore piuttosto che l'uguaglianza di riferimento, così come il fatto che il tipo stringa può essere indicato utilizzando il modulo breve string piuttosto che dover usare il nome System.String completo.

Basta aggiungere che c'è un altro tipo che offusca il limite: System.Decimal i cui valori possono essere espressi come letterali nella C # la lingua, ma che non è un Net tipo primitivo .

IMHO tipi primitivi potrebbe essere semplicemente definito come tipi che direttamente "esiste" in ogni sottostante Piattaforma / host : se hai già giocato con il linguaggio assembly si sa che avete byte, parole, doppie parole ... ma non hai stringhe o decimali.

Infatti decimali Net sono " emulato " dal runtime Net e non sono direttamente gestite dal hardware che comprende solo IEEE 754 numeri a virgola mobile (float e doppie che sono poi tipi primitivi).

Per estensione del concetto di valori letterali "tipi letterali" potrebbe essere considerato come qualsiasi tipo i cui valori possono essere espressi direttamente in una determinata lingua (C #, VB.Net, CIL ...) . Con questa definizione tipi letterale sarebbe:. tutti i tipi primitivi + stringhe + decimali

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top