Dans C# , les Termes "primitif" et "littéral" sont-ils interchangeables?
une discussion plus tôt aujourd'hui m'a amené à me demander si oui ou non ma compréhension des notions primaires et littérales est correcte.
mon interprétation est qu'un type littéral est spécifiquement un type qui peut avoir une valeur assignée en utilisant une notation que l'humain et le compilateur peuvent comprendre sans déclarations de type spécifiques:
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
ma compréhension des primitifs est qu'ils sont essentiellement les types de données élémentaires que le compilateur peut comprendre, tels que int:
int age = 25;
...un littéral pourrait être non primitif, comme le support de vb9 pour les littérales XML. Un exemple non-réel du monde serait si le système.Dessin.Point pourrait être attribué avec des littérales:
Point somePoint = 2,2; // both X and Y are primitive values, however Point is a
// composite value comprised of two primitive values
Enfin (et c'est la question qui, à son tour m'a conduit à poser les questions ci-dessus): Ma compréhension est que qu'un type soit primitif ou littéral, il n'y a pas de relation directe à savoir s'il s'agit d'un type de valeur ou de référence.
, par exemple Système.String est un type de référence qui supporte les littérales. Les structures définies sur mesure sont des types de valeurs composites qui ne supportent pas les littérales.
est-ce que ma compréhension (sinon mon explication) est correcte pour la plupart?
mise à Jour: Merci pour l'info et les conversations! Pour ceux qui trouvent cela, assurez-vous de lire les commentaires ainsi que les réponses, Il ya quelques grandes clarifications réparties autour ainsi que quelques notes secondaires intéressantes.
btw: c'est un mélange entre lequel réponse est vraiment digne d'obtenir le grand chèque vert. Je le donne à la réponse malheureusement rétrograde qui contient non seulement une réponse décente mais beaucoup de clarification et d'information dans le fil de commentaires. Pour être juste il n'y a pas une meilleure réponse ici, il y en a au moins trois :)
8 réponses
je suppose qu'une chose que vous n'avez pas mentionnée est l'espace et l'allocation. Les Primitives sont des types de valeurs et sont attribuées sur la pile (à condition qu'elles ne soient pas associées à un objet) sauf pour le type de chaîne de caractères comme vous l'avez mentionné (la classe string alloue son espace sur le tas).
bien que les objets eux-mêmes contiennent des primitives, là réside le stockage où l'objet réel est alloué, qui est sur le tas.
autre que votre déclaration est assez bien écrit. Vous avez une question spécifique que j'ai raté :)?
je voulais juste injecter une petite note ici.
la spécification du langage C# définit clairement" littéral "-- un littéral est une représentation du code source d'une valeur . Les littérales sont des choses comme true, 10, 5.7,' c', "hello" et null -- elles sont text qui représente une valeur spécifique .
La spécification du langage C# utilise le mot "primitif" à deux reprises; il n'est jamais défini et complètement vague quant à ce que cela pourrait signifier.
le C# language spec n'a pas besoin d'utiliser ou de définir le mot" primitif " et ne devrait donc pas utiliser ce terme vague. J'ai eu une discussion avec Mads et nous avons convenu que les prochaines éditions du spec seront reformulées pour éliminer complètement cet usage.
comment d'autres spécifications de systèmes de type -- la bibliothèque de réflexion, le CLI, le VES, et ainsi de suite -- définissent le mot "primitif" est cours jusqu'à eux.
Merci d'avoir soulevé la question.
ma compréhension (si ce n'est mon explication) est-elle correcte dans la plupart des cas?
Je ne suis pas d'accord sur un point:
Un littéral est une sorte de constante de temps de compilation (comme "Hello World" , 5 ou 'A' ). Cependant, il n'y a pas de" type littéral"; la valeur littérale est toujours la valeur réelle.
types Primitifs sont OMI "de base" de type string, int, double, float, bref, ...
si primitif ont leurs types de littérales en rapport avec eux.
Oui, un littéral est une valeur exprimée en code source - donc, alors que VB supporte les littérales date/heure et XML, C# ne le fait pas.
du C# spec, section 2.4.4:
Un littérale est un code source représentation d'une valeur.
comme vous le dites, ceci n'est pas lié au type de valeur vs type de référence - la chaîne de caractères est en effet un type de référence.
un littéral que personne n'a encore mentionné il null soit dit en passant...
ça n'a rien à voir avec les types primitifs. Type.IsPrimitive :
les types primitifs sont booléens, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double et Unique.
... la spécification C# ne définit pas réellement l'idée d'un type "primitif", mais notez que String n'est pas dans la liste ci-dessus.
en termes de constantes de temps de compilation... dans C# chaque littéral a une représentation qui peut être cuite directement dans l'assemblée; les littérales supplémentaires dans VB signifient qu'elles ne sont pas constantes comme le CLR les comprendrait - vous ne pouvez pas avoir un const DateTime par exemple - mais elles sont toujours littérales.
Ici est une page MSDN, de parler de la CEMAT, qui comprend chaîne comme un type primitif:
.NET Framework bibliothèque de classe comprend les types qui correspondent à la types de données primitives qui compilent utiliser. De ces types, sont les suivantes Conforme CLS: Byte, Int16, Int32, Int64, Simple, Double, Boolean, Char, Décimal, IntPtr et String. Pour plus d' informations sur ces types, voir la tableau des types de la classe .net Framework Bibliothèque De Synthèse.
N'oubliez pas qu'il existe aussi le ASP.Net Classe littérale .
EDIT: ainsi, une réponse à la question dans le titre est non, car il n'y a pas de classe "Primitive" qui fournit la même fonctionnalité. Cela peut être considéré comme un peu d'une réponse intelligente alec, bien que.
je pense que votre compréhension est en grande partie correcte. Comme winSharp93 l'a dit, les littérales sont des valeurs qui elles-mêmes ont des types, mais il n'y a pas de "type littéral". C'est-à-dire, alors que vous pouvez avoir des caractères littéraux, les cordes ne sont pas un "type littéral". Comme vous l'avez deviné, ce qui définit un littéral est que la valeur est écrite directement dans le code source, bien que votre exigence qu'aucun type ne doit être spécifié semble trop stricte (par exemple F# a un tableau littérales, et peut déduire le type du tableau littéral [| 1; 2; 3 |] , mais ne peut pas nécessairement inférer le type du tableau vide littéral [| |] ).
malheureusement, je ne pense pas qu'il y ait une définition bien convenue de ce qui fait une primitive. Certes, comme le fait remarquer Jon Skeet, le CLR a sa propre définition de la primitivité ( Type.IsPrimitive ), qui exclut les cordes. Cependant, autres sources réputées considèrent string et même object comme primitif types au sein de C#. Je préfère cette définition, car il y a un support intégré dans C# pour les chaînes, comme l'utilisation de l'opérateur + pour la concaténation et l'utilisation de == comme égalité de valeur plutôt que l'égalité de référence, ainsi que le fait que le type de chaîne peut être mentionné en utilisant la forme courte string plutôt que d'avoir à utiliser le nom complet System.String .
juste pour ajouter qu'il y a un autre type qui brouille la limite: System.Decimal dont les valeurs peuvent être exprimées comme littérales dans le c# langue, mais qui n'est pas un type primitif .Net .
IMHO primitive types pourrait être simplement défini comme des types qui "existe" directement dans chaque sous-jacent plate-forme / hôte : si vous avez vous savez que vous avez des octets, des mots, des mots doubles... mais vous n'avez ni ficelles ni décimales.
en effet . les décimales Net sont émulées " par le.net runtime et ne sont pas directement manipulées par le matériel qui ne comprend que IEEE 754 nombres à virgule flottante (flotteurs et doubles qui sont alors des types primitifs).
par extension de la notion des valeurs littérales "types littéraux" peuvent être considérés comme n'importe quel type dont les valeurs peuvent être directement exprimées dans une langue donnée (C#, VB.Net, CIL...). Avec cette définition types littéraux seraient: tous les types primitifs + chaînes + décimales .