Types C ++
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 personnage d'Europe occidentale. La taille d'un objet est donnée en octets. Cet article donne un résumé des types C ++. Vous devriez déjà avoir des connaissances de base de C ++, afin de comprendre cet article.
Contenu de l'article
- Types fondamentaux
- Façons de construire des types de composés
- Tableaux
- Énumération
- Classe
- syndicat
- Les références
- Les fonctions
- Autres types de composés
- Conclusion
Types fondamentaux
Les types fondamentaux sont des types scalaires.
bool
Un type booléen ou un type bool a une valeur de vrai ou de faux pour 1 ou 0. Vrai ou faux occupe un octet.
Char, Char non signé et signé Char
Un char est généralement pour un personnage d'Europe occidentale. Il occupe généralement un octet. Il y a aussi un char 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 d'un char dépend dépend du compilateur et peut être simplement un char 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 entiers standard non signés et cinq types entiers standard signés. Les cinq types entiers non signés sont: «Char non signé», «UNSIGNED COURT INT», «INT UNSIGNED», «UNSIGNED Long Int» et «Unsigned Long Long Int». Les cinq types entiers signés correspondants sont: «Char signé», «court int», «int», «long int» et «long long int».
«Char non signé» est le même type que les types de caractères étroits (voir ci-dessus). «Char signé» est l'autre type des types de caractères étroits (voir ci-dessus).
Avec le compilateur G ++, le «char non signé» ou «Char signé» occupe un octet; «Unsigned court int» ou «court 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 (à partir de maintenant).
char16_t, char32_t, wchar_t
Lorsque vous traitez avec des personnages d'Europe occidentale, le type de char est suffisant dans de nombreuses situations. Cependant, lorsqu'ils traitent avec des langues chinoises et autres 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, le signé et les types entiers non signés, forment un autre ensemble, appelé types intégrales (entier).
À ce stade de l'article, deux types collectifs ont été mentionnés: types de caractères étroits et types intégraux.
Types de points flottants
Supposons que les chiffres 457 000 et 457 230 sont la même lecture, mesurés 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 numéro de point flottant 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 les autres.
Certains instruments de mesure prennent des mesures à des é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, etc. Bien que les nombres dans l'ordinateur soient une séquence de bits, les nombres à virgule flottante varient dans certaines étapes minimales (beaucoup plus petit que 10 unités).
C ++ a trois types de points flottants, qui sont: flotter, double et long double. Pour tout compilateur, le double doit avoir la précision supérieure à celle de Float ou du moins celle du flotteur; le double long doit avoir la précision supérieure à celle du double ou du moins celle du double.
Il y a un troisième nom collectif: type arithmétique. Ceci est le nom des types intégraux et de points flottants. Notez que c'est aussi le nom de tous les types scalaires, comme expliqué jusqu'à présent.
Avec le compilateur G ++, le nombre d'octets pour un flotteur est de quatre; Le nombre d'octets pour un double est de huit; Le nombre d'octets pour un long double est seize.
Type de vide
Avec le compilateur G ++, la taille du type de vide est un octet. L'octet n'a officiellement pas de bits, ce qui signifie que son emplacement a un contenu vide.
Façons de construire des types de composés
Les types de composés sont des types non fondamentaux. Cela signifie que les types de composés sont des types non échelle. Cette section explique les bases des types de composés.
Tableaux
Le segment de code suivant montre un tableau d'INTS et un tableau de caractères:
int arrint [] = 1, 2, 3, 4, 5;char arrcha [] = 'a', 'b', 'c', 'd', 'e';
couter << 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;couter << 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.
Classe
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. Un tel objet est différent d'un objet scalaire.
#inclureUtilisation de Namespace Std;
classe TheCla
public:
int num = 5;
int fn ()
retour num;
;
int main()
Thecla obj1;
Thecla obj2;
couter << obj1.num << " << obj2.num <<'\n';
retour 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 principale ().
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 d'index / valeur, il a des paires de noms / valeur. Les noms peuvent être écrits dans n'importe quel ordre. Le programme suivant montre une structure et son utilisation:
#inclureUtilisation de Namespace Std;
struct thecla
int num = 5;
float flt = 2.3;
char ch = 'a';
obj1, obj2;
int main()
couter << obj2.num <<", "<< obj2.flt <<
","<< obj2.ch <<'\n';
retour 0;
La sortie est:
5, 2.3, unLe nom de la structure est TheCla. obj1 et obj2 sont deux objets différents de la structure.
syndicat
Le programme suivant montre un syndicat et son utilisation:
#inclureUtilisation de Namespace Std;
Union thecla
int num;
float flt = 2.3;
Char Ch;
obj1, obj2;
int main()
couter << obj2.flt <<'\n';
retour 0;
La sortie est: 2.3. Le syndicat est similaire à une structure. La principale différence entre une structure et un syndicat est que, pour une structure, un seul membre peut avoir une valeur (initialisée) à tout moment. 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 que si la valeur de FLT est abandonnée.
Les références
Une référence est synonyme d'un identifiant. Le segment de code suivant montre comment obtenir une référence à un identifiant:
int id = 5;int & Ref1 = id;
int & Ref2 = id;
couter << id << " << ref1 <<
" << ref2 <<'\n';
La sortie est: 5 5 5. Ref1 et Ref2 sont des synonymes à ID.
référence lvalue et référence
Les références ci-dessus sont des références lvalues. Le code suivant affiche la référence RValue:
int && ref = 5;couter << ref <<'\n';
La sortie est: 5. Cette référence est créée sans identifier aucun emplacement en mémoire. Pour y parvenir, double et est nécessaire, je.e., &&.
Aiguille
Un pointeur n'est pas vraiment une entité C ++. Cependant, il fournit un meilleur plan pour gérer les références. Le code suivant montre comment un pointeur peut être créé:
int ptdid = 5;int ptdid = 5;
int * ptrid;
ptrid = &ptdId;
couter << *ptrId <<'\n';
La sortie est: 5. Notez la différence de nom entre PTDID et PTDID. PTDID est l'objet pointu et Ptrid est l'objet de pointeur. & PTDID renvoie l'adresse de l'objet pointu qui est affecté à Ptrid. Pour retourner la valeur de l'objet pointu, utilisez * ptrid.
Les fonctions
Fonction de base et son appel
Le code suivant montre une définition de fonction de base et son appel:
#inclureUtilisation de Namespace Std;
int fn (int num)
couter<<"seen"<<'\n';
retour num;
int main()
int ret = fn (5);
couter << ret <<'\n';
retour 0;
La sortie est
vu5
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 de la fonction. La première paire de parenthèses différenciez ce pointeur de fonction d'un pointeur d'objet scalaire. Func peut être conçu pour contenir l'adresse d'une fonction identifiée par FN, comme suit:
func = &fn;Le programme suivant met la référence de la fonction et le pointeur en action:
#inclureUtilisation de Namespace Std;
int fn (int num)
/ * quelques instructions * /
retour num;
int main()
int (* func) (int);
func = &fn;
int ret = func (5);
couter << ret <<'\n';
retour 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 seul nom (pour la séquence). Le segment de code suivant l'illustre:
typedef unsigned long int iduil;Iduil myint = 5555555555555555555;
couter << myInt <<'\n';
La sortie est de 5555555555555555555. 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 aux noms d'être donnés aux sous-objets. Le code suivant l'illustre pour le tableau:
int arr [3] = 1, 2, 3;auto [x, y, z] (arr);
couter << 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.
Mât
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 réglé et modifié. Un tel groupe est appelé un peu de champ. Ces groupes se trouvent côte à côte. Si les groupes ne composent pas de type, disons 16 bits pour un court int, des bits de rembourrage sont ajoutés. Le code suivant l'illustre avec la structure:
Date de structureCrournée courte non signée: 3; // 3 bits
Court non signé lundi: 6; // 6 bits
Short non signé: 5; // 5 bits
Court non signé, 8; // 8 bits pour l'année à 2 chiffres
dte;
DTE.wkday = 1; DTE.Lundi = 2; DTE.lun = 2; DTE.an = 21;
couter << 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 rembourrage seraient ajoutés pour constituer 16 bits pour le court entier de 2 octets (16 bits). Les 8 bits suivants commencent le prochain court INT, qui est ensuite rempli de 8 bits de rembourrage.
Remarque: Évitez d'utiliser des champs binaires; Utilisez-le uniquement pour la recherche.
Espace de noms
Un espace de noms est un ensemble de noms, qui ne devrait 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 ():
#inclureUtilisation de Namespace Std;
Espace de noms NS1
int myInt = 8;
float flt;
Espace de noms NS2
int myInt = 9;
float flt;
int main()
couter << NS1::myInt << '\n';
couter << NS2::myInt << '\n';
Ns1 :: flt = 2.5;
Ns2 :: flt = 4.8;
couter << NS1::flt << '\n';
couter << NS2::flt << '\n';
retour 0;
La sortie est:
98
2.5
4.8
Il y a deux mêmes noms int INT et deux mêmes noms de flottants conflictuels dans le code.
Spécialisation du modèle et du modèle
Le schéma de modèle permet d'utiliser un espace réservé pour différents types scalaires possibles. La spécialisation est de choisir un type scalaire particulier. Le code suivant l'illustre pour une fonction:
#inclureUtilisation de Namespace Std;
modèle
void func (t cha, u no)
couter << "I need bread for " << cha << no << '.' << '\n';
int main()
func ('$', 3);
retour 0;
La sortie est:
J'ai besoin de pain pour 3 $.Pack de paramètres de modèle
Les compilateurs doivent encore implémenter pleinement cette fonctionnalité - voir plus tard.
Conclusion
Les types C ++ existent dans deux catégories: types fondamentaux et types de composés. Les types fondamentaux sont des types scalaires. Les types de composés de base sont les tableaux, les énumérations, les classes, les syndicats, les références, les pointeurs et les fonctions. Ces types de composés de base sont utilisés pour construire des types de composés élaborés, qui sont des types de type, des liaisons structurées, des champs de bits, de l'espace de noms et des fonctionnalités de modèle.