Phenquestions
La mémoire d'un ordinateur est une série de cellules. Chaque cellule a la taille d'un octet, c'est normalement l'espace occupé par un caractère d'Europe occidentale. La taille d'un objet est donnée en octets. Cet article donne un résumé des types C++. Vous devez déjà avoir des connaissances de base en C++, afin de comprendre cet article.
Contenu de l'article
- Types fondamentaux
- Façons de construire des types de composés
- Tableaux
- Énumération
- Classer
- syndicat
- Les références
- Les fonctions
- Autres types de composés
- Conclusion
Types fondamentaux
Les types fondamentaux sont des types scalaires.
bobo
Un type booléen ou un type bool a une valeur true ou false pour 1 ou 0. Vrai ou faux occupe un octet.
caractère, caractère non signé et caractère signé
Un caractère est généralement pour un caractère d'Europe occidentale. Il occupe généralement un octet. Il existe également un caractère non signé et signé, qui est chacun un entier de huit bits. Les caractères non signés n'impliquent pas de valeurs négatives, tandis que les caractères signés impliquent des valeurs négatives. Le type de valeur que contient un caractère dépend du compilateur et peut être simplement un caractère non signé. Ces trois types de caractères sont appelés types de caractères étroits et chacun occupe un octet.
Entier
Il existe cinq types d'entiers standard non signés et cinq types d'entiers standard signés. Les cinq types d'entiers non signés sont : "unsigned char", "unsigned short int", "unsigned int", "unsigned long int" et "unsigned long long int". Les cinq types d'entiers signés correspondants sont : "signed char", "short int", "int", "long int" et "long long int".
"unsigned char" est du même type que les types de caractères étroits (voir ci-dessus). "signed char" est l'autre type des types de caractères étroits (voir ci-dessus).
Avec le compilateur g++, « unsigned char » ou « signed char » occupe un octet ; "unsigned short int" ou "short int" occupe deux octets ; « unsigned int » ou « int » occupe quatre octets ; "unsigned long int" ou "long int" occupe 8 octets ; "unsigned long long int" ou "long long int" occupe toujours 8 octets (pour l'instant).
char16_t, char32_t, wchar_t
Lorsqu'il s'agit de caractères d'Europe occidentale, le type char est suffisant dans de nombreuses situations. Cependant, lorsqu'il s'agit de chinois et d'autres langues orientales, char16_t, ou char32_t, ou wchar_t est nécessaire. Avec le compilateur g++, char16_t occupe deux octets ; char32_t occupe quatre octets et wchar_t occupe également quatre octets.
Le bool, le char, le char16_t, le char32_t, le wchar_t, les types entiers signés et non signés, forment un autre ensemble, appelé types intégraux (entiers).
À ce stade de l'article, deux types collectifs ont été mentionnés : les types de caractères étroits et les types intégraux.
Types à virgule flottante
Supposons que les nombres 457 000 et 457 230 correspondent à la même lecture, mesurée par deux instruments de mesure différents. 457 230 est plus précis que 457 000 car la valeur est plus détaillée (implique des endroits plus petits : + 200 plus 30). Un nombre à virgule flottante est un nombre avec une partie fractionnaire (décimale). Bien que les nombres dans l'ordinateur soient une séquence de bits, certains nombres à virgule flottante sont plus précis que d'autres.
Certains instruments de mesure prennent des mesures par étapes minimales, disons 10 unités. Un tel instrument aurait les lectures suivantes : 10, 20, 30, 40,… 100, 110, 130, 140,… 200, 210, 220, 230, 240, et ainsi de suite. Bien que les nombres dans l'ordinateur soient une séquence de bits, les nombres à virgule flottante varient en quelques étapes minimales (beaucoup plus petites que 10 unités).
C++ a trois types à virgule flottante, qui sont : float, double et long double. Pour tout compilateur, double doit avoir une précision supérieure à celle de float ou au moins à celle de float ; long double doit avoir la précision supérieure à celle de double ou au moins celle de double.
Il existe un troisième nom collectif : type arithmétique. C'est le nom des types intégraux et à virgule flottante. Notez que c'est aussi le nom de tous les types scalaires, comme expliqué jusqu'ici.
Avec le compilateur g++, le nombre d'octets pour un float est de quatre ; le nombre d'octets pour un double est de huit ; le nombre d'octets pour un long double est de seize.
Type de vide
Avec le compilateur g++, la taille du type void est d'un octet. L'octet n'a officiellement aucun bit, ce qui signifie que son emplacement a un contenu vide.
Façons de construire des types de composés
Les types composés sont des types non fondamentaux. Cela signifie que les types composés sont des types non scalaires. Cette section explique les bases des types de composés.
Tableaux
Le segment de code suivant montre un tableau d'entiers et un tableau de caractères :
int arrInt[] = 1, 2, 3, 4, 5 ;char arrCha[] = 'a', 'b', 'c', 'd', 'e' ;
cout << arrInt[2] <<" <
Énumération
Une énumération est un type, avec des constantes nommées. Considérez le segment de code suivant :
enum a=3, b, c ;cout << b <<'\n';
La sortie est : 4. La première ligne du segment de code est une énumération et a, b ou c est un énumérateur.
Classer
Une classe est une unité généralisée à partir de laquelle de nombreux objets de la même unité généralisée peuvent être créés (instanciés). Le programme suivant montre une classe et deux objets, instanciés à partir de celle-ci. Un tel objet est différent d'un objet scalaire.
#inclureen utilisant l'espace de noms std ;
classe TheCla
Publique:
nombre entier = 5 ;
entier fn()
nombre de retour ;
;
int main()
LeCla obj1;
TheCla obj2;
cout << obj1.num << " << obj2.num <<'\n';
renvoie 0 ;
La sortie est : 5 5. Le nom de la classe est TheCla, et les noms des deux objets sont obj1 et obj2. Notez le point-virgule juste après la description (définition) de la classe. Notez comment les deux objets ont été instanciés dans la fonction main().
Remarque : num est un membre de données et fn est une fonction membre.
syndicat
structure
Une structure est comme un tableau mais au lieu d'avoir des paires index/valeur, elle a des paires nom/valeur. Les noms peuvent être écrits dans n'importe quel ordre. Le programme suivant montre une structure et son utilisation :
#inclureen utilisant l'espace de noms std ;
struct TheCla
nombre entier = 5 ;
flotteur flt = 2.3 ;
char ch = 'a';
obj1, obj2;
int main()
cout << obj2.num <<", "<< obj2.flt <<", "<< obj2.ch <<'\n';
renvoie 0 ;
La sortie est :
5, 2.3, un
Le nom de la structure est TheCla. obj1 et obj2 sont deux objets différents de la structure.
syndicat
Le programme suivant montre une union et son utilisation :
#inclureen utilisant l'espace de noms std ;
syndicat TheCla
nombre entier ;
flotteur flt = 2.3 ;
char ch;
obj1, obj2;
int main()
cout << obj2.flt <<'\n';
renvoie 0 ;
La sortie est : 2.3. L'union est similaire à une structure. La principale différence entre une structure et une union est que, pour une structure, un seul membre peut avoir une valeur (initialisée) à la fois. Dans le programme ci-dessus, le membre, flt a une valeur de 2.3. Chacun des autres membres, num ou ch, ne peut avoir une valeur next que si la valeur de flt est abandonnée.
Les références
Une référence est synonyme d'identifiant. Le segment de code suivant montre comment obtenir une référence à un identifiant :
int id = 5;int& ref1 = id;
int& ref2 = id;
cout << id << " << ref1 << " << ref2 <<'\n';
La sortie est : 5 5 5. ref1 et ref2 sont des synonymes de id.
Référence lvalue et référence rvalue
Les références ci-dessus sont des références lvalue. Le code suivant montre la référence rvalue :
int&& ref = 5;cout << ref <<'\n';
La sortie est : 5. Cette référence est créée sans identifier aucun emplacement en mémoire. Pour y parvenir, double & est nécessaire, je.e., &&.
Aiguille
Un pointeur n'est pas vraiment une entité C++. Cependant, il fournit un meilleur schéma pour traiter les références. Le code suivant montre comment créer un pointeur :
int ptdId = 5;int ptdId = 5;
int *ptrId;
ptrId = &ptdId;
cout << *ptrId <<'\n';
La sortie est : 5. Notez la différence de nom entre ptdId et ptdId. ptdId est l'objet pointé et ptrId est l'objet pointeur. &ptdId renvoie l'adresse de l'objet pointé affecté à ptrId. Pour renvoyer la valeur de l'objet pointé, utilisez *ptrId.
Les fonctions
Fonction de base et son appel
Le code suivant montre une définition de fonction de base et son appel :
#inclureen utilisant l'espace de noms std ;
int fn(int num)
cout<<"seen"<<'\n';
nombre de retour ;
int main()
int ret = fn(5);
cout << ret <<'\n';
renvoie 0 ;
La sortie est
définition de fonction
5
L'appel de fonction est fn(5). Le nom de la fonction est fn.
Référence et pointeur vers une fonction
&fn renvoie l'adresse en mémoire de la fonction dont le nom est fn. L'instruction suivante déclare un pointeur vers une fonction :
int (*func)();Ici, func est le nom du pointeur vers la fonction. La première paire de parenthèses différencie ce pointeur de fonction d'un pointeur d'objet scalaire. func peut contenir l'adresse d'une fonction identifiée par fn, comme suit :
fonction = &fn;Le programme suivant met la référence de fonction et le pointeur en action :
#inclureen utilisant l'espace de noms std ;
int fn(int num)
/* quelques déclarations */
numéro de retour ;
int main()
int (*func)(int);
fonction = &fn;
int ret = func(5);
cout << ret <<'\n';
renvoie 0 ;
La sortie est : 5. Notez que fn et func ont chacun le paramètre int dans la déclaration.
Autres types de composés
Les types de composés de base ci-dessus sont composés en eux-mêmes. Ils sont également utilisés pour construire des types de composés élaborés.
typedef
Le mot réservé typedef est utilisé pour remplacer une séquence de types par un nom (pour la séquence). Le segment de code suivant illustre cela :
typedef unsigned long int IduIL;
IduIL myInt = 55555555555555555555;cout << myInt <<'\n';
La sortie est 555555555555555555. Dans le code, IduIL est devenu un type qui signifie « unsigned long int ».
Reliure structurée
La liaison structurée est une fonctionnalité qui permet de donner des noms aux sous-objets. Le code suivant illustre cela pour le tableau :
int arr[3] = 1, 2, 3 ;auto [x, y, z](arr);
cout << x <<"<< y <<"<< z <<'\n';
La sortie est 1 2 3. Ainsi, les valeurs : 1, 2, 3 ont reçu les noms, x, y, z. Notez l'utilisation et la position du mot réservé, auto. Notez également l'utilisation des crochets.
Bit-Champ
La mémoire est une séquence de cellules. Chaque cellule prend un octet. De plus, chaque octet se compose de huit bits. Un groupe de bits, pas nécessairement huit bits, peut être défini et modifié. Un tel groupe est appelé un champ de bits. Ces groupes se trouveraient les uns à côté des autres. Si les groupes ne constituent pas un type, disons 16 bits pour un int court, des bits de remplissage sont ajoutés. Le code suivant illustre cela avec la structure :
Date de structurewkDay court non signé : 3; ///3 bits
Lun court non signéJour : 6 ; ///6 bits
lun court non signé : 5; ///5 bits
année courte non signée : 8 ; //8 bits pour l'année à 2 chiffres
dte;
dte.wkJour = 1 ; dte.lunJour = 2 ; dte.lun = 2 ; dte.an = 21 ;
cout << dte.mon <<'/'<< dte.monDay <<'/'<< dte.yr <<'\n';
La sortie est : 2/2/21. Le nombre total de bits pour wkDay, MonDay et mon est 3 + 6 + 5 = 14. Ainsi, deux bits de remplissage seraient ajoutés pour constituer 16 bits pour l'entier court de 2 octets (16 bits). Les 8 bits suivants commencent le prochain int court, qui est ensuite rempli de 8 bits de remplissage.
Remarque : évitez d'utiliser des champs de bits ; l'utiliser uniquement pour la recherche.
Espace de noms
Un espace de noms est un ensemble de noms, qui ne doit pas entrer en conflit avec les mêmes noms d'autres ensembles de noms. Le programme suivant illustre l'utilisation des mêmes noms à partir de deux espaces de noms différents, appliqués dans l'espace de noms de la fonction main() :
#inclureen utilisant l'espace de noms std ;
espace de noms NS1
int monInt = 8;
flotteur;
espace de noms NS2
int monInt = 9;
flotteur;
int main()
cout << NS1::myInt << '\n';
cout << NS2::myInt << '\n';
NS1::flt = 2.5 ;
NS2::flt = 4.8 ;
cout << NS1::flt << '\n';
cout << NS2::flt << '\n';
renvoie 0 ;
La sortie est :
9
8
2.5
4.8
Il y a deux mêmes noms int en conflit et deux mêmes noms flottants en conflit dans le code.
Modèle et spécialisation de modèle
Le schéma de modèle permet l'utilisation d'un espace réservé pour différents types scalaires possibles. La spécialisation consiste à choisir un type scalaire particulier. Le code suivant illustre cela pour une fonction :
#inclureen utilisant l'espace de noms std ;
template void func (T cha, U non)
cout << "I need bread for " << cha << no << '.' << '\n';
int main()
func('$', 3);
renvoie 0 ;
La sortie est :
« J'ai besoin de pain pour 3 $."
Pack de paramètres de modèle
Les compilateurs doivent encore implémenter complètement cette fonctionnalité - voir plus tard.
Conclusion
Les types C++ existent en deux catégories : les types fondamentaux et les types composés. Les types fondamentaux sont des types scalaires. Les types composés de base sont des tableaux, des énumérations, des classes, des unions, des références, des pointeurs et des fonctions. Ces types composés de base sont utilisés pour construire des types composés élaborés, qui sont des typesdef, des liaisons structurées, des champs de bits, un espace de noms et des fonctionnalités de modèle.
Chrys
