Std futur C ++

Aujourd'hui, nous allons en apprendre davantage sur l'un des fichiers d'en-tête importants du langage de programmation C ++ qui est la bibliothèque «future». Pour éviter la confusion lors de l'apprentissage du concept du futur fichier d'en-tête, passons brièvement la langue C ++ avant de passer au sujet principal. La signification des fichiers d'en-tête et la justification de leur utilisation dans le langage de codage C ++ seront également discutées.

Le langage de codage C est le prédécesseur de C++. De plus, nous pourrions dire qu'il s'agit d'une forme améliorée de C qui est fondée sur le principe de la programmation orientée objet (POO). Lors de l'écriture d'un programme dans le langage de programmation C ++, nous utilisons des fichiers d'en-tête standard, des classes, des fonctions, etc. Ceux-ci nous évitent d'avoir à écrire de nombreuses lignes de code. À l'aide de quelques mots clés de réserve, nous ajoutons simplement le fichier d'en-tête.

Introduction

Dans les programmes C ++, nous devons inclure au moins une bibliothèque qui est la majorité des programmes C ++ qui nécessitent les méthodes CIN () et cout () afin que nous acceptions les données de l'utilisateur et de nombreux autres codes pré-écrits qui rendent le code plus lisible. Pour accéder à ces fonctions, vous devez avoir un fichier d'en-tête. La bibliothèque «future» est utilisée pour créer des modèles de classe et des modèles associés qui facilitent l'exécution d'une méthode qui pourrait avoir été dans un thread différent et récupérer ses résultats. Le résultat est soit le nombre que la méthode renvoie, soit une exception que la méthode génère mais ne capte pas.

Pour mieux comprendre la future approche du fichier d'en-tête, examinons le futur package pour voir comment cette bibliothèque est utilisée et implémentée dans le langage de programmation C ++, en plus des fonctions associées du futur module.

Syntaxe:

C'est ainsi que le fichier d'en-tête d'un programme C ++ à l'aide de la balise "#include future>" doit être écrit. Commençons maintenant à comprendre le style de mise en œuvre et d'écriture de la future bibliothèque. La directive de préprocesseur «#include» du langage de programmation C ++ est écrite de la manière suivante. En les qualifiant d'instructions de préprocesseur, le préprocesseur examine le programme de directives spécifiques qu'il peut comprendre. Chaque directive de préprocesseur commence par le symbole # (hash).

Le préprocesseur effectue d'abord des actions préliminaires comme exécuter implicitement le code, y compris les fichiers liés au programme, etc. Avant que le traducteur ne rencontre le programme. Un avenir est une représentation des résultats d'une opération asynchrone qui ne pouvait pas encore être accessible. Une fois les calculs terminés, l'avenir peut contenir une valeur ou il peut afficher une erreur.

Exemple:

Pour comprendre le concept des futurs fichiers d'en-tête, nous implémenterons les futures bibliothèques et discuterons également d'autres bibliothèques et fonctions que nous allons utiliser. Nous allons maintenant créer un exemple du futur fichier d'en-tête dans le langage de programmation C ++.

Pour ce faire, nous utilisons d'abord une version C ++ 11 ou supérieure ou plus du compilateur qui prend en charge la future bibliothèque. La future bibliothèque ne fonctionnera pas correctement sur le compilateur en ligne si vous n'avez pas le compilateur C ++ 11 ou supérieur, vous devez donc l'installer. Commencez à écrire le programme d'exemples que nous souhaitons implémenter après l'installation et le démarrage du compilateur. Pour s'assurer que les actions du programme, qui signifient les classes, les objets, les fonctions, etc., fonctionnent correctement dans le programme, les fichiers d'en-tête doivent toujours être inclus dans les programmes C ++.

Les méthodes que nous avons implémentées dans le programme n'auraient pas fonctionné sans les fichiers d'en-tête. La WWE n'aurait même pas vu le résultat sur le panneau utilisateur. Lorsque nous inclurons n'importe quel fichier d'en-tête, nous écrivons d'abord le symbole «#» qui indique au compilateur que nous ajoutons la bibliothèque au programme existant. Le nom du fichier d'en-tête que nous souhaitons ajouter au programme sera écrit après le mot clé C ++ réservé «Inclure», qui est utilisé pour inclure le fichier d'en-tête, et ensuite, nous écrivons le nom de la bibliothèque «iOStream».

L'iOStream signifie que nous pouvons obtenir la contribution de l'utilisateur en utilisant la méthode CIN () et nous pouvons également afficher les résultats en utilisant la méthode Cout (). Ensuite, ajoutera un autre fichier d'en-tête qui est «#include dans le programme car le fichier d'en-tête de thread contient des définitions des classes de threads que nous implémenterons dans la fonction principale () et les fonctionnalités associées.

Dans le langage de programmation C ++, un seul thread est représenté par la classe de threads en utilisant le thread STD ::. Maintenant, nous inclurons un en-tête de plus qui est «#include Library. Nous pouvons utiliser cette bibliothèque à plusieurs fins du programme comme lorsque nous voulons prendre en charge le threading dans le programme et il attend également une fonction prédéterminée asynchrone qui exécute la fonction de manière asynchrone et donne l'avenir de la valeur de la fonction.

#inclure
#inclure
#inclure
Utilisation de Namespace Std;

De plus, nous ajouterons une autre instruction «à l'aide de Namespace STD», qui est utilisée pour spécifier la portée du programme. Il est simplement dit, cela nous empêche de déclarer des objets, des méthodes et des arguments dans l'ensemble du programme existant avec des références à la même portée.

Ensuite, nous implémenterons une fonction asynchrone globale pour obtenir l'ID de la bande de roulement. Tout d'abord, nous rédigerons le type de retour de la fonction qui est un entier. Ensuite, nous écrire le nom de la fonction que nous avons déclaré id «asyncfunc». Ensuite, dans les supports de fonction, nous avons passé le type de données et la variable. Dans la fonction asyncfunc (), nous avons imprimé l'ID du thread en utilisant la méthode cout (). Dans la ligne 10, nous avons renvoyé la valeur à la variable «valeur» que nous avons déclarée dans les supports de fonction asyncfun ().

int asyncfunc (Int Value)

couter << "Asynchronous Thread: " << this_thread::get_id() << endl;
Retour "La valeur est:", valeur + 200;

En termes d'écriture, les extraits de code pour le scénario que nous mettons en œuvre, nous appellerons ensuite la méthode principale (). Le type de retour de la fonction Main (), "int", sera écrit en premier, suivi du nom de la fonction, qui est la fonction principale (), lors de l'appel de la fonction. Ensuite, commencez à créer le code en ouvrant les supports de la fonction.

Dans la ligne suivante, nous allons imprimer l'ID principal de la bande de roulement en écrivant "this_thread :: get_id ()" et en le faisant passer dans la méthode cout (). Ensuite, nous créerons la classe future en écrivant le mot-clé réservé «futur» et en passant le type entier et le nom de la classe est «FUT». Ensuite, la fonction asyncfunc () renvoie le futur objet. Ensuite, nous avons utilisé l'instruction IF pour vérifier si le futur «FUT» est valide et si la condition est valide, nous imprimerons le futur objet en utilisant la méthode Cout (). Ensuite, nous avons utilisé la déclaration IF-Else pour vérifier la validité du futur. S'il est valide, il compilera le «FUT.instruction get () ”et si ce n'est pas le cas, il imprimera le message« non valide.

int main()

couter <<"Main Thread: "<< this_thread::get_id() << endl;
Future FUT = Async (Launch :: Async, AsyncFunc, 400);
if (fut.valide())

couter << fut.get()<
if (fut.valide())

fut.obtenir();

autre

couter<<"Invalid" <
retour 0;

Pour informer le compilateur pour arrêter d'exécuter le programme et afficher la sortie sur l'écran, ainsi que pour afficher l'écran d'erreur s'il y en a, nous retournerons 0 à la méthode principale () à la fin du programme.

Voici la sortie du programme compilé ci-dessus:

Conclusion

Dans cet article, nous avons appris le futur fichier d'en-tête. Nous avons appris pourquoi nous utilisons les futurs fichiers d'en-tête et comment nous les implémenterons en apprenant la syntaxe du futur. Nous avons mis en œuvre un exemple de l'avenir avec une explication détaillée de chaque ligne de code afin que la confusion soit laissée dans l'esprit des utilisateurs.