Le début du langage C++ remonte à 1983, peu après lorsque 'Bjare Stroustrup' travaillé avec des classes en langage C inclusivement avec quelques fonctionnalités supplémentaires comme la surcharge d'opérateurs. Les extensions de fichiers utilisées sont ‘.c’ et ‘.cpp’. C++ est extensible et ne dépend pas de la plate-forme et inclut STL qui est l'abréviation de Standard Template Library. Donc, fondamentalement, le langage C++ connu est en fait connu comme un langage compilé dont le fichier source est compilé pour former des fichiers objets, qui, lorsqu'ils sont combinés avec un éditeur de liens, produisent un programme exécutable.

D'autre part, si nous parlons de son niveau, il s'agit de niveau intermédiaire interprétant l'avantage de la programmation de bas niveau comme les pilotes ou les noyaux et aussi les applications de niveau supérieur comme les jeux, l'interface graphique ou les applications de bureau. Mais la syntaxe est presque la même pour C et C++.

Composants du langage C++ :

#include

Cette commande est un fichier d'en-tête comprenant la commande 'cout'. Il peut y avoir plus d'un fichier d'en-tête selon les besoins et les préférences de l'utilisateur.

int main()

Cette instruction est la fonction de programme maître qui est une condition préalable à tout programme C++, ce qui signifie que sans cette instruction, on ne peut exécuter aucun programme C++. Ici, 'int' est le type de données de la variable de retour indiquant le type de données que la fonction renvoie.

Déclaration:

Les variables sont déclarées et des noms leur sont attribués.

Énoncé du problème :

Ceci est essentiel dans un programme et peut être une boucle 'while', une boucle 'for' ou toute autre condition appliquée.

Les opérateurs:

Les opérateurs sont utilisés dans les programmes C++ et certains sont cruciaux car ils sont appliqués aux conditions. Quelques opérateurs importants sont &&, ||, !, &, !=, |, &=, |=, ^, ^=.

Sortie d'entrée C++ :

Nous allons maintenant discuter des capacités d'entrée et de sortie en C++. Toutes les bibliothèques standard utilisées en C++ fournissent des capacités d'entrée et de sortie maximales qui sont exécutées sous la forme d'une séquence d'octets ou sont normalement liées aux flux.

Flux d'entrée:

Dans le cas où les octets sont diffusés de l'appareil vers la mémoire principale, il s'agit du flux d'entrée.

Flux de sortie :

Si les octets sont diffusés dans le sens opposé, il s'agit du flux de sortie.

Un fichier d'en-tête est utilisé pour faciliter l'entrée et la sortie en C++. Il est écrit sous la forme qui fournit des méthodes, par exemple stew et set precision. Les commandes d'entrée et de sortie sont cin, cout, cerr et clog. Ici, « cin » désigne l'entrée standard et « cout » signifie le périphérique de sortie standard utilisé avec les opérateurs d'insertion de flux (<<) pour afficher les instructions à l'écran.

Exemple:

Nous afficherons un message de chaîne en utilisant une chaîne de type caractère.

Dans la première ligne, nous incluons 'iostream' qui contient presque toutes les bibliothèques essentielles dont nous pourrions avoir besoin pour l'exécution d'un programme C++. Dans la ligne suivante, nous déclarons un espace de noms qui fournit la portée des identifiants. Après avoir appelé la fonction principale, nous initialisons un tableau de type caractère qui stocke le message de chaîne et 'cout' l'affiche en concaténant. Nous utilisons « cout » pour afficher le texte à l'écran. De plus, nous avons pris une variable 'A' ayant un tableau de type de données de caractères pour stocker une chaîne de caractères, puis nous avons ajouté à la fois le message de tableau le long du message statique à l'aide de la commande 'cout'.

La sortie générée est illustrée ci-dessous :

Exemple:

Dans ce cas, nous représenterions l'âge de l'utilisateur dans un simple message de chaîne.

Dans la première étape, nous incluons la bibliothèque. Après cela, nous utilisons un espace de noms qui fournirait la portée des identifiants. Dans l'étape suivante, nous appelons le principale() fonction. Après quoi, nous initialisons l'âge en tant que variable 'int'. Nous utilisons la commande 'cin' pour l'entrée et la commande 'cout' pour la sortie du message de chaîne simple. Le « cin » saisit la valeur de l'âge de l'utilisateur et le « cout » l'affiche dans l'autre message statique.

Ce message s'affiche à l'écran après l'exécution du programme afin que l'utilisateur puisse connaître l'âge, puis appuyer sur ENTER.

Exemple:

Ici, nous montrons comment imprimer une chaîne en utilisant 'cout'.

Pour imprimer une chaîne, nous incluons initialement une bibliothèque, puis l'espace de noms pour les identifiants. La principale() fonction est appelée. De plus, nous imprimons une sortie de chaîne à l'aide de la commande 'cout' avec l'opérateur d'insertion qui affiche ensuite le message statique à l'écran.

Types de données C++ :

Les types de données en C++ sont un sujet très important et largement connu car c'est la base du langage de programmation C++. De même, toute variable utilisée doit être d'un type de données spécifié ou identifié.

Nous savons que pour toutes les variables, nous utilisons le type de données lors de la déclaration pour limiter le type de données à restaurer. Ou, nous pourrions dire que les types de données indiquent toujours à une variable le type de données qu'elle stocke elle-même. Chaque fois que nous définissons une variable, le compilateur alloue la mémoire en fonction du type de données déclaré car chaque type de données a une capacité de stockage de mémoire différente.

Le langage C++ assiste la diversité des types de données afin que le programmeur puisse sélectionner le type de données approprié dont il pourrait avoir besoin.

C++ facilite l'utilisation des types de données indiqués ci-dessous :

1. Types de données définis par l'utilisateur
2. Types de données dérivés
3. Types de données intégrés

Par exemple, les lignes suivantes sont données pour illustrer l'importance des types de données en initialisant quelques types de données courants :

Quelques types de données courants : la taille qu'ils spécifient et le type d'informations que leurs variables stockeront sont indiqués ci-dessous :

• Char : Avec la taille d'un octet, il stockera un seul caractère, lettre, chiffre ou valeurs ASCII.
• Booléen : Avec la taille de 1 octet, il stockera et renverra les valeurs comme vraies ou fausses.
• Int : Avec une taille de 2 ou 4 octets, il stockera des nombres entiers sans décimale.
• Virgule flottante : avec une taille de 4 octets, il stockera les nombres fractionnaires qui ont une ou plusieurs décimales. Ceci est suffisant pour stocker jusqu'à 7 chiffres décimaux.
• Double virgule flottante : avec une taille de 8 octets, il stockera également les nombres fractionnaires qui ont une ou plusieurs décimales. Ceci est suffisant pour stocker jusqu'à 15 chiffres décimaux.
• Vide : sans taille spécifiée, un vide contient quelque chose sans valeur. Par conséquent, il est utilisé pour les fonctions qui renvoient une valeur nulle.
• Caractère large : avec une taille supérieure à 8 bits qui est généralement de 2 ou 4 octets de long est représenté par wchar_t qui est similaire à char et stocke donc également une valeur de caractère.

La taille des variables mentionnées ci-dessus peut différer selon l'utilisation du programme ou du compilateur.

Exemple:

Écrivons simplement un code simple en C++ qui donnera les tailles exactes de quelques types de données décrits ci-dessus :

Dans ce code, nous intégrons la bibliothèque . Après quoi, nous utilisons 'namespace'. Dans la ligne suivante, nous appelons le principale() fonction dans laquelle nous utilisons une commande 'cout' qui imprimera les tailles de tous les types de données spécifiés dans le programme. Pour trouver la taille des variables, nous devons appliquer la taille de() méthode.

La sortie est reçue en octets comme indiqué dans la figure :

Exemple:

Ici, nous ajouterions la taille de deux types de données différents.

Tout d'abord, nous incorporons un fichier d'en-tête utilisant un 'espace de noms standard' pour les identifiants. Ensuite, le principale() La fonction est appelée dans laquelle nous initialisons d'abord la variable 'int', puis une variable 'double' pour vérifier la différence entre les tailles de ces deux variables. Ensuite, leurs tailles sont concaténées par l'utilisation de la taille de() fonction. La sortie est affichée par l'instruction 'cout'.

Il y a un autre terme qui doit être mentionné ici et c'est 'Modificateurs de données' . Le nom suggère que les «modificateurs de données» sont utilisés avec les types de données intégrés pour modifier leurs longueurs qu'un certain type de données peut respecter selon les besoins ou les exigences du compilateur.

Voici les modificateurs de données accessibles en C++ :

1. Signé
2. Non signé
3. Long
4. Court

La taille modifiée ainsi que la plage appropriée des types de données intégrés sont mentionnées ci-dessous lorsqu'elles sont combinées avec les modificateurs de type de données :

• Short int : ayant la taille de 2 octets, a une gamme de modifications de -32 768 à 32 767
• Entier court non signé : ayant la taille de 2 octets, a une plage de modifications de 0 à 65 535
• Unsigned int : ayant la taille de 4 octets, a une plage de modifications de 0 à 4 294 967 295
• Int : ayant la taille de 4 octets, a une plage de modification de -2 147 483 648 à 2 147 483 647
• Entier long : ayant la taille de 4 octets, a une plage de modification de -2 147 483 648 à 2 147 483 647
• Unsigned long int : ayant la taille de 4 octets, a une plage de modifications de 0 à 4 294 967,295
• Long long int : ayant la taille de 8 octets, a une gamme de modifications de –(2^63) à (2^63)-1
• Unsigned long long int : ayant la taille de 8 octets, a une plage de modifications de 0 à 18 446 744 073 709 551 615
• Caractère signé : ayant la taille de 1 octet, a une gamme de modifications de -128 à 127
• Caractère non signé : ayant la taille de 1 octet, a une plage de modifications de 0 à 255.

Énumération C++ :

Dans le langage de programmation C++, 'Enumeration' est un type de données défini par l'utilisateur. L'énumération est déclarée comme un ' enum' en C++. Il est utilisé pour attribuer des noms spécifiques à toute constante utilisée dans le programme. Il améliore la lisibilité et la convivialité du programme.

Syntaxe:

Nous déclarons l'énumération en C++ comme suit :

Avantages de l'énumération en C++ :

Enum peut être utilisé des manières suivantes :

• Il peut être utilisé fréquemment dans les instructions switch case.
• Il peut utiliser des constructeurs, des champs et des méthodes.
• Il ne peut étendre que la classe 'enum', pas n'importe quelle autre classe.
• Cela peut augmenter le temps de compilation.
• Il peut être parcouru.

Inconvénients de l'énumération en C++ :

Enum a aussi quelques inconvénients :

Si une fois qu'un nom est énuméré, il ne peut plus être utilisé dans la même portée.

Par exemple:

Enum ne peut pas être déclaré en avant.

Par exemple:

Ils ressemblent à des noms mais ce sont des nombres entiers. Ainsi, ils peuvent automatiquement convertir vers n'importe quel autre type de données.

Par exemple:

Exemple:

Dans cet exemple, nous voyons l'utilisation de l'énumération C++ :

Dans cette exécution de code, tout d'abord, nous commençons par #include . est l'une des bibliothèques les plus riches en C++. C'est une bibliothèque intégrée. Cela implique des flux de données d'entrée et de sortie . Après cela, nous utilisons l'espace de noms Standard. Ensuite, nous avons déclaré « enum » un nom spécifique en tant que sujet et avons attribué trois sujets qui sont les mathématiques, l'anglais et l'ourdou. Math se voit attribuer la valeur 1. Notre objectif est d'imprimer les valeurs de Subject déclarées dans enum. Ensuite, nous invoquons le principale() fonction. Dans principale() nous avons cout<<, où 'c' signifie 'caractère' et out signifie 'sortie'. ‘Cout’ est utilisé pour afficher la sortie . << indique l'opérateur d'insertion. En utilisant 'cout<<', nous imprimons des valeurs enum. Ensuite, nous utiliserons la commande « return 0 ». Cette commande renvoie le résultat sous forme de valeurs.

Voici notre résultat du programme exécuté :

Donc, comme vous pouvez le voir, nous avons des valeurs de Sujet : Mathématiques, ourdou, anglais ; c'est-à-dire 1,2,3.

Exemple:

Voici un autre exemple à travers lequel nous clarifions nos concepts sur enum :

Dans ce programme, nous commençons par intégrer le fichier d'en-tête . C'est une bibliothèque intégrée. Cela implique des flux de données d'entrée et de sortie. Après cela, nous devons utiliser l'espace de noms standard. Ensuite, nous avons attribué des valeurs enum aux constantes qui sont des joueurs. Notre objectif est d'afficher qui est dessus. Ensuite, nous appelons notre principale() fonction. Dans le principale() fonction, nous avons attribué deux constantes : Shadab, dont la valeur est 20 à la variable d'énumération 'bowler1' ; et Afridi, dont la valeur est 25 pour la variable enum 'bowler2'.

Nous devons utiliser une instruction if-else . Nous avons également utilisé l'opérateur de comparaison à l'intérieur de l'instruction 'if', ce qui signifie que nous comparons si 'bowler2' est supérieur à 'bowler1'. Ensuite, le bloc 'si' s'exécute, ce qui signifie qu'il s'agit de la fin d'Afridi. Ensuite, nous avons saisi ‘cout<<’ pour afficher la sortie. Tout d'abord, nous imprimons la déclaration 'C'est fini'. Ensuite, la valeur de 'bowler2'. Si ce n'est pas le cas, le bloc else est invoqué, ce qui signifie que c'est le over de Shadab. Ensuite, en appliquant la commande ‘cout<<’ nous affichons l’instruction ‘It is over of’. Ensuite, la valeur de 'bowler1'.

Selon l'instruction If-else, nous avons plus de 25 qui est la valeur d'Afridi. Cela signifie que la valeur de la variable enum 'bowler2' est supérieure à 'bowler1' c'est pourquoi l'instruction 'if' est exécutée.

C++ Sinon, basculez :

Dans le langage de programmation C ++, nous utilisons les 'instructions if' et 'instruction switch' pour modifier le déroulement du programme. Ces instructions sont utilisées pour fournir plusieurs ensembles de commandes pour la mise en œuvre du programme en fonction de la valeur réelle des instructions mentionnées respectivement. Dans la plupart des cas, nous utilisons des opérateurs comme alternatives à l'instruction 'if'. Toutes ces déclarations mentionnées ci-dessus sont les déclarations de sélection appelées déclarations décisionnelles ou conditionnelles.

L'instruction 'si' :

Cette instruction est utilisée pour tester une condition donnée chaque fois que vous avez envie de modifier le déroulement d'un programme. Ici, si une condition est vraie, le programme exécutera les instructions écrites, mais si la condition est fausse, il se terminera simplement. Prenons un exemple;

Il s'agit de la simple instruction 'if' utilisée, où nous initialisons une variable 'int' à 10. Ensuite, une valeur est prise de l'utilisateur et elle est recoupée dans l'instruction 'if'. S'il satisfait aux conditions appliquées dans l'instruction 'if', la sortie s'affiche.

Comme le chiffre choisi était 40, la sortie est le message.

L'instruction 'Si-sinon' :

Dans un programme plus complexe où l'instruction 'if' ne coopère généralement pas, nous utilisons l'instruction 'if-else'. Dans le cas donné, nous utilisons l'instruction 'if- else' pour vérifier les conditions appliquées.

Tout d'abord, nous allons déclarer une variable de type de données 'int' nommée 'x' dont la valeur est prise de l'utilisateur. Maintenant, l'instruction 'if' est utilisée là où nous avons appliqué une condition selon laquelle si la valeur entière entrée par l'utilisateur est 2. La sortie sera celle souhaitée et un simple message 'NICE TRY' sera affiché. Sinon, si le nombre saisi n'est pas 2, la sortie serait différente.

Lorsque l'utilisateur écrit le chiffre 2, la sortie suivante s'affiche.

Lorsque l'utilisateur écrit un autre nombre sauf 2, la sortie que nous obtenons est :

L'instruction If-else-if :

Les instructions if-else-if imbriquées sont assez complexes et sont utilisées lorsque plusieurs conditions sont appliquées dans le même code. Réfléchissons à cela en utilisant un autre exemple :

Ici, après avoir intégré le fichier d'en-tête et l'espace de noms, nous avons initialisé une valeur de variable « m » à 200. La valeur de « m » est ensuite extraite de l'utilisateur, puis recoupée avec les multiples conditions énoncées dans le programme.

Ici, l'utilisateur a choisi la valeur 195. C'est pourquoi la sortie indique qu'il s'agit de la valeur réelle de « m ».

Instruction de commutation :

Une instruction 'switch' est utilisée en C++ pour une variable qui doit être testée si elle est égale à une liste de valeurs multiples. Dans l'instruction 'switch', nous identifions les conditions sous la forme de cas distincts et tous les cas ont une pause incluse à la fin de chaque instruction case. Plusieurs cas ont des conditions et des instructions appropriées qui leur sont appliquées avec des instructions break qui terminent l'instruction switch et passent à une instruction par défaut au cas où aucune condition n'est prise en charge.

Mot-clé 'pause' :

L'instruction switch contient le mot-clé 'break'. Il arrête l'exécution du code sur le cas suivant. L'exécution de l'instruction switch se termine lorsque le compilateur C++ rencontre le mot-clé 'break' et que le contrôle passe à la ligne qui suit l'instruction switch. Il n'est pas nécessaire d'utiliser une instruction break dans un switch. L'exécution passe au cas suivant s'il n'est pas utilisé.

Dans la première ligne du code partagé, nous incluons la bibliothèque. Après quoi, nous ajoutons 'espace de noms'. Nous invoquons le principale() fonction. Ensuite, nous déclarons une note de type de données de caractère comme « F ». Cette note pourrait être votre souhait et le résultat serait affiché respectivement pour les cas choisis. Nous avons appliqué l'instruction switch pour obtenir le résultat.

Si nous choisissons 'F' comme note, le résultat est 'meilleure chance la prochaine fois' car c'est la déclaration que nous voulons imprimer au cas où la note serait 'F'.

Changeons la note en X et voyons ce qui se passe. J'ai écrit « X » comme note et la sortie reçue est indiquée ci-dessous :

Ainsi, la casse incorrecte dans le 'commutateur' déplace automatiquement le pointeur directement vers l'instruction par défaut et termine le programme.

Les instructions if-else et switch ont des caractéristiques communes :

• Ces instructions sont utilisées pour gérer la façon dont le programme est exécuté.
• Ils évaluent tous les deux une condition et cela détermine le déroulement du programme.
• Bien qu'ils aient des styles de représentation différents, ils peuvent être utilisés dans le même but.

Les instructions if-else et switch diffèrent à certains égards :

• Alors que l'utilisateur a défini les valeurs dans les déclarations de cas 'switch', alors que les contraintes déterminent les valeurs dans les déclarations 'if-else'.
• Il faut du temps pour déterminer où le changement doit être fait, il est difficile de modifier les déclarations 'if-else'. D'un autre côté, les instructions 'switch' sont simples à mettre à jour car elles peuvent être modifiées facilement.
• Pour inclure de nombreuses expressions, nous pouvons utiliser de nombreuses déclarations 'if-else'.

Boucles C++ :

Nous allons maintenant découvrir comment utiliser les boucles dans la programmation C++. La structure de contrôle connue sous le nom de «boucle» répète une série d'instructions. En d'autres termes, on parle de structure répétitive. Toutes les instructions sont exécutées en même temps dans une structure séquentielle . D'autre part, selon l'instruction spécifiée, la structure de condition peut exécuter ou omettre une expression. Il peut être nécessaire d'exécuter une instruction plusieurs fois dans des situations particulières.

Types de boucle :

Il existe trois catégories de boucles :

• Pour la boucle
• Pendant que la boucle
• Faire pendant que la boucle

Pour la boucle :

La boucle est quelque chose qui se répète comme un cycle et s'arrête lorsqu'elle ne valide pas la condition fournie. Une boucle « for » implémente une séquence d'instructions plusieurs fois et condense le code qui fait face à la variable de boucle. Cela montre comment une boucle 'for' est un type spécifique de structure de contrôle itérative qui nous permet de créer une boucle qui se répète un nombre défini de fois. La boucle nous permettrait d'exécuter le nombre 'N' d'étapes en utilisant juste un code d'une simple ligne. Parlons de la syntaxe que nous allons utiliser pour qu'une boucle 'for' soit exécutée dans votre application logicielle.

La syntaxe de l'exécution de la boucle 'for' :

Exemple:

Ici, nous utilisons une variable de boucle pour réguler cette boucle dans une boucle 'for'. La première étape serait d'attribuer une valeur à cette variable que nous énonçons comme une boucle. Après cela, nous devons définir s'il est inférieur ou supérieur à la valeur du compteur. Maintenant, le corps de la boucle doit être exécuté et la variable de boucle est également mise à jour au cas où l'instruction renvoie vrai. Les étapes ci-dessus sont fréquemment répétées jusqu'à ce que nous atteignions la condition de sortie.

• Expression d'initialisation : Au début, nous devons définir le compteur de boucle sur n'importe quelle valeur initiale de cette expression.
• Tester l'expression : Maintenant, nous devons tester la condition donnée dans l'expression donnée. Si les critères sont remplis, nous exécuterons le corps de la boucle 'for' et continuerons à mettre à jour l'expression ; sinon, il faut arrêter.
• Mettre à jour l'expression : Cette expression augmente ou diminue la variable de boucle d'une certaine valeur après l'exécution du corps de la boucle.

Exemples de programmes C++ pour valider une boucle 'For' :

Exemple:

Cet exemple montre l'impression de valeurs entières de 0 à 10.

Dans ce scénario, nous sommes censés imprimer les entiers de 0 à 10. Tout d'abord, nous avons initialisé une variable aléatoire i avec une valeur donnée '0', puis le paramètre de condition que nous avons déjà utilisé vérifie la condition si i<=10. Et quand il satisfait la condition et devient vrai, l'exécution de la boucle 'for' commence. Après l'exécution, parmi les deux paramètres d'incrémentation ou de décrémentation, un doit être exécuté et dans lequel jusqu'à ce que la condition spécifiée i<=10 devienne fausse, la valeur de la variable i est augmentée.

Nombre d'itérations avec condition i<10 :

Exemple:

L'instance suivante affiche la valeur de l'entier :

Dans le cas ci-dessus, une variable nommée 'a' est initialisée avec une valeur donnée 50. Une condition est appliquée lorsque la variable 'a' est inférieure à 70. Ensuite, la valeur de 'a' est mise à jour de sorte qu'elle est ajoutée avec 2. La valeur de 'a' est ensuite démarrée à partir d'une valeur initiale qui était de 50 et 2 est ajouté simultanément tout au long de la boucle jusqu'à ce que la condition renvoie faux et que la valeur de 'a' soit augmentée de 70 et que la boucle se termine.

Nombre d'itérations :

Boucle While :

Jusqu'à ce que la condition définie soit satisfaite, une ou plusieurs instructions peuvent être exécutées. Lorsque l'itération est inconnue à l'avance, elle est très utile. Tout d'abord, la condition est vérifiée, puis entre dans le corps de la boucle pour exécuter ou implémenter l'instruction.

Dans la première ligne, nous incorporons le fichier d'en-tête et l'espace de noms standard. Nous appelons le principale() fonction. Ici, nous initialisons une variable 'a'. Dans la ligne suivante, nous appliquons la condition while. Dans la condition while, nous utilisons l'instruction 'cout' pour afficher la valeur qui est écrite. Ensuite, nous utilisons l'opérateur d'incrémentation pour augmenter le nombre. Dans la dernière ligne, nous utilisons l'instruction 'return 0' pour terminer le programme.

Boucle Do-While :

Lorsque la condition définie est satisfaite, une série d'instructions est effectuée. Tout d'abord, le corps de la boucle est réalisé. Après cela, la condition est vérifiée si elle est vraie ou non. Par conséquent, l'instruction est exécutée une fois. Le corps de la boucle est traité dans une boucle « Do-while » avant d'évaluer la condition. Le programme s'exécute chaque fois que la condition requise est satisfaite. Sinon, lorsque la condition est fausse, le programme se termine.

Ici, nous intégrons le fichier d'en-tête . Nous utilisons le principale() fonction dans le programme. Ensuite, nous initialisons quatre entiers et utilisons l'instruction 'cin', afin que l'utilisateur puisse entrer la valeur. Dans la ligne suivante, nous initialisons deux entiers différents. Nous appliquons l'instruction « faire ». Dans l'instruction, nous utilisons deux fonctions arithmétiques. Premièrement, nous utilisons l'opérateur de multiplication et deuxièmement, nous utilisons l'opérateur d'addition. Ensuite, nous appliquons la condition 'while' dans le programme en dehors de l'instruction 'do'. De plus, nous ajoutons l'instruction 'cout' pour imprimer le résultat via l'entier 'result'. Dans la dernière ligne, pour terminer le programme, nous utilisons les commandes return 0.

C++ Continuer/Pause :

Instruction Continue C++ :

L'instruction continue est utilisée dans le langage de programmation C++ pour éviter une incarnation actuelle d'une boucle ainsi que pour déplacer le contrôle vers l'itération suivante. Pendant la boucle, l'instruction continue peut être utilisée pour ignorer certaines instructions. Il est également utilisé dans la boucle en conjonction avec les déclarations de la direction. Si la condition spécifique est vraie, toutes les instructions suivant l'instruction continue ne sont pas implémentées.

Avec boucle for :

Dans ce cas, nous utilisons la 'boucle for' avec l'instruction continue de C++ pour obtenir le résultat requis tout en respectant certaines exigences spécifiées.

Nous commençons par inclure la bibliothèque et en utilisant ‘namespace std’. Ensuite, nous appelons le principale() fonction. Nous utilisons la boucle for. À l'intérieur de la boucle for, nous déclarons une variable 'k' considérée comme comprise entre 3 et 8. Nous utilisons une condition pour continuer l'itération même si (k = = 5). Ensuite, utilisez l'instruction 'continue' après avoir spécifié la condition. À la fin. pour afficher la sortie, nous utilisons la commande 'cout' avec la commande 'return 0'.

Avec une boucle while :

Tout au long de cette démonstration, nous avons utilisé à la fois la boucle 'while' et l'instruction 'continue' C++, y compris certaines conditions pour voir quel type de sortie peut être généré.

Dans cet exemple, nous définissons une condition pour ajouter des nombres à 40 uniquement. Si l'entier entré est un nombre négatif, la boucle 'while' sera terminée. D'autre part, si le nombre est supérieur à 40, ce nombre spécifique sera ignoré de l'itération.

Nous allons inclure la bibliothèque , en utilisant 'namespace std', puis appeler le principale() fonction. Nous initialisons une variable 's'. Une autre variable 'numéro' est déclarée à l'étape suivante. Nous utilisons la boucle 'while'. Maintenant, nous spécifions la condition selon laquelle la valeur requise sera supérieure ou égale à zéro. Pour additionner tous les nombres positifs, nous utilisons l'instruction 's += nombre'. La commande 'cout' sera appliquée pour afficher le message sur la console 'Entrez n'importe quel nombre'. Nous obtenons l'entier de l'utilisateur en utilisant l'instruction 'cin'. Nous utilisons également l'instruction 'si'. Chaque fois que le nombre défini est supérieur à 40, le message s'affiche. Ensuite, nous avons utilisé la commande 'continuer'. Après toutes ces étapes, l'instruction 'continue' sera exécutée. Pour afficher la somme de tous les nombres, nous utilisons l'instruction 'cout'.

Instruction d'arrêt C++ :

Chaque fois que l'instruction break est utilisée dans une boucle en C++, la boucle se termine instantanément et le contrôle du programme redémarre à l'instruction après la boucle. Il est également possible de terminer un cas à l'intérieur d'une instruction 'switch'.

Avec boucle for :

Ici, nous utiliserons la boucle 'for' avec l'instruction 'break' pour observer la sortie en itérant sur différentes valeurs.

Tout d'abord, nous incorporons un fichier d'en-tête . Ensuite, nous utilisons ‘namespace std’. Après avoir appelé la fonction main(), nous avons utilisé pour la boucle. Ici, nous initialiserions la variable 'm'. Nous appliquerons la condition que la valeur de ‘m’ soit comprise entre 10 et 20. La condition ‘break’ sera exécutée comme si (m == 17). Pour imprimer le résultat, nous avons utilisé 'cout'. Ensuite, la commande « return 0 » sera appliquée.

Avec une boucle while :

Nous allons utiliser la boucle 'while' avec l'instruction break.

Nous commençons par importer la bibliothèque . Le 'namespace std' sera inclus. Dans la méthode main(), deux variables 'nbr' et 'x' seraient initialisées. Nous avons utilisé la boucle 'while' et passé 'true' comme argument. Pour obtenir de la valeur de l'utilisateur, nous utilisons la commande 'cin'. Ensuite, nous avons utilisé l'instruction 'if'. Parallèlement à cela, la condition 'break' est appliquée pour spécifier la condition si (nbr < 0). Pour additionner toutes les valeurs positives, nous avons utilisé les formules ‘x += nbr’. Pour afficher cette somme, nous avons ajouté la déclaration « cout ».

Fonctions C++ :

Les fonctions sont utilisées pour structurer un programme déjà connu en plusieurs fragments de codes qui ne s'exécutent que lorsqu'il est appelé. Dans le langage de programmation C++, une fonction est définie comme un groupe d'instructions qui reçoivent un nom approprié et sont appelées par elles. L'utilisateur peut passer des données dans les fonctions que nous appelons paramètres. Les fonctions sont chargées de mettre en œuvre les actions lorsque le code est le plus susceptible d'être réutilisé.

Création d'une fonction :

Bien que C++ offre de nombreuses fonctions prédéfinies telles que principale(), ce qui facilite l'exécution du code. De la même manière, vous pouvez créer et définir vos fonctions selon vos besoins. Comme toutes les fonctions ordinaires, ici, vous avez besoin d'un nom pour votre fonction pour une déclaration qui est ajoutée avec une parenthèse après '()'.

Syntaxe:

Void est le type de retour de la fonction. Labor est le nom qui lui est donné et les accolades entourent le corps de la fonction où nous ajoutons le code pour l'exécution.

Appel d'une fonction :

Les fonctions déclarées dans le code ne sont exécutées que lorsqu'elles sont appelées. Pour appeler une fonction, vous devez spécifier le nom de la fonction avec la parenthèse qui est suivie d'un point-virgule ';'.

Exemple:

Déclarons et construisons une fonction définie par l'utilisateur dans cette situation.

Initialement, comme décrit dans chaque programme, une bibliothèque et un espace de noms nous sont attribués pour prendre en charge l'exécution du programme. La fonction définie par l'utilisateur travail() est toujours appelé avant d'écrire le principale() fonction. Une fonction nommée travail() est déclarée où un message « Un travail mérite le respect ! » s'affiche. Dans le principale() fonction avec le type de retour entier, nous appelons la travail() fonction.

C'est le message simple qui a été défini dans la fonction définie par l'utilisateur affichée ici à l'aide du principale() fonction.

Annuler:

Dans l'exemple susmentionné, nous avons remarqué que le type de retour de la fonction définie par l'utilisateur est vide. Cela indique qu'aucune valeur n'est renvoyée par la fonction. Cela signifie que la valeur n'est pas présente ou est probablement nulle. Parce que chaque fois qu'une fonction imprime simplement les messages, elle n'a pas besoin de valeur de retour.

Ce vide est utilisé de la même manière dans l'espace des paramètres de la fonction pour indiquer clairement que cette fonction ne prend aucune valeur réelle lorsqu'elle est appelée. Dans la situation ci-dessus, nous appellerions également le travail() fonctionne comme:

Les paramètres réels :

On peut définir des paramètres pour la fonction. Les paramètres d'une fonction sont définis dans la liste des arguments de la fonction qui s'ajoute au nom de la fonction. Chaque fois que nous appelons la fonction, nous devons transmettre les valeurs authentiques des paramètres pour terminer l'exécution. Ceux-ci sont conclus comme paramètres réels. Alors que les paramètres définis pendant la définition de la fonction sont appelés paramètres formels.

Exemple:

Dans cet exemple, nous sommes sur le point d'échanger ou de substituer les deux valeurs entières par une fonction.

Au début, nous prenons le fichier d'en-tête. La fonction définie par l'utilisateur est le nom déclaré et défini sous(). Cette fonction est utilisée pour la substitution des deux valeurs entières que sont i et n. Ensuite, les opérateurs arithmétiques sont utilisés pour l'échange de ces deux entiers. La valeur du premier entier ‘i’ est stockée à la place de la valeur ‘n’ et la valeur de n est enregistrée à la place de la valeur de ‘i’. Ensuite, le résultat après avoir changé les valeurs est imprimé. Si nous parlons de la principale() fonction, nous prenons les valeurs des deux entiers de l'utilisateur et affichés. Dans la dernière étape, la fonction définie par l'utilisateur sous() est appelé et les deux valeurs sont échangées.

Dans ce cas de substitution des deux nombres, on voit bien qu'en utilisant le sous() fonction, la valeur de 'i' et 'n' à l'intérieur de la liste des paramètres sont les paramètres formels. Les paramètres réels sont le paramètre qui passe à la fin du principale() fonction où la fonction de substitution est appelée.

Pointeurs C++ :

Le pointeur en C++ est assez facile à apprendre et agréable à utiliser. Dans le langage C++, les pointeurs sont utilisés car ils facilitent notre travail et toutes les opérations fonctionnent avec une grande efficacité lorsque des pointeurs sont impliqués. De plus, certaines tâches ne seront pas accomplies à moins que des pointeurs ne soient utilisés comme l'allocation de mémoire dynamique. En parlant de pointeurs, l'idée principale qu'il faut saisir est que le pointeur n'est qu'une variable qui stockera l'adresse mémoire exacte comme valeur. L'utilisation intensive des pointeurs en C++ est due aux raisons suivantes :

• Pour passer d'une fonction à une autre.
• Pour allouer les nouveaux objets sur le tas.
• Pour l'itération d'éléments dans un tableau

Habituellement, l'opérateur '&' (esperluette) est utilisé pour accéder à l'adresse de n'importe quel objet dans la mémoire.

Pointeurs et leurs types :

Le pointeur a plusieurs types suivants :

• Pointeurs nuls : Ce sont des pointeurs avec une valeur de zéro stockés dans les bibliothèques C++.
• Pointeur arithmétique : Il comprend quatre opérateurs arithmétiques majeurs accessibles qui sont ++, –, +, -.
• Un tableau de pointeurs : Ce sont des tableaux qui sont utilisés pour stocker des pointeurs.
• Pointeur à pointeur : C'est là qu'un pointeur est utilisé sur un pointeur.

Exemple:

Réfléchissez à l'exemple suivant dans lequel les adresses de quelques variables sont imprimées.

Après avoir inclus le fichier d'en-tête et l'espace de noms standard, nous initialisons deux variables. L'un est une valeur entière représentée par i' et l'autre est un tableau de type caractère 'I' d'une taille de 10 caractères. Les adresses des deux variables sont ensuite affichées à l'aide de la commande 'cout'.

La sortie que nous avons reçue est illustrée ci-dessous :

Ce résultat affiche l'adresse pour les deux variables.

D'autre part, un pointeur est considéré comme une variable dont la valeur elle-même est l'adresse d'une variable différente. Un pointeur pointe toujours vers un type de données qui a le même type qui est créé avec un opérateur (*).

Déclaration d'un pointeur :

Le pointeur est déclaré de cette façon :

Le type de base du pointeur est indiqué par « type », tandis que le nom du pointeur est exprimé par « var-name ». Et pour autoriser une variable au pointeur astérisque (*) est utilisé.

Façons d'affecter des pointeurs aux variables :

Presque toujours, il y a un nombre hexadécimal long qui représente l'adresse mémoire qui est initialement la même pour tous les pointeurs, quel que soit leur type de données.

Exemple:

L'instance suivante montre comment les pointeurs remplacent l'opérateur '&' et stockent l'adresse des variables.

Nous allons intégrer le support des bibliothèques et répertoires. Ensuite, on invoquerait le principale() fonction où nous déclarons et initialisons d'abord une variable 'n' de type 'int' avec la valeur 55. Dans la ligne suivante, nous initialisons une variable de pointeur nommée 'p1'. Après cela, nous attribuons l'adresse de la variable 'n' au pointeur 'p1', puis nous montrons la valeur de la variable 'n'. L'adresse de « n » stockée dans le pointeur « p1 » s'affiche. Ensuite, la valeur de '*p1' est imprimée à l'écran en utilisant la commande 'cout'. La sortie est la suivante :

Ici, nous voyons que la valeur de 'n' est 55 et l'adresse de 'n' qui a été stockée dans le pointeur 'p1' est affichée sous la forme 0x6ffe14. La valeur de la variable pointeur est trouvée et c'est 55 qui est la même que la valeur de la variable entière. Par conséquent, un pointeur stocke l'adresse de la variable, et également le pointeur *, a la valeur de l'entier stocké qui renverra en conséquence la valeur de la variable initialement stockée.

Exemple:

Considérons un autre exemple où nous utilisons un pointeur qui stocke l'adresse d'une chaîne.

Dans ce code, nous ajoutons d'abord les bibliothèques et l'espace de noms. Dans le principale() fonction, nous devons déclarer une chaîne nommée 'makeup' qui contient la valeur 'Mascara'. Un pointeur de type chaîne '*p2' est utilisé pour stocker l'adresse de la variable de maquillage. La valeur de la variable 'makeup' est ensuite affichée à l'écran en utilisant l'instruction 'cout'. Après cela, l'adresse de la variable 'makeup' est imprimée, et à la fin, la variable pointeur 'p2' est affichée montrant l'adresse mémoire de la variable 'makeup' avec le pointeur.

La sortie reçue du code ci-dessus est la suivante :

La première ligne contient la valeur de la variable ‘makeup’ affichée. La deuxième ligne affiche l'adresse de la variable 'makeup'. Dans la dernière ligne, l'adresse mémoire de la variable 'makeup' avec l'utilisation du pointeur est affichée.

Gestion de la mémoire C++ :

Pour une gestion efficace de la mémoire en C++, de nombreuses opérations sont utiles pour la gestion de la mémoire tout en travaillant en C++. Lorsque nous utilisons C++, la procédure d'allocation de mémoire la plus couramment utilisée est l'allocation de mémoire dynamique où les mémoires sont affectées aux variables pendant l'exécution ; pas comme les autres langages de programmation où le compilateur pourrait allouer la mémoire aux variables. En C++, la désallocation des variables allouées dynamiquement est nécessaire, afin que la mémoire soit libérée lorsque la variable n'est plus utilisée.

Pour l'allocation et la désallocation dynamiques de la mémoire en C++, nous faisons le ' Nouveau' et 'effacer' opérations. Il est essentiel de gérer la mémoire de sorte qu'aucune mémoire ne soit gaspillée. L'allocation de la mémoire devient facile et efficace. Dans tout programme C++, la mémoire est employée dans l'un des deux aspects suivants : soit sous forme de tas, soit sous forme de pile.

• Empiler : Toutes les variables déclarées dans la fonction et tous les autres détails liés à la fonction sont stockés dans la pile.
• Tas : Toute sorte de mémoire inutilisée ou la partie à partir de laquelle nous allouons ou attribuons la mémoire dynamique lors de l'exécution d'un programme est appelée un tas.

Lors de l'utilisation de tableaux, l'allocation de mémoire est une tâche dans laquelle nous ne pouvons tout simplement pas déterminer la mémoire à moins que le temps d'exécution. Donc, nous attribuons la mémoire maximale à la matrice, mais ce n'est pas non plus une bonne pratique car dans la plupart des cas, la mémoire reste inutilisée et elle est en quelque sorte gaspillée, ce qui n'est tout simplement pas une bonne option ou pratique pour votre ordinateur personnel. C'est pourquoi, nous avons quelques opérateurs qui sont utilisés pour allouer de la mémoire à partir du tas pendant l'exécution. Les deux principaux opérateurs 'nouveau' et 'supprimer' sont utilisés pour une allocation et une désallocation efficaces de la mémoire.

Nouvel opérateur C++ :

Le nouvel opérateur est responsable de l'allocation de la mémoire et est utilisé comme suit :

Dans ce code, nous incluons la bibliothèque et l'espace de noms. Ensuite, nous avons initialisé un pointeur avec le type de données 'int'. Dans la ligne suivante, ce pointeur se voit attribuer l'opérateur 'nouveau'.

La mémoire a été allouée à la variable 'int' avec succès à l'aide d'un pointeur.

Opérateur de suppression C++ :

Chaque fois que nous avons fini d'utiliser une variable, nous devons désallouer la mémoire que nous lui avons allouée car elle n'est plus utilisée. Pour cela, nous utilisons l'opérateur 'supprimer' pour libérer la mémoire.

L'exemple que nous allons examiner maintenant consiste à inclure les deux opérateurs.

Nous calculons la moyenne de trois valeurs différentes prises par l'utilisateur. Les variables de pointeur sont affectées avec l'opérateur 'nouveau' pour stocker les valeurs. La formule de moyenne est implémentée. Après cela, l'opérateur 'supprimer' est utilisé, ce qui supprime les valeurs qui ont été stockées dans les variables de pointeur à l'aide de l'opérateur 'nouveau'. Il s'agit de l'allocation dynamique où l'allocation est effectuée pendant l'exécution, puis la désallocation se produit peu de temps après la fin du programme.

Utilisation d'un tableau pour l'allocation de mémoire :

Maintenant, nous allons voir comment les opérateurs 'nouveau' et 'supprimer' sont utilisés lors de l'utilisation de tableaux. L'allocation dynamique se produit de la même manière que pour les variables car la syntaxe est presque la même.

Dans l'exemple donné, nous considérons le tableau d'éléments dont la valeur est tirée de l'utilisateur. Les éléments du tableau sont pris et la variable pointeur est déclarée puis la mémoire est allouée. Peu de temps après l'allocation de mémoire, la procédure d'entrée des éléments du tableau est lancée. Ensuite, la sortie des éléments du tableau est affichée à l'aide d'une boucle 'for'. Cette boucle a la condition d'itération des éléments ayant une taille inférieure à la taille réelle du tableau représenté par n.

Lorsque tous les éléments sont utilisés et qu'il n'est plus nécessaire de les utiliser à nouveau, la mémoire affectée aux éléments sera désallouée à l'aide de l'opérateur 'supprimer'.

Dans la sortie, nous pourrions voir des ensembles de valeurs imprimés deux fois. La première boucle 'for' a été utilisée pour écrire les valeurs des éléments et l'autre boucle 'for' est utilisée pour l'impression des valeurs déjà écrites montrant que l'utilisateur a écrit ces valeurs pour plus de clarté.

Avantages :

L'opérateur 'nouveau' et 'supprimer' est toujours la priorité dans le langage de programmation C++ et est largement utilisé. Lors d'une discussion et d'une compréhension approfondies, il est noté que le « nouvel » opérateur présente trop d'avantages. Les avantages de l'opérateur 'nouveau' pour l'allocation de la mémoire sont les suivants :

• Le nouvel opérateur peut être surchargé plus facilement.
• Lors de l'allocation de mémoire pendant l'exécution, chaque fois qu'il n'y a pas assez de mémoire, une exception automatique est levée plutôt que le programme se termine simplement.
• L'agitation de l'utilisation de la procédure de transtypage n'est pas présente ici car le 'nouveau' opérateur a exactement le même type que la mémoire que nous avons allouée.
• L'opérateur 'new' rejette également l'idée d'utiliser l'opérateur sizeof() car 'new' calculera inévitablement la taille des objets.
• L'opérateur 'new' nous permet d'initialiser et de déclarer les objets même s'il génère spontanément l'espace pour eux.

Tableaux C++ :

Nous allons avoir une discussion approfondie sur ce que sont les tableaux et comment ils sont déclarés et implémentés dans un programme C++. Le tableau est une structure de données utilisée pour stocker plusieurs valeurs dans une seule variable, réduisant ainsi l'agitation de déclarer de nombreuses variables indépendamment.

Déclaration des tableaux :

Pour déclarer un tableau, il faut d'abord définir le type de variable et donner un nom approprié au tableau qui est ensuite ajouté entre crochets. Celui-ci contiendra le nombre d'éléments indiquant la taille d'un tableau particulier.

Par exemple:

Cette variable est déclarée indiquant qu'elle contient cinq chaînes dans un tableau nommé 'makeup'. Pour identifier et illustrer les valeurs de ce tableau, nous devons utiliser les accolades, avec chaque élément séparément entouré de doubles virgules, chacune séparée par une seule virgule entre les deux.

Par exemple:

De même, si vous avez envie de créer un autre tableau avec un type de données différent supposé être 'int', alors la procédure serait la même, il vous suffit de changer le type de données de la variable comme indiqué ci-dessous :

Lors de l'affectation de valeurs entières au tableau, il ne faut pas les contenir entre guillemets, ce qui ne fonctionnerait que pour la variable chaîne. Donc, en conclusion, un tableau est une collection d'éléments de données interdépendants avec des types de données dérivés stockés en eux.

Comment accéder aux éléments du tableau ?

Tous les éléments inclus dans le tableau sont affectés d'un numéro distinct qui est leur numéro d'index utilisé pour accéder à un élément du tableau. La valeur d'index commence par un 0 jusqu'à un de moins que la taille du tableau. La toute première valeur a la valeur d'index de 0.

Exemple:

Considérons un exemple très basique et facile dans lequel nous allons initialiser des variables dans un tableau.

Dans la toute première étape, nous incorporons le fichier d'en-tête , qui ajoutera automatiquement toutes les bibliothèques nécessaires dans le programme. L'espace de noms 'std' fournira la portée des répertoires. Dans la troisième ligne, nous appelons le principale() fonction. L'accolade signifie le démarrage de la fonction. Après être entré dans la fonction, nous allons déclarer le tableau de type « int » nommé « digits ». Il contient la taille de 4, ce qui signifie qu'il ne peut contenir que 4 valeurs entières à la fois. Chacun des éléments du tableau s'est vu attribuer un chiffre unique et différent séparément. L'ensemble du tableau est alors affiché, chaque élément étant appelé individuellement.

C'est le résultat reçu du code ci-dessus. Le mot-clé 'endl' déplace automatiquement l'autre élément à la ligne suivante.

Exemple:

Dans ce code, nous utilisons une boucle 'for' pour imprimer les éléments d'un tableau.

Dans l'exemple ci-dessus, nous ajoutons la bibliothèque essentielle. L'espace de noms standard est en cours d'ajout. La principale() fonction est la fonction où nous allons exécuter toutes les fonctionnalités pour l'exécution d'un programme particulier. Ensuite, nous déclarons un tableau de type int nommé 'Num', qui a une taille de 10. La valeur de ces dix variables est prise de l'utilisateur avec l'utilisation de la boucle 'for'. Pour l'affichage de ce tableau, une boucle 'for' est à nouveau utilisée. Les 10 entiers stockés dans le tableau sont affichés à l'aide de l'instruction 'cout'.

C'est la sortie que nous avons obtenue de l'exécution du code ci-dessus, montrant 10 entiers ayant des valeurs différentes.

Exemple:

Dans ce scénario, nous sommes sur le point de connaître le score moyen d'un élève et le pourcentage qu'il a obtenu dans la classe.

Tout d'abord, vous devez ajouter une bibliothèque qui fournira un support initial au programme C++. Ensuite, nous spécifions la taille 5 du tableau nommé 'Score'. Ensuite, nous avons initialisé une variable ‘sum’ de datatype float. Les scores de chaque sujet sont récupérés manuellement par l'utilisateur. Ensuite, une boucle 'for' est utilisée pour connaître la moyenne et le pourcentage de tous les sujets inclus. La somme est obtenue en utilisant le tableau et la boucle 'for'. Ensuite, la moyenne est trouvée en utilisant la formule de la moyenne. Après avoir trouvé la moyenne, nous transmettons sa valeur au pourcentage qui est ajouté à la formule pour obtenir le pourcentage. La moyenne et le pourcentage sont ensuite calculés et affichés.

Il s'agit de la sortie finale où les scores sont obtenus de l'utilisateur pour chaque sujet individuellement et la moyenne et le pourcentage sont calculés respectivement.

Avantages de l'utilisation des tableaux :

• Les éléments du tableau sont faciles d'accès en raison du numéro d'index qui leur est attribué.
• Nous pouvons facilement effectuer l'opération de recherche sur un tableau.
• Au cas où vous voudriez des complexités dans la programmation, vous pouvez utiliser un tableau à 2 dimensions qui caractérise également les matrices.
• Pour stocker plusieurs valeurs ayant un type de données similaire, un tableau peut être utilisé facilement.

Inconvénients de l'utilisation des tableaux :

• Les tableaux ont une taille fixe.
• Les tableaux sont homogènes, ce qui signifie qu'un seul type de valeur est stocké.
• Les baies stockent les données dans la mémoire physique individuellement.
• Le processus d'insertion et de suppression n'est pas facile pour les tableaux.

Objets et classes C++ :

C++ est un langage de programmation orienté objet, ce qui signifie que les objets jouent un rôle vital en C++. En parlant d'objets, il faut d'abord considérer ce que sont les objets, donc un objet est n'importe quelle instance de la classe. Comme C++ traite des concepts de la POO, les principaux éléments à discuter sont les objets et les classes. Les classes sont en fait des types de données qui sont définis par l'utilisateur lui-même et sont désignés pour encapsuler les membres de données et les fonctions qui ne sont accessibles que lorsque l'instance de la classe particulière est créée. Les membres de données sont les variables définies à l'intérieur de la classe.

En d'autres termes, la classe est un plan ou une conception responsable de la définition et de la déclaration des membres de données et des fonctions attribuées à ces membres de données. Chacun des objets déclarés dans la classe pourrait partager toutes les caractéristiques ou fonctions démontrées par la classe.

Supposons qu'il y ait une classe nommée oiseaux, maintenant initialement tous les oiseaux pouvaient voler et avoir des ailes. Par conséquent, voler est un comportement que ces oiseaux adoptent et les ailes font partie de leur corps ou une caractéristique de base.

Définition d'une classe :

Pour définir une classe, vous devez suivre la syntaxe et la réinitialiser en fonction de votre classe. Le mot clé 'class' est utilisé pour définir la classe et tous les autres membres de données et fonctions sont définis à l'intérieur des accolades suivies de la définition de la classe.

Déclarer des objets :

Peu de temps après avoir défini une classe, nous devons créer les objets pour accéder et définir les fonctions qui ont été spécifiées par la classe. Pour cela, il faut écrire le nom de la classe puis le nom de l'objet à déclarer.

Accéder aux membres de données :

Les fonctions et données membres sont accessibles à l'aide d'un simple point ‘.’ Opérateur. Les membres de données publics sont également accessibles avec cet opérateur, mais dans le cas des membres de données privés, vous ne pouvez tout simplement pas y accéder directement. L'accès des membres de données dépend des contrôles d'accès qui leur sont donnés par les modificateurs d'accès qui sont privés, publics ou protégés. Voici un scénario qui montre comment déclarer la classe simple, les membres de données et les fonctions.

Exemple:

Dans cet exemple, nous allons définir quelques fonctions et accéder aux fonctions de classe et aux données membres à l'aide des objets.

Dans la première étape, nous intégrons la bibliothèque, après quoi nous devons inclure les répertoires de support. La classe est explicitement définie avant d'appeler le principale() fonction. Cette classe est appelée « véhicule ». Les membres de données étaient le 'nom du véhicule' et 'l'identifiant' de ce véhicule, qui est le numéro de plaque de ce véhicule ayant une chaîne, et le type de données int respectivement. Les deux fonctions sont déclarées pour ces deux membres de données. La identifiant() La fonction affiche l'identifiant du véhicule. Comme les données membres de la classe sont publiques, nous pouvons également y accéder en dehors de la classe. Par conséquent, nous appelons le Nom() fonction en dehors de la classe, puis en prenant la valeur du 'VehicleName' de l'utilisateur et en l'imprimant à l'étape suivante. Dans le principale() fonction, nous déclarons un objet de la classe requise qui aidera à accéder aux membres de données et aux fonctions de la classe. De plus, nous initialisons les valeurs pour le nom du véhicule et son identifiant, uniquement si l'utilisateur ne donne pas la valeur du nom du véhicule.

Il s'agit de la sortie reçue lorsque l'utilisateur donne lui-même le nom du véhicule et que les plaques d'immatriculation sont la valeur statique qui lui est attribuée.

En parlant de la définition des fonctions membres, il faut comprendre qu'il n'est pas toujours obligatoire de définir la fonction à l'intérieur de la classe. Comme vous pouvez le voir dans l'exemple ci-dessus, nous définissons la fonction de la classe en dehors de la classe car les membres de données sont déclarés publiquement et cela se fait à l'aide de l'opérateur de résolution de portée affiché comme ' :: ' avec le nom de la classe et le nom de la fonction.

Constructeurs et destructeurs C++ :

Nous allons avoir une vision approfondie de ce sujet à l'aide d'exemples. La suppression et la création des objets dans la programmation C++ sont très importantes. Pour cela, chaque fois que nous créons une instance pour une classe, nous appelons automatiquement les méthodes du constructeur dans quelques cas.

Constructeurs :

Comme son nom l'indique, un constructeur est dérivé du mot 'construction' qui spécifie la création de quelque chose. Ainsi, un constructeur est défini comme une fonction dérivée de la classe nouvellement créée qui partage le nom de la classe. Et il est utilisé pour l'initialisation des objets inclus dans la classe. De plus, un constructeur n'a pas de valeur de retour pour lui-même, ce qui signifie que son type de retour ne sera même pas vide non plus. Il n'est pas obligatoire d'accepter les arguments, mais on peut les ajouter si nécessaire. Les constructeurs sont utiles dans l'allocation de mémoire à l'objet d'une classe et dans la définition de la valeur initiale des variables membres. La valeur initiale peut être passée sous forme d'arguments à la fonction constructeur une fois l'objet initialisé.

Syntaxe:

Types de constructeurs :

Constructeur paramétré :

Comme discuté précédemment, un constructeur n'a pas de paramètre mais on peut ajouter un paramètre de son choix. Cela initialisera la valeur de l'objet pendant sa création. Pour mieux comprendre ce concept, considérons l'exemple suivant :

Exemple:

Dans ce cas, nous créerions un constructeur de la classe et déclarerions des paramètres.

Nous incluons le fichier d'en-tête dans la toute première étape. La prochaine étape de l'utilisation d'un espace de noms consiste à prendre en charge les répertoires du programme. Une classe nommée 'chiffres' est déclarée où les variables sont d'abord initialisées publiquement afin qu'elles puissent être accessibles tout au long du programme. Une variable nommée 'dig1' avec un type de données entier est déclarée. Ensuite, nous avons déclaré un constructeur dont le nom est similaire au nom de la classe. Ce constructeur a une variable entière qui lui est transmise en tant que 'n' et la variable de classe 'dig1' est définie égale à n. Dans le principale() fonction du programme, trois objets pour la classe 'chiffres' sont créés et reçoivent des valeurs aléatoires. Ces objets sont ensuite utilisés pour appeler les variables de classe qui reçoivent automatiquement les mêmes valeurs.

Les valeurs entières sont présentées à l'écran en sortie.

Copier le constructeur :

C'est le type de constructeur qui considère les objets comme arguments et duplique les valeurs des données membres d'un objet à l'autre. Par conséquent, ces constructeurs sont utilisés pour déclarer et initialiser un objet à partir de l'autre. Ce processus est appelé initialisation de copie.

Exemple:

Dans ce cas, le constructeur de copie sera déclaré.

Premièrement, nous intégrons la bibliothèque et l'annuaire. Une classe nommée ‘New’ est déclarée dans laquelle les entiers sont initialisés comme ‘e’ et ‘o’. Le constructeur est rendu public où les deux variables reçoivent les valeurs et ces variables sont déclarées dans la classe. Ensuite, ces valeurs sont affichées à l'aide de la principale() fonction avec 'int' comme type de retour. La affichage() fonction est appelée et définie par la suite où les nombres sont affichés à l'écran. À l'intérieur de principale() fonction, les objets sont créés et ces objets assignés sont initialisés avec des valeurs aléatoires, puis les affichage() méthode est utilisée.

La sortie reçue par l'utilisation du constructeur de copie est révélée ci-dessous.

Destroyers :

Comme le nom le définit, les destructeurs sont utilisés pour détruire les objets créés par le constructeur. Comparables aux constructeurs, les destructeurs ont le même nom que la classe mais avec un tilde supplémentaire (~) suivi.

Syntaxe:

Le destructeur ne prend aucun argument et n'a même pas de valeur de retour. Le compilateur appelle implicitement la sortie du programme pour nettoyer le stockage qui n'est plus accessible.

Exemple:

Dans ce scénario, nous utilisons un destructeur pour supprimer un objet.

Ici, une classe 'Chaussures' est créée. Un constructeur est créé avec un nom similaire à celui de la classe. Dans le constructeur, un message s'affiche à l'endroit où l'objet est créé. Après le constructeur, le destructeur est créé, ce qui supprime les objets créés avec le constructeur. Dans le principale() fonction, un objet pointeur nommé ‘s’ est créé et un mot-clé ‘delete’ est utilisé pour supprimer cet objet.

C'est la sortie que nous avons reçue du programme où le destructeur efface et détruit l'objet créé.

Différence entre constructeurs et destructeurs :

Héritage C++ :

Maintenant, nous allons en apprendre davantage sur l'héritage C++ et sa portée.

L'héritage est la méthode par laquelle une nouvelle classe est générée ou descend d'une classe existante. La classe actuelle est appelée « classe de base » ou encore « classe parente » et la nouvelle classe qui est créée est appelée « classe dérivée ». Lorsque nous disons qu'une classe enfant est héritée d'une classe parent, cela signifie que l'enfant possède toutes les propriétés de la classe parent.

L'héritage fait référence à une (est une) relation. Nous appelons toute relation un héritage si 'est-un' est utilisé entre deux classes.

Par exemple:

• Un perroquet est un oiseau.
• Un ordinateur est une machine.

Syntaxe:

En programmation C++, nous utilisons ou écrivons Héritage comme suit :

Modes d'héritage C++ :

L'héritage implique 3 modes pour hériter des classes :

• Public: Dans ce mode, si une classe enfant est déclarée, les membres d'une classe parent sont hérités par la classe enfant comme les mêmes dans une classe parent.
• Protégé : je Dans ce mode, les membres publics de la classe parent deviennent des membres protégés de la classe enfant.
• Privé : Dans ce mode, tous les membres d'une classe parent deviennent privés dans la classe enfant.

Types d'héritage C++ :

Voici les types d'héritage C++ :

1. Héritage unique :

Avec ce type d'héritage, les classes proviennent d'une classe de base.

Syntaxe:

2. Héritage multiple :

Dans ce type d'héritage, une classe peut descendre de différentes classes de base.

Syntaxe:

3. Héritage à plusieurs niveaux :

Une classe enfant descend d'une autre classe enfant dans cette forme d'héritage.

Syntaxe:

4. Héritage hiérarchique :

Plusieurs sous-classes sont créées à partir d'une classe de base dans cette méthode d'héritage.

Syntaxe:

5. Héritage hybride :

Dans ce type d'héritage, plusieurs héritages sont combinés.

Syntaxe:

Exemple:

Nous allons exécuter le code pour démontrer le concept d'héritage multiple dans la programmation C++.

Comme nous avons commencé avec une bibliothèque d'entrée-sortie standard, nous avons donné le nom de classe de base 'Bird' et l'avons rendue publique afin que ses membres puissent être accessibles. Ensuite, nous avons la classe de base 'Reptile' et nous l'avons également rendue publique. Ensuite, nous avons « cout » pour imprimer la sortie. Après cela, nous avons créé un 'pingouin' de classe enfant. Dans le principale() fonction dont nous avons fait l'objet de la classe penguin 'p1'. Tout d'abord, la classe 'Bird' s'exécutera, puis la classe 'Reptile'.

Après l'exécution du code en C++, nous obtenons les déclarations de sortie des classes de base 'Bird' et 'Reptile'. Cela signifie qu'une classe « pingouin » est dérivée des classes de base « Oiseau » et « Reptile », car un pingouin est à la fois un oiseau et un reptile. Il peut voler aussi bien que ramper. Par conséquent, les héritages multiples ont prouvé qu'une classe enfant peut être dérivée de plusieurs classes de base.

Exemple:

Ici, nous allons exécuter un programme pour montrer comment utiliser l'héritage à plusieurs niveaux.

Nous avons commencé notre programme en utilisant des flux d'entrée-sortie. Ensuite, nous avons déclaré une classe parente 'M' qui est définie comme publique. Nous avons appelé le affichage() fonction et la commande 'cout' pour afficher l'instruction. Ensuite, nous avons créé une classe enfant ‘N’ qui est dérivée de la classe parent ‘M’. Nous avons une nouvelle classe enfant 'O' dérivée de la classe enfant 'N' et le corps des deux classes dérivées est vide. En fin de compte, nous invoquons le principale() fonction dans laquelle nous devons initialiser l'objet de la classe 'O'. La affichage() fonction de l'objet est utilisée pour démontrer le résultat.

Dans cette figure, nous avons le résultat de la classe 'M' qui est la classe mère car nous avions un affichage() y fonctionner. Ainsi, la classe 'N' est dérivée de la classe parente 'M' et la classe 'O' de la classe parente 'N' qui fait référence à l'héritage à plusieurs niveaux.

Polymorphisme C++ :

Le terme « polymorphisme » représente une collection de deux mots 'poly' et ' morphisme’ . Le mot « Poly » représente « plusieurs » et « morphisme » représente des « formes ». Le polymorphisme signifie qu'un objet peut se comporter différemment dans différentes conditions. Il permet à un programmeur de réutiliser et d'étendre le code. Le même code agit différemment selon la condition. La mise en acte d'un objet peut être employée au moment de l'exécution.

Catégories de polymorphisme :

Le polymorphisme se produit principalement selon deux méthodes :

1. Polymorphisme de temps de compilation
2. Polymorphisme d'exécution

Expliquons-nous.

6. Polymorphisme de temps de compilation :

Pendant ce temps, le programme saisi est transformé en un programme exécutable. Avant le déploiement du code, les erreurs sont détectées. Il en existe principalement deux catégories.

• Surcharge de fonction
• Surcharge de l'opérateur

Voyons comment nous utilisons ces deux catégories.

7. Surcharge de fonction :

Cela signifie qu'une fonction peut effectuer différentes tâches. Les fonctions sont dites surchargées lorsqu'il existe plusieurs fonctions avec un nom similaire mais des arguments distincts.

Tout d'abord, nous utilisons la bibliothèque ainsi que l'espace de noms standard. Ensuite, nous déclarerions la classe définie par l'utilisateur 'Add'. A l'intérieur de la classe, nous définissons une fonction ADD() avec deux paramètres en public. Encore une fois, déclarez une nouvelle fonction dans le corps de la classe avec le même nom mais cette fonction n'a pas de paramètre. Ici, nous initialisons trois chaînes. Les deux premières chaînes ont une certaine valeur et la dernière chaîne est utilisée pour concaténer les deux premières chaînes. Nous utilisons la commande 'cout' pour imprimer le résultat. Ensuite, nous appelons le principale() méthode en dehors de la classe. Nous construisons un objet de la classe requise ‘Add’. Maintenant, nous appelons la première fonction avec deux paramètres, puis appelons également la deuxième fonction. Dans la dernière étape, nous incluons l'instruction 'return 0' pour terminer le programme.

Surcharge d'opérateur :

Le processus de définition de plusieurs fonctionnalités d'un opérateur est appelé surcharge d'opérateur.

L'exemple ci-dessus inclut le fichier d'en-tête . Ensuite, nous avons utilisé un espace de noms standard. Nous définissons la classe ‘Integer’. Dans cette classe, nous spécifions un entier comme membre privé d'une classe. Ensuite, nous déclarons le constructeur Parameterized en tant que membre public et initialisons la valeur de l'entier qu'il contient. Nous définissons un constructeur avec un opérateur de préfixe de surcharge. À l'intérieur de ce constructeur, nous effectuons une opération de préfixe. De plus, nous créons une fonction qui affiche la valeur d'incrément en utilisant l'instruction 'cout'. En attendant, nous invoquons le principale() fonction. Ici, nous créons deux objets de classe. Le premier objet passe une valeur de l'entier. Ensuite, utilisez l'instruction 'cout' pour imprimer la ligne 'Avant d'incrémenter la valeur est'. Ensuite, nous appelons affichage() fonction pour le premier objet. Le deuxième objet utilise l'opérateur de pré-incrémentation. Nous utilisons la commande 'cout' pour afficher la ligne 'Après la pré-incrémentation, la valeur est'. Ensuite, on utilise le affichage() fonction pour le deuxième objet.

8. Polymorphisme d'exécution :

C'est le laps de temps pendant lequel le code s'exécute. Après l'emploi du code, des erreurs peuvent être détectées.

Remplacer la fonction :

Cela se produit lorsqu'une classe dérivée utilise une définition de fonction similaire comme l'une des fonctions membres de la classe de base.

Dans la première ligne, nous incorporons la bibliothèque pour exécuter les opérations d'entrée et de sortie. De plus, nous ajoutons l'espace de noms standard. Dans la ligne suivante, nous déclarons une classe parent 'Man'. À l'intérieur de la classe, nous définissons une fonction avec deux paramètres en tant que public. Ensuite, nous utilisons l'instruction 'cout' pour afficher le texte 'Walking'. En dehors de la classe, nous créons une classe enfant 'Animal' dérivée de la classe parent. Ici, nous créons une fonction ayant un nom similaire à celui qui était précédemment déclaré dans la classe parent. Ensuite, utilisez l'instruction 'cout' pour afficher le texte 'Manger'. Nous utilisons le principale() fonction. Pendant ce temps, nous créons un objet de classe 'm'. Ensuite, nous appelons la fonction de la classe parent ainsi que la fonction de la classe enfant. Utilisez la commande « retour 0 ».

Chaînes C++ :

Nous allons maintenant découvrir comment déclarer et initialiser le String en C++. La chaîne est utilisée pour stocker un groupe de caractères dans le programme. Il stocke les valeurs alphabétiques, les chiffres et les symboles de type spécial dans le programme. Il a réservé des caractères sous forme de tableau dans le programme C++. Les tableaux sont utilisés pour réserver une collection ou une combinaison de caractères dans la programmation C++. Un symbole spécial connu sous le nom de caractère nul est utilisé pour terminer le tableau. Il est représenté par la séquence d'échappement (\0) et il est utilisé pour spécifier la fin de la chaîne.

Obtenez la chaîne à l'aide de la commande 'cin' :

Il est utilisé pour saisir une variable de chaîne sans aucun espace vide. Dans l'exemple donné, nous implémentons un programme C++ qui obtient le nom de l'utilisateur à l'aide de la commande 'cin'.

Dans la première étape, nous utilisons la bibliothèque . En attendant, nous avons inclus l'espace de noms standard. Ensuite, nous déclarons le principale() fonction. Nous initialisons une chaîne de caractères dans le corps du principale() fonction. Ensuite, nous utilisons l'instruction 'cout' pour imprimer 'Entrez votre nom'. Nous utilisons la commande 'cin' pour demander la chaîne à l'utilisateur. La commande 'cout' est appliquée pour imprimer le nom qui serait écrit par l'utilisateur. L'instruction return 0 est ajoutée pour terminer le programme.

L'utilisateur saisit le nom 'Ahmed Chaudry'. Mais nous n'obtenons que 'Ahmed' en sortie plutôt que le 'Ahmed Chaudry' complet car la commande 'cin' ne peut pas stocker une chaîne avec un espace vide. Il ne stocke que la valeur avant l'espace.

Obtenez la chaîne en utilisant la fonction cin.get() :

La obtenir() La fonction de la commande cin est utilisée pour obtenir la chaîne du clavier qui peut contenir des espaces vides.

L'exemple ci-dessus inclut la bibliothèque pour effectuer des opérations d'entrée et de sortie. Ensuite, nous avons utilisé un espace de noms standard. La principale() fonction est appelée. Après cela, nous initialisons une chaîne nommée 's'. À l'étape suivante, la commande 'cout' est utilisée pour afficher l'instruction 'Entrez une chaîne'. La cin.get() est appliqué pour obtenir la chaîne de l'utilisateur. En utilisant le cin.get() fonction nous passons une valeur de chaîne et spécifions la taille de la chaîne en tant que paramètre. La commande « cout » est à nouveau utilisée pour afficher la sortie du programme. À la fin, nous ajoutons le retour 0.

Une chaîne 'Mon nom est Ali' est entrée par l'utilisateur. Nous obtenons la chaîne complète 'Mon nom est Ali' comme résultat car la fonction cin.get() accepte les chaînes qui contiennent les espaces vides.

Utilisation d'un tableau de chaînes 2D (bidimensionnel) :

Dans ce cas, nous prenons l'entrée (nom de trois villes) de l'utilisateur en utilisant un tableau 2D de chaînes.

Tout d'abord, nous intégrons le fichier d'en-tête et un espace de noms standard. Nous invoquons le principale() fonction. Ensuite, nous initialisons un tableau de caractères à deux dimensions avec trois lignes et quinze colonnes. Dans l'étape suivante, la boucle for est utilisée pour compter la variable 'i' pour itérer sur la chaîne requise jusqu'à ce que le caractère nul soit identifié. Dans le corps de la boucle 'for', nous utilisons la commande 'cout' pour afficher la ligne 'Entrez le nom de la ville'. Utilisez ensuite l'instruction 'cin' pour obtenir le nom de la ville. Nous utilisons à nouveau une autre boucle 'for' et une autre instruction 'cout' pour afficher le nom des villes dans une séquence jusqu'à ce que la boucle se termine. Ensuite, la commande « return 0 » est utilisée.

Ici, l'utilisateur entre le nom de trois villes différentes. Le programme utilise un index de ligne pour obtenir trois valeurs de chaîne. Chaque valeur est conservée dans sa propre ligne. La première chaîne est stockée dans la première ligne et ainsi de suite. Chaque valeur de chaîne est affichée de la même manière en utilisant l'index de ligne.

Bibliothèque standard C++ :

La bibliothèque C++ est un cluster ou un regroupement de nombreuses fonctions, classes, constantes et tous les éléments associés inclus dans un ensemble approprié, définissant et déclarant toujours les fichiers d'en-tête standardisés. L'implémentation de ceux-ci inclut deux nouveaux fichiers d'en-tête qui ne sont pas requis par la norme C++ nommés et . Une longue liste de fichiers d'en-tête obligatoires est présente, qui dépend des exigences du compilateur. Les fichiers d'en-tête contiennent la liste d'en-tête qui contient tout le contenu de la bibliothèque standard C++, y compris les fichiers d'en-tête spécifiques pour le modèle de bibliothèque Stand (STL).

La bibliothèque standard supprime l'agitation de la réécriture des instructions lors de la programmation. Il contient de nombreuses bibliothèques qui contiennent du code pour de nombreuses fonctions. Pour faire bon usage de ces bibliothèques, il est obligatoire de les lier à l'aide de fichiers d'en-tête. Lorsque nous importons la bibliothèque d'entrée ou de sortie, cela signifie que nous importons tout le code qui a été stocké dans cette bibliothèque et c'est ainsi que nous pouvons également utiliser les fonctions qu'elle contient en masquant tout le code sous-jacent dont vous n'avez peut-être pas besoin voir.

La bibliothèque standard C++ prend en charge les deux types suivants :

• Une implémentation hébergée qui fournit tous les fichiers d'en-tête de bibliothèque standard essentiels décrits par la norme ISO C++.
• Une implémentation autonome qui ne nécessite qu'une partie des fichiers d'en-tête de la bibliothèque standard. Le sous-ensemble approprié est :

Quelques-uns des fichiers d'en-tête ont été déplorés depuis l'arrivée des 11 derniers C++ : il s'agit de , et .

Les différences entre les implémentations hébergées et autonomes sont illustrées ci-dessous :

• Dans l'implémentation hébergée, nous devons utiliser une fonction globale qui est la fonction principale. Dans une implémentation autonome, l'utilisateur peut déclarer et définir lui-même les fonctions de début et de fin.
• Une implémentation d'hébergement a un thread obligatoire en cours d'exécution au moment correspondant. Alors que, dans l'implémentation autonome, les implémenteurs décideront eux-mêmes s'ils ont besoin du support du thread concurrent dans leur bibliothèque.

Les types:

Les versions autonome et hébergée sont prises en charge par C++. Les fichiers d'en-tête sont divisés en deux :

• Pièces Iostream
• Pièces STL C++ (bibliothèque standard)

Chaque fois que nous écrivons un programme à exécuter en C++, nous appelons toujours les fonctions déjà implémentées dans la STL. Ces fonctions connues prennent en entrée et affichent la sortie à l'aide d'opérateurs identifiés avec efficacité.

Compte tenu de l'historique, la STL s'appelait initialement la bibliothèque de modèles standard. Ensuite, les portions de la bibliothèque STL ont ensuite été standardisées dans la bibliothèque standard de C++ qui est utilisée de nos jours. Ceux-ci incluent la bibliothèque d'exécution ISO C++ et quelques fragments de la bibliothèque Boost, y compris d'autres fonctionnalités importantes. Parfois, la STL désigne les conteneurs ou plus fréquemment les algorithmes de la bibliothèque standard C++. Maintenant, cette STL ou bibliothèque de modèles standard parle entièrement de la bibliothèque standard C++ connue.

L'espace de noms std et les fichiers d'en-tête :

Toutes les déclarations de fonctions ou de variables sont faites au sein de la bibliothèque standard à l'aide de fichiers d'en-tête qui sont répartis équitablement entre eux. La déclaration ne se produira que si vous n'incluez pas les fichiers d'en-tête.

Supposons que quelqu'un utilise des listes et des chaînes, il doit ajouter les fichiers d'en-tête suivants :

Ces crochets angulaires '<>' signifient qu'il faut rechercher ce fichier d'en-tête particulier dans le répertoire défini et inclus. On peut également ajouter une extension '.h' à cette bibliothèque, ce qui est fait si nécessaire ou souhaité. Si nous excluons la bibliothèque '.h', nous avons besoin d'un ajout 'c' juste avant le début du nom du fichier, juste comme une indication que ce fichier d'en-tête appartient à une bibliothèque C. Par exemple, vous pouvez soit écrire (#include ou #include ).

En parlant de l'espace de noms, toute la bibliothèque standard C++ se trouve à l'intérieur de cet espace de noms noté std. C'est la raison pour laquelle les noms de bibliothèques normalisés doivent être définis avec compétence par les utilisateurs. Par exemple:

Vecteurs C++ :

Il existe de nombreuses façons de stocker des données ou des valeurs en C++. Mais pour l'instant, nous recherchons le moyen le plus simple et le plus flexible de stocker les valeurs lors de l'écriture des programmes en langage C++. Ainsi, les vecteurs sont des conteneurs qui sont correctement séquencés dans un motif de série dont la taille varie au moment de l'exécution en fonction de l'insertion et de la déduction des éléments. Cela signifie que le programmeur pourra modifier la taille du vecteur selon son souhait lors de l'exécution du programme. Ils ressemblent aux tableaux de telle manière qu'ils ont également des positions de stockage communicables pour leurs éléments inclus. Pour la vérification du nombre de valeurs ou d'éléments présents à l'intérieur des vecteurs, nous devons utiliser un ' std::count' fonction. Les vecteurs sont inclus dans la bibliothèque de modèles standard de C++, il a donc un fichier d'en-tête défini qui doit être inclus en premier, c'est-à-dire :

Déclaration:

La déclaration d'un vecteur est illustrée ci-dessous.

Ici, le vecteur est le mot-clé utilisé, la DT affiche le type de données du vecteur qui peut être remplacé par int, float, char ou tout autre type de données associé. La déclaration ci-dessus peut être réécrite comme suit :

La taille du vecteur n'est pas spécifiée car la taille peut augmenter ou diminuer pendant l'exécution.

Initialisation des vecteurs :

Pour l'initialisation des vecteurs, il existe plusieurs manières en C++.

Technique numéro 1 :

Dans cette procédure, nous attribuons directement les valeurs des deux vecteurs. Les valeurs attribuées aux deux sont exactement similaires.

Technique numéro 2 :

Dans ce processus d'initialisation, 3 dicte la taille du vecteur et 15 est la donnée ou la valeur qui y a été stockée. Un vecteur de type de données 'int' avec la taille donnée de 3 stockant la valeur 15 est créé, ce qui signifie que le vecteur 'v3' stocke ce qui suit :

Opérations majeures :

Les principales opérations que nous allons implémenter sur les vecteurs à l'intérieur de la classe vector sont :

• Ajouter une valeur
• Accéder à une valeur
• Modification d'une valeur
• Suppression d'une valeur

Ajout et suppression :

L'ajout et la suppression des éléments à l'intérieur du vecteur se font systématiquement. Dans la plupart des cas, les éléments sont insérés à la fin des conteneurs vectoriels, mais vous pouvez également ajouter des valeurs à l'endroit souhaité, ce qui finira par déplacer les autres éléments vers leurs nouveaux emplacements. Alors que lors de la suppression, lorsque les valeurs sont supprimées de la dernière position, cela réduira automatiquement la taille du conteneur. Mais lorsque les valeurs à l'intérieur du conteneur sont supprimées de manière aléatoire d'un emplacement particulier, les nouveaux emplacements sont automatiquement attribués aux autres valeurs.

Fonctions utilisées :

Pour modifier ou changer les valeurs stockées dans le vecteur, il existe des fonctions prédéfinies appelées modificateurs. Ils sont les suivants :

• Insert () : Il est utilisé pour l'ajout d'une valeur à l'intérieur d'un conteneur vectoriel à un emplacement particulier.
• Effacer (): Il est utilisé pour supprimer ou supprimer une valeur à l'intérieur d'un conteneur vectoriel à un emplacement particulier.
• Swap() : Il est utilisé pour l'échange des valeurs à l'intérieur d'un conteneur vectoriel qui appartient au même type de données.
• Assign () : Il est utilisé pour l'attribution d'une nouvelle valeur à la valeur précédemment stockée à l'intérieur du conteneur vectoriel.
• Begin (): Il est utilisé pour renvoyer un itérateur à l'intérieur d'une boucle qui adresse la première valeur du vecteur à l'intérieur du premier élément.
• Clear() : Il est utilisé pour la suppression de toutes les valeurs stockées dans un conteneur vectoriel.
• Push_back() : Il est utilisé pour l'ajout d'une valeur à la fin du conteneur vectoriel.
• Pop_back() : Il est utilisé pour la suppression d'une valeur à la fin du conteneur du vecteur.

Exemple:

Dans cet exemple, des modificateurs sont utilisés le long des vecteurs.

Tout d'abord, nous incluons les fichiers d'en-tête et . Après cela, l'espace de noms std est intégré pour ajouter les classes en une seule fois. Pour écrire la logique de l'ensemble du programme, nous appelons la fonction main() où un vecteur nommé 'chiffres' est initialisé. L'affectation de ce vecteur se fait à l'étape suivante où 'digits' a donné une valeur de 6 et 24, ce qui signifie que 6 éléments sont stockés à l'intérieur du conteneur de vecteur, chacun avec la valeur de 24. Ces valeurs sont ensuite affichées en utilisant le 'cout ' commande. Une boucle 'for' est utilisée pour la fonction de modification push_back() pour l'ajout des éléments à l'intérieur du conteneur. Maintenant, la valeur 3 est ajoutée aux chiffres à la fin. Ensuite, nous initialisons une variable 'x' pour conserver l'enregistrement de la taille du conteneur vectoriel. Maintenant, la valeur du dernier élément est affichée et le pop_back() la fonction supprimerait le nombre « 3 » stocké à l'intérieur du conteneur. Pour l'affichage de tous les éléments, nous utilisons à nouveau une boucle 'for' avec le insérer() modificateur qui insérera les valeurs. Ici, 4 sera inséré au début du conteneur vectoriel et affiché à l'écran. La dégager() modifier effacera ou supprimera alors toutes les valeurs stockées dans le conteneur. La taille du vecteur est ensuite affichée une fois le nettoyage effectué.

La sortie est illustrée ci-dessous.

Sortie d'entrée de fichiers C++ :

Un fichier est un assemblage de données interdépendantes. En C++, un fichier est une séquence d'octets qui sont rassemblés dans l'ordre chronologique. La plupart des fichiers existent à l'intérieur du disque. Mais les périphériques matériels tels que les bandes magnétiques, les imprimantes et les lignes de communication sont également inclus dans les fichiers.

L'entrée et la sortie dans les fichiers sont caractérisées par les trois classes principales :

• La classe « istream » est utilisée pour prendre des entrées.
• La classe 'ostream' est utilisée pour afficher la sortie.
• Pour l'entrée et la sortie, utilisez la classe 'iostream'.

Les fichiers sont traités comme des flux en C++. Lorsque nous prenons des entrées et des sorties dans un fichier ou à partir d'un fichier, voici les classes utilisées :

• Hors ligne : C'est une classe de flux utilisée pour écrire dans un fichier.
• Si flux : C'est une classe de flux utilisée pour lire le contenu d'un fichier.
• Flux: C'est une classe de flux utilisée à la fois pour la lecture et l'écriture dans un fichier ou à partir d'un fichier.

Les classes ‘istream’ et ‘ostream’ sont les ancêtres de toutes les classes citées ci-dessus. Les flux de fichiers sont aussi faciles à utiliser que les commandes 'cin' et 'cout', à la seule différence d'associer ces flux de fichiers à d'autres fichiers. Voyons un exemple à étudier brièvement sur la classe ‘fstream’ :

Exemple:

Dans ce cas, nous écrivons des données dans un fichier.

Nous intégrons le flux d'entrée et de sortie dans la première étape. Le fichier d'en-tête est ensuite ajouté car nous allons écrire et lire des données à partir du fichier. Après cela, les classes sont appelées à l'aide de l'espace de noms. La principale() est appelée pour le corps du programme où le 'ofstream' est utilisé pour écrire les données dans un fichier, le fichier est créé en tant que New_File. Dans l'étape suivante, nous ouvrons un fichier texte nommé 'exemple' en utilisant le ouvert( ) méthode. Nous écrivons un texte à l'aide de crochets angulaires dans le fichier. Chaque dossier est voué à être clos une fois qu'il a été traité. C'est pourquoi le dossier est clos à l'aide du proche() fonction.

Le fichier « exemple » est ouvert à partir de l'ordinateur personnel et le texte écrit sur le fichier est imprimé sur ce fichier texte, comme indiqué ci-dessus.

Ouverture d'un fichier :

Lorsqu'un fichier est ouvert, il est représenté par un flux. Un objet est créé pour le fichier comme New_File a été créé dans l'exemple précédent. Toutes les opérations d'entrée et de sortie qui ont été effectuées sur le flux sont automatiquement appliquées au fichier lui-même. Pour l'ouverture d'un fichier, la fonction open() est utilisée comme :

Ici, le mode est non obligatoire.

Fermeture d'un dossier :

Une fois toutes les opérations d'entrée et de sortie terminées, nous devons fermer le fichier qui a été ouvert pour l'édition. Nous sommes tenus d'employer un proche() fonctionner dans cette situation.

Lorsque cela est fait, le fichier devient indisponible. Si en aucun cas l'objet est détruit, même en étant lié au fichier, le destructeur appellera spontanément la fonction close().

Fichiers texte :

Les fichiers texte sont utilisés pour stocker le texte. Par conséquent, si le texte est saisi ou affiché, il doit avoir quelques modifications de formatage. L'opération d'écriture à l'intérieur du fichier texte est la même que celle que nous effectuons avec la commande 'cout'.

Exemple:

Dans ce scénario, nous écrivons des données dans le fichier texte qui a déjà été créé dans l'illustration précédente.

Ici, nous écrivons des données dans le fichier nommé « example » en utilisant la fonction New_File(). Nous ouvrons le fichier ‘exemple’ en utilisant le ouvert() méthode. Le ‘ofstream’ est utilisé pour ajouter les données au fichier. Après avoir effectué tout le travail à l'intérieur du fichier, le fichier requis est fermé par l'utilisation de la proche() fonction. Si le fichier ne s'ouvre pas, le message d'erreur 'Le fichier n'est pas pris en charge, erreur lors du chargement du fichier' s'affiche.

Le fichier s'ouvre et le texte s'affiche sur la console.

Lecture d'un fichier texte :

La lecture d'un fichier est illustrée à l'aide de l'exemple suivant.

Exemple:

Le 'ifstream' est utilisé pour lire les données stockées dans le fichier.

L'exemple inclut les principaux fichiers d'en-tête au début. Ensuite, utilisez 'ifstream' à l'intérieur du principale() fonction. Avec l'aide de 'ifstream', nous lirons les données avec le fichier 'New_File' montrant le texte stocké dans le fichier texte 'exemple'. Nous employons le ouvert() méthode pour ouvrir le fichier. Ensuite, nous utiliserons la boucle 'while'. Après avoir lu les données du fichier texte « exemple », le proche() La fonction est utilisée pour fermer le fichier requis. Si le système n'a pas le fichier particulier, nous obtenons le message 'Impossible d'ouvrir le fichier'.

Toutes les informations stockées dans le fichier texte sont affichées à l'écran comme indiqué.

Conclusion

Dans le guide ci-dessus, nous avons appris en détail le langage C++. En plus des exemples, chaque sujet est démontré et expliqué, et chaque action est élaborée.