Qu’est-ce qu’un object scalaire en C ++?

Autant que je sache, les types fondamentaux sont Scalar et les tableaux sont agrégés, mais qu’en est-il des types définis par l’utilisateur? Selon quels critères les diviserais-je en deux catégories?

struct S { int i; int j }; class C { public: S s1_; S s2_ }; std::vector V; std::vector *pV = &v; 

Version courte: Les types en C ++ sont:

  • Types d’object: scalaires, tableaux, classes, unions

  • Types de référence

  • Types de fonction

  • (Types de membres) [voir ci-dessous]

  • void


Version longue

  • Types d’object

    • Scalaires

      1. arithmétique (intégrale, float)

      2. pointeurs: T * pour tout type T

      3. enum

      4. pointeur vers membre

      5. nullptr_t

    • Tableaux: T[] ou T[N] pour tout type T complet, sans référence

    • Classes: class Foo ou struct Bar

      1. Classes sortingviales

      2. Agrégats

      3. Cours de POD

      4. (etc.)

    • Unions: union Zip

  • Types de références: T & , T && pour tout object ou type de fonction libre T

  • Types de fonction

    • Fonctions libres: R foo(Arg1, Arg2, ...)

    • Fonctions membres: RT::foo(Arg1, Arg2, ...)

  • void

Les types de membres fonctionnent comme ceci. Un type de membre est de la forme T::U , mais vous ne pouvez pas avoir d’objects ou de variables de type membre. Vous ne pouvez avoir que des pointeurs membres. Un pointeur membre a le type T::* U , et il s’agit d’un pointeur vers un object membre si U est un type d’object (libre) et un pointeur vers une fonction membre si U est un type de fonction (libre) .

Tous les types sont complets, à l’exception des tableaux void , void dimensionnés et des classes et unions déclarées mais non définies. Tous les types incomplets, à l’exception de void peuvent être complétés.

Tous les types peuvent être const / volatile qualifiés.

L’en-tête fournit des classes de traits pour vérifier chacune de ces caractéristiques de type.

Je pense que ce serait une réponse plus complète:

entrez la description de l'image ici

document original:
http://howardhinnant.github.io/TypeHiearchy.pdf

un scalaire est un fondamental sauf qu’il ne peut pas être vide, mais il peut s’agir d’un type de pointeur ou d’un type enum.

Et un fondamental a un mot clé dans la langue . il est facile de reconnaître quand on dit comme ça.

Il existe une série de classes de bibliothèque utilisées pour tester le type de variables. std::is_scalar peut être utilisé pour tester si un object est un scalaire.

Un type scalaire est un type qui possède une fonctionnalité intégrée pour l’opérateur d’addition sans surcharge (arithmétique, pointeur, membre pointeur, enum et std::nullptr_t ).

Aussi une table d’ ici .

Catégories de type C ++