En C # sont les termes « primitives » et « littérales » interchangeables?

https://stackoverflow.com/questions/2066035

20-09-2019
|

Question

Une discussion plus tôt aujourd'hui m'a amené à se demander si ou non ma compréhension de primtives et littéraux est correcte.

Si je comprends qu'un type littéral est spécifiquement un type qui peut avoir une valeur attribuée en utilisant une notation humaines et le compilateur peut 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 primitives est qu'ils sont essentiellement les types de données élémentaires que le compilateur peut comprendre, comme int:

int age = 25;

... un littéral pourrait être non primitive, comme le soutien de VB9 pour littéraux XML. Un exemple du monde non réel serait si System.Drawing.Point pourrait être attribué littéraux:

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

Enfin (et ceci est la question qui, à son tour m'a amené à poser les questions ci-dessus): Je crois comprendre que si un type est relation primitive ou littérale il n'est directement si elle est un type de valeur ou de référence.

Par exemple System.String est un type de référence qui prend en charge les littéraux. structures définies sur mesure sont les types de valeurs composites qui ne supportent pas les littéraux.

Je crois comprendre (sinon mon explication) correcte pour la plupart?

Mise à jour: Merci pour la grande information et les conversations! Pour toute personne qui trouve cela, assurez-vous de lire les commentaires ainsi que les réponses, il y a quelques grands éclaircissements répartis dans ainsi que quelques fausses notes intéressantes.

BTW: il est un entre-toss qui répond est vraiment digne d'obtenir le gros chèque vert. Je donne à la réponse downvoted, malheureusement, qui contient non seulement une réponse décente, mais beaucoup de clarification et d'information dans le fil des commentaires. Pour être honnête il n'y a pas une meilleure réponse ici, il y a au moins trois:)

La solution

Je suppose une chose que vous n'avez pas mentionné l'espace et de l'allocation. Primitives sont les types de valeur et sont attribués sur la pile (tant qu'ils ne sont pas associés à un objet) à l'exception du type de chaîne que vous avez mentionné (la classe de chaîne alloue son espace sur le tas).

Bien que les objets eux-mêmes contiennent des primitives il réside stockage où l'objet réel est alloué, qui est sur le tas.

A part que votre déclaration est assez bien écrit. Avez-vous une question précise que je manqué?)

Autres conseils

Je voulais juste injecter une note rapide ici.

La spécification du langage C # définit clairement "littérale" - un littéral est un code source représentation d'une valeur . Littéraux sont des choses comme true, 10, 5.7, 'c', "hello" et null -. Ils sont text qui représente une valeur spécifique

La spécification du langage C # utilise le mot « primitif » deux fois; il est jamais défini et complètement vague quant à ce qu'il pourrait vouloir dire.

La spécification du langage C # n'a pas besoin d'utiliser ou de définir le mot « primitif » et ne devrait donc pas faire usage de ce terme vague. J'ai eu un entretien avec Mads et nous avons convenu que les futures éditions de la spécification seront reformulées pour éliminer complètement cet usage.

Comment les autres spécifications des systèmes de type - la bibliothèque de réflexion, la CLI, le VES, et ainsi de suite - définir le mot « primitif » est bien sûr à eux.

Merci d'avoir soulevé la question.

Je crois comprendre (sinon mon explication) correcte pour la plupart?

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 « littérales-types »; le littéral est toujours la valeur réelle.

Les types primitifs sont OMI types "de base" comme chaîne, int, double, flotteur, bref, ...

Alors primitif leurs types de littéraux connectés avec eux.

Oui, un littéral est une valeur exprimée en code source -. Ainsi, alors que VB prend en charge la date / heure et littéraux XML, C # ne pas

A partir de la spécification C #, section 2.4.4:

littéral est un code source représentation d'une valeur.

Comme vous le dites, cela est sans rapport avec le type de valeur par rapport type de référence -. Chaîne est en effet un type de référence

Un littéral dont personne ne l'a mentionné mais il null par la manière ...

Il est également sans rapport avec les types primitifs - de Type.IsPrimitive :

Les types primitifs sont Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double et simple.

... la spécification C # ne définit pas l'idée d'un type « primitive », mais notez que String est pas dans la liste ci-dessus.

En termes de littéraux étant des constantes à la compilation ... en C # chaque littéral a une représentation qui peut être cuit directement dans l'ensemble; les littéraux supplémentaires en VB signifie qu'ils ne sont pas constantes que le CLR les comprendrais - vous ne pouvez pas avoir un const DateTime par exemple - mais ils sont encore littéraux

est une page MSDN , en parlant de la CLS, qui comprend string comme un type primitif:

Le .NET Framework bibliothèque de classes comprend les types qui correspondent à la les types de données primitifs que les compilateurs utilisation. Parmi ces types, les éléments suivants sont Conforme CLS: Byte, Int16, Int32, Int64, Simple, Double, Boolean, Char, Décimal, IntPtr et String. Pour plus informations sur ces types, consultez le table des types de classes .NET Framework dans Vue d'ensemble Bibliothèque.

Ne pas oublier qu'il existe aussi ASP.Net classe littérales.

EDIT: Ainsi, une réponse à la question dans le titre est pas, car il n'y a pas une classe « primitive » qui fournit les mêmes fonctionnalités. Cela peut être considéré comme un peu d'une réponse intelligente alec, cependant.

Je pense que votre compréhension est la plupart du temps correct. Comme winSharp93 dit littéraux sont des valeurs qui ont eux-mêmes types, mais il n'y a pas une telle chose comme un « type littéral ». Autrement dit, alors que vous pouvez avoir des chaînes littérales, les chaînes ne sont pas un « type littéral ». Comme vous l'avez deviné, ce qui définit un littéral est que la valeur est directement écrit dans le code source, bien que votre exigence qui doit être spécifié aucun type semble trop stricte (par exemple F # a littéraux de tableau, et peut déduire le type de tableau littéral [| 1; 2; 3 |], mais ne peut pas en déduire nécessairement le type de tableau vide [| |] littéral).

Malheureusement, je ne pense pas qu'il y ait une définition, sur le bien-convenu de ce qui fait une primitive. Certes, comme Jon Skeet souligne, le CLR a sa propre définition de primitivisme (Type.IsPrimitive), ce qui exclut les chaînes. Cependant, autres sources fiables considèrent string et même object soient les types primitifs au sein de C #. Je préfère cette définition, car il est un support intégré en C # pour les chaînes, telles que l'utilisation de l'opérateur + pour la concaténation et l'utilisation de == l'égalité de la valeur plutôt que l'égalité de référence, ainsi que le fait que le type de chaîne peut être soumis à l'aide de la forme courte string plutôt que d'avoir à utiliser le System.String nom complet.

Il suffit d'ajouter qu'il existe un autre type qui brouille la limite: System.Decimal dont les valeurs peuvent être exprimées en littéraux dans C # langue, mais qui ne constitue pas une Net type primitif .

IMHO les types primitifs pourrait être définie simplement comme des types qui directement « existe » dans tous les sous-jacents Plate-forme / hôte : si vous avez déjà joué avec le langage assembleur vous savez que vous avez octets, mots, doubles mots ... mais vous n'avez pas des chaînes ou des décimales.

En effet .Net décimales sont " émulé " par le moteur d'exécution .Net et ne sont pas directement traitées par le matériel qui ne comprend que IEEE 754 des nombres à virgule flottante (float et doubles qui sont ensuite types primitifs).

Par extension de la notion de valeurs littérales "types littérales" pourrait être considéré comme tout type dont les valeurs peuvent être exprimées directement dans une langue donnée (C #, VB.Net, CIL ...) . Avec cette définition types littérale serait:. tous les types primitifs + chaînes + décimales

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow