Type de données C ++ (deux)

Un programme C ++ peut être défini comme une collection d'objets qui interagissent en appelant les méthodes de chacun.

• Comportement et état de l'objet.
• Classe-une collection d'objets avec les mêmes caractéristiques, qui sont abstraits, pas réels.
• Méthodes-Une classe peut contenir plusieurs méthodes, vous pouvez écrire Logitech dans les méthodes, manipuler des données et effectuer des actions. Elle est généralement appelée une fonction en c ++.
• Variables paires - Chaque objet a des variables paires uniques, et l'état de l'objet est créé par les valeurs de ces variables paires.

Structure du programme C ++

#include <iostream> //头文件
using namespace std; //命名空间，std
// main() 是程序开始执行的地方
 
int main()
{
    
    
   cout << "Hello World"; // 输出 Hello World
   return 0; //终止main函数
}

Compiler et exécuter des programmes C ++

Comment enregistrer le code source dans un fichier?

• Ouvrez un éditeur de texte (tel que txt) et ajoutez le code ci-dessus
• Enregistrez le fichier sous hello.cpp
• Ouvrez la fenêtre d'invite de commande cmd et entrez le répertoire dans lequel le fichier est enregistré
• Entrez g++ hello.cpp, appuyez sur Entrée, compilez le code, cela générera un.out
• Entrez a.outpour exécuter le programme
• Vous pouvez voir que les
  débutants de Hello World doivent comprendre cette méthode, ce qui aide à comprendre le passé et le présent du programme. Cette méthode n'est fondamentalement pas utilisée dans le développement réel.

Bloc de déclaration

{
    
    
   cout << "Hello World"; // 输出 Hello World
   return 0;
}

C'est un groupe d'instructions logiquement connectées entre accolades.

Identifiant

C'est le nom utilisé pour identifier les variables, fonctions, classes, modules ou tout autre élément défini par l'utilisateur, en commençant par une lettre ou un trait de soulignement, suivi d'une lettre de soulignement ou d'un numéro
mohd zara abc nom_move a_123
monnom50 _temp j a23b9 retVal

Mot-clé

Trigramme

Un groupe de trois caractères est une séquence de trois caractères utilisée pour représenter un autre caractère, également appelé séquence de trois caractères. Une séquence de trois caractères commence toujours par deux points d'interrogation.

Les séquences de trois caractères ne sont pas très courantes, mais la norme C ++ permet de spécifier certains caractères sous forme de séquences de trois caractères. Dans le passé, pour représenter des caractères qui n'étaient pas sur le clavier, c'était une méthode essentielle.

Les séquences de trois caractères peuvent apparaître n'importe où, y compris les chaînes, les séquences de caractères, les commentaires et les instructions de prétraitement.

Les séquences de trois caractères les plus couramment utilisées sont répertoriées ci-dessous:

Si vous voulez deux points d'interrogation consécutifs dans le programme source et que vous ne voulez pas être remplacé par le préprocesseur, cette situation se produit dans les constantes de caractères, les chaînes littérales ou les commentaires de programme, l'alternative La méthode consiste à utiliser la concaténation automatique des chaînes: "...?" "? .." ou la séquence d'échappement: "... ?? ..".

À partir de Microsoft Visual C ++ 2010, le compilateur ne remplace plus automatiquement les trigrammes par défaut. Si vous devez utiliser la substitution à trois caractères (par exemple, pour être compatible avec les anciens codes logiciels), vous devez définir l'option de ligne de commande du compilateur / Zc: trigraphs

g ++ prend toujours en charge les trois caractères par défaut, mais donnera un avertissement de compilation.

Commentaire

• // Généralement utilisé pour les commentaires sur une seule ligne
• / *. . * / Généralement utilisé pour les commentaires sur plusieurs lignes

type de données

Sept types de données:

1. Entier entier
2. Flottant de type virgule flottante
3. Double virgule flottante
4. Caractère char
5. Booléen
6. Vide sans type
7. Type de caractère large wchar_t

typedef short int wchar_t;

Ainsi, l'espace réel de wchar_t est le même que short int.
java中是八大数据类型：byte short int long float double char boolean
Le tableau suivant montre la mémoire que différents types de variables doivent stocker en mémoire, ainsi que les valeurs maximum et minimum qui peuvent être stockées dans ce type de variable.
Remarque: différents systèmes seront différents, un octet correspond à 8 bits.
Remarque: long int vaut 8 octets, int vaut 4 octets. Les premiers compilateurs C définissaient long int pour occuper 4 octets et int pour occuper 2 octets. La nouvelle version de la norme C / C ++ est compatible avec les versions antérieures de cette norme. Un paramètre .

Variables et constantes

Les élèves débutants seront certainement confus et peuvent être déroutés par les exemples inappropriés donnés par l'enseignant. Ici, permettez-moi de parler de la définition que je leur ai donnée, et je ne donnerai pas d’exemple pour le moment.

• Variable: le montant que l'apparence ne change pas, la valeur changera
• Constante: il s'agit généralement d'une valeur spécifique et la valeur ne peut pas être modifiée.

Tels que: int a; a est une variable. a peut être égal à 0, 1, 2 ...
Les variables ont des variables globales et des variables locales. La différence est qu'à différents endroits, les variables globales seront initialisées automatiquement, tandis que les variables locales doivent être initialisées manuellement.
C ++ permet également la définition de divers autres types de variables, tels que des énumérations, des pointeurs, des tableaux, des références, des structures de données, des classes, etc. . .

définir 和 const

Define est le préprocesseur, c'est-à-dire le montant qui ne peut pas être modifié après la définition globale.

#include <iostream>
using namespace std;
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
    
    
   int area;    
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

Le mot clé const
déclare des constantes du type spécifié 程序中只读不能修改.

const int  LENGTH = 10;
const int  WIDTH  = 5;
const char NEWLINE = '\n';
int area;  

la différence

1. Le type et le contrôle de sécurité sont différents: la définition de la macro (#define) est une substitution de caractères, il n'y a aucune différence de type de données.
2. Le compilateur gère différemment: la définition de macro est un concept de compilation et const est un concept d'exécution.
3. La méthode de stockage est différente: la définition de la macro est un remplacement direct, aucune mémoire n'est allouée et stockée dans le segment de code, et const doit être alloué en mémoire et stocké dans le segment de données du programme.
4. Le domaine de définition est différent, la définition de la macro est globale et const est dans la fonction.
5. La définition de macro peut être annulée par #undef
6. const peut être passé comme paramètres de fonction, mais pas comme définitions de macro.

La différence entre const char *, char const *, char * const

Type de modificateur

Le long court morceau de code signé et
non signé comprend parfaitement:

#include <iostream>
using namespace std;
/* 
 * 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
    
    
   short int i;           // 有符号短整数
   short unsigned int j;  // 无符号短整数
   j = 50000;
   
   i = j;
   cout << i << " " << j;
   return 0;
}
//运行结果：-15536 50000

Qualificateur de type

• const: les objets de type const ne peuvent pas être modifiés pendant l'exécution du programme.
• volatile: Le modificateur volatile indique au compilateur qu'il n'a pas besoin d'optimiser les variables déclarées par volatile, afin que le programme puisse lire les variables directement depuis la mémoire. Pour les compilateurs de variables générales, les variables seront optimisées et les valeurs des variables en mémoire seront placées dans des registres pour accélérer l'efficacité de la lecture et de l'écriture.
• restrict: un pointeur modifié par restrict est le seul moyen d'accéder à l'objet vers lequel il pointe. Seul C99 ajoute la nouvelle restriction de qualificatif de type.

Classe de stockage

La classe de stockage définit la portée (visibilité) et le cycle de vie des variables / fonctions dans les programmes C ++. Ces spécificateurs sont placés avant les types qu'ils modifient. Les classes de stockage disponibles dans les programmes C ++ sont répertoriées ci-dessous:

auto
register
static
extern
mutable
thread_local (C++11)

À partir de C ++ 17, le mot clé auto n'est plus un spécificateur de classe de stockage C ++ et le mot clé register est obsolète.

auto

Depuis C ++ 11, le mot clé auto a été utilisé dans deux situations: lors de la déclaration d'une variable, il déduit automatiquement le type de la variable en fonction de l'expression d'initialisation, et lors de la déclaration d'une fonction 返回值的占位符.

Le mot clé auto dans la norme C ++ 98 est utilisé pour la déclaration des variables automatiques, mais il a été supprimé dans C ++ 11 en raison de son utilisation minimale et de sa redondance.
Le type de la variable déclarée est automatiquement déduit en fonction de l'expression d'initialisation, par exemple:

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

S'inscrire

La signification originale du registre est de définir une variable locale stockée dans le registre au lieu de la mémoire. Cela signifie que la taille maximale de la variable est égale à la taille du registre (généralement un mot), et vous ne pouvez pas utiliser & car il n'est pas en mémoire.
Utilisé uniquement pour les variables nécessitant un accès rapide, telles que les compteurs. De plus, après la modification du registre, il n'est pas nécessairement stocké dans le registre, en fonction des limitations matérielles et d'implémentation.

statique

La classe de stockage statique indique au compilateur de maintenir l'existence de variables locales pendant le cycle de vie du programme, sans avoir besoin de créer et de détruire chaque fois qu'il entre et quitte la portée. Par conséquent, l'utilisation de static pour modifier les variables locales peut conserver la valeur des variables locales entre les appels de fonction.
Le modificateur statique peut également être appliqué aux variables globales. Lorsque static modifie une variable globale, la portée de la variable est limitée au fichier dans lequel elle est déclarée.
En C ++, lorsque statique est utilisé sur un membre de données de classe, une seule copie du membre sera partagée par tous les objets de la classe.
1). Les variables membres statiques existent avant les objets de
la classe 2). Tous les objets de cette classe partagent un membre statique
3). Si le membre statique est public, il peut être appelé directement par le nom de la classe
4). les données de membre sont déclarées en dehors de l'heure d'initialisation de la classe
qu'est le blanc 类变量.

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    
    
    while(count--)
    {
    
    
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    
    
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants:

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

classe de stockage externe

La classe de stockage extern est utilisée pour fournir une référence à une variable globale, qui est visible par tous les fichiers programme. Lorsque vous utilisez «externe», pour les variables qui ne peuvent pas être initialisées, le nom de la variable pointe vers un emplacement de stockage précédemment défini.

Lorsque vous avez plusieurs fichiers et que vous définissez une variable globale ou une fonction pouvant être utilisée dans d'autres fichiers, vous pouvez utiliser extern dans d'autres fichiers pour obtenir une référence à la variable ou à la fonction définie. On comprend que extern est utilisé pour déclarer une variable globale ou une fonction dans un autre fichier.

Le modificateur extern est généralement utilisé lorsque deux fichiers ou plus partagent la même variable ou fonction globale, comme indiqué ci-dessous:

Le premier fichier: main.cpp

#include <iostream>
int count ;
extern void write_extern();
int main()
{
    
    
   count = 5;
   write_extern();
}

Le deuxième fichier: support.cpp

#include <iostream>
extern int count;
void write_extern(void)
{
    
    
   std::cout << "Count is " << count << std::endl;
}

Ici, le mot-clé extern dans le deuxième fichier est utilisé pour déclarer le décompte qui a été défini dans le premier fichier main.cpp. Maintenant, compilez ces deux fichiers comme suit:

$ g++ main.cpp support.cpp -o write

Cela produira le programme exécutable d'écriture, essayez d'exécuter l'écriture, cela produira les résultats suivants:

$ ./write
Count est de 5
''

classe de stockage mutable

Le spécificateur mutable s'applique uniquement aux objets de la classe, ce qui sera expliqué à la fin de ce tutoriel. Il permet aux membres d'un objet de se substituer aux constantes. En d'autres termes, les membres mutables peuvent être modifiés via les fonctions membres const.

classe de stockage thread_local

Une variable déclarée avec le spécificateur thread_local n'est accessible que sur le thread sur lequel elle a été créée. Les variables sont créées lorsque le thread est créé et détruites lorsque le thread est détruit. Chaque thread a sa propre copie de variables.

Le spécificateur thread_local peut être combiné avec static ou extern.

Vous ne pouvez utiliser thread_local que pour les déclarations et définitions de données, et thread_local ne peut pas être utilisé pour les déclarations ou définitions de fonction.

Ce qui suit montre les variables qui peuvent être déclarées comme thread_local:

thread_local int x;  // 命名空间下的全局变量
class X
{
    
    
    static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s;  // X::s 是需要定义的
 
void foo()
{
    
    
    thread_local std::vector<int> v;  // 本地变量
}