Type de données scalaire vs primitif - est-ce la même chose?

Dans divers articles que j'ai lus, il y a parfois des références à des types de données primitifs et parfois des références à des scalaires.

Ma compréhension de chacun est qu'il s'agit de types de données de quelque chose de simple comme un int, un booléen, un char, etc.

Y a-t-il quelque chose qui me manque qui signifie que vous devriez utiliser une terminologie particulière ou les termes sont-ils simplement interchangeables? Les pages Wikipédia de chacun ne montrent rien d'évident.

Si les termes sont simplement interchangeables, quel est celui que vous préférez?

Je ne pense pas qu'ils soient interchangeables. Ils sont souvent similaires, mais la différence existe et semble résider principalement dans ce avec quoi ils sont mis en contraste et ce qui est pertinent dans le contexte.

Les scalaires sont généralement comparés aux composés , tels que les tableaux, les cartes, les ensembles, les structures, etc. Un scalaire est une valeur "unique" - entier, booléen, peut-être une chaîne - tandis qu'un composé est composé de plusieurs scalaires (et éventuellement de références à autres composés). «Scalaire» est utilisé dans des contextes où la distinction pertinente est entre les valeurs uniques / simples / atomiques et les valeurs composées.

Les types primitifs , cependant, sont mis en contraste avec les types de référence , par exemple , et sont utilisés lorsque la distinction pertinente est "Est-ce directement une valeur ou est-ce une référence à quelque chose qui contient la valeur réelle?", Comme dans les types primitifs de Java par rapport aux références . Je vois cela comme une distinction de niveau un peu plus bas que scalaire / composé, mais pas tout à fait.

Cela dépend vraiment du contexte (et souvent de la famille de langues discutée). Pour prendre un exemple, peut-être pathologique: les cordes. En C, une chaîne est un composé (un tableau de caractères), tandis qu'en Perl, une chaîne est un scalaire. En Java, une chaîne est un objet (ou un type de référence). En Python, tout est (conceptuellement) un type objet / référence, y compris les chaînes (et les nombres).

Il y a beaucoup de confusion et d'abus de ces termes. Souvent, l'un est utilisé pour signifier un autre. Voici ce que ces termes signifient réellement.

«Native» fait référence aux types qui sont intégrés au langage, par opposition à être fournis par une bibliothèque (même une bibliothèque standard), quelle que soit la façon dont ils sont implémentés. Les chaînes Perl font partie du langage Perl, elles sont donc natives en Perl. C fournit une sémantique de chaîne sur des pointeurs vers des caractères à l'aide d'une bibliothèque, le pointeur vers char est donc natif, mais les chaînes ne le sont pas.

"Atomic" fait référence à un type qui ne peut plus être décomposé. C'est l'opposé de «composite» . Les composites peuvent être décomposés en une combinaison de valeurs atomiques ou d'autres composites. Les entiers natifs et les nombres à virgule flottante sont atomiques. Les fractions, les nombres complexes, les conteneurs / collections et les chaînes sont composites.

«Scalaire» - et c'est celui qui déroute la plupart des gens - fait référence à des valeurs qui peuvent exprimer l'échelle (d'où le nom), telles que la taille, le volume, les nombres, etc. Les entiers, les nombres à virgule flottante et les fractions sont des scalaires. Les nombres complexes, les booléens et les chaînes ne sont PAS des scalaires. Quelque chose qui est atomique n'est pas nécessairement scalaire et quelque chose qui est scalaire n'est pas nécessairement atomique. Les scalaires peuvent être natifs ou fournis par des bibliothèques.

Certains types ont des classifications étranges. Les types BigNumber, généralement implémentés sous forme de tableau de chiffres ou d'entiers, sont des scalaires, mais ils ne sont techniquement pas atomiques. Ils peuvent sembler atomiques si l'implémentation est masquée et que vous ne pouvez pas accéder aux composants internes. Mais les composants ne sont que cachés, donc l'atomicité est une illusion. Ils sont presque toujours fournis dans les bibliothèques, ils ne sont donc pas natifs, mais ils pourraient l'être. Dans le langage de programmation Mathematica, par exemple, les grands nombres sont natifs et, comme il n'y a aucun moyen pour un programme Mathematica de les décomposer en leurs blocs de construction, ils sont également atomiques dans ce contexte, malgré le fait qu'ils soient composites sous le couvertures (où vous n'êtes plus dans le monde du langage Mathematica).

Ces définitions sont indépendantes de la langue utilisée.

En termes simples, il semblerait qu'un type «scalaire» se réfère à un élément unique, par opposition à un composite ou à une collection. Les scalaires incluent donc à la fois des valeurs primitives et des éléments comme une valeur d'énumération.

http://ee.hawaii.edu/~tep/EE160/Book/chap5/section2.1.3.html

Peut-être que le terme `` scalaire '' peut être un retour à C:

où les scalaires sont des objets primitifs qui contiennent une seule valeur et ne sont pas composés d'autres objets C ++

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1995/N0774.pdf

Je suis curieux de savoir si cela se réfère à si ces éléments auraient une valeur de «échelle»? - Tels que compter les nombres.

J'aime la réponse de Scott Langeberg car elle est concise et appuyée par des liens faisant autorité. Je voterais pour la réponse de Scott si je le pouvais.

Je suppose que le type de données "primitif" pourrait être considéré comme un type de données principal afin que les types de données secondaires soient dérivés des types de données primaires. La dérivation se fait par combinaison, telle qu'une structure C ++. Une structure peut être utilisée pour combiner des types de données (tels que et int et un char) pour obtenir un type de données secondaire. Le type de données défini par la structure est toujours un type de données secondaire. Les types de données primaires ne sont dérivés de rien, ils sont plutôt une donnée du langage de programmation.

J'ai un parallèle avec le primitif étant la nomenclature signifiant primaire. Ce parallèle est une «expression régulière». Je pense que la nomenclature «régulière» peut être comprise comme «régulatrice». Ainsi vous avez une expression qui régule la recherche.

L'étymologie scalaire ( http://www.etymonline.com/index.php?allowed_in_frame=0&search=scalar&searchmode=none ) signifie échelle. Je pense que la façon dont cela se rapporte à la programmation est qu'une échelle n'a qu'une seule dimension: combien d'échelons à partir de la fin de l'échelle. Un type de données scalaire n'a qu'une seule dimension, donc représentée par une seule valeur.

Je pense que dans l'usage, primitif et scalaire sont interchangeables. Existe-t-il un exemple de primitive qui n'est pas scalaire ou de scalaire qui n'est pas primitif?

Bien qu'interchangeable, la primitive fait référence au type de données étant un élément constitutif de base d'autres types de données, et une primitive n'est pas composée d'autres types de données.

Scalar fait référence à sa valeur unique. Le scalaire contraste avec le vecteur mathématique. Un vecteur n'est pas représenté par une seule valeur car (en utilisant un type de vecteur comme exemple) une valeur est nécessaire pour représenter la direction du vecteur et une autre valeur est nécessaire pour représenter la magnitude du vecteur.

Liens de référence: http://whatis.techtarget.com/definition/primitive http://en.wikipedia.org/wiki/Primitive_data_type

En C, les types d'énumération, les caractères et les diverses représentations d'entiers forment une classe de types plus générale appelée types scalaires. Par conséquent, les opérations que vous pouvez effectuer sur les valeurs de tout type scalaire sont les mêmes que celles des entiers.

le type nul est la seule chose qui se conforme le plus de façon réaliste à la définition d'un "type scalaire". Même la sérialisation de «Aucun» comme «N.» l'ajustement dans un mot 16 bits qui est traditionnellement scalaire - ou même un seul bit qui a plusieurs valeurs possibles - n'est pas une «donnée unique».

Chaque primitive est scalaire, mais pas l'inverse. DateTime est scalaire, mais pas primitive.