Décltype C ++

«L'inférence du type est la détermination automatique du type de données d'une instruction dans un langage informatique. Les valeurs possibles d'une expression au moment de l'exécution ont été limitées par la déclaration manuelle de chaque type de données avant C ++ 11. Si nous pouvons utiliser l'inférence de type, nous pouvons écrire moins de code pour exprimer quelque chose que le compilateur comprend déjà. Bien que le temps de compilation augmente considérablement car tous les types ne sont déterminés que pendant la phase du compilateur, le temps d'exécution du programme n'est pas affecté. Ici, nous discuterons du Dectype de mot-clé C ++ et de ses fonctionnalités."

Qu'est-ce que les déclarations en C++

Il examine le type indiqué d'une entité ou d'une expression. Decltype est une sorte d'opérateur qui examine le type d'expression donnée, par opposition à «l'auto», qui vous permet de définir une variable avec un certain type mais vous permet de récupérer le type de la variable. Les informations de type sont fournies par Decltype pendant la compilation et par typeid pendant l'exécution. En conséquence, si un objet d'une classe dérivée a une référence de classe de base ou un pointeur le pointant, TypeID fournira la référence ou le pointeur de type dérivé plutôt que le type, qui sera fourni par Decltype.

Lorsqu'il est nécessaire de connaître le type dynamique d'un objet, l'opérateur typeid est utilisé. Cependant, le nom réel qui est renvoyé est un peu dépendant du compilateur.

La syntaxe générale C ++ prévoit des déclarations est la suivante:

Syntaxe:

Decltype (Expression)

Le déclarant ne prend qu'un seul paramètre, qui est une expression. Le déclarant renvoie le type du paramètre d'expression. En utilisant les directives suivantes, le compilateur dépend du type de paramètre d'expression.

• Lorsque le paramètre d'expression est un accès à un membre de classe ou à un identifiant, le type de l'objet identifié par l'expression est Decltype (expression). Si un tel objet n'existe pas ou si l'argument d'expression spécifie un groupe de fonctions surchargées, le compilateur émet un message d'erreur.
• Si l'expression d'entrée appelle une méthode ou une fonction d'opérateur avec de nombreuses surcharges, le type de retour d'une fonction donnée est Decltype (expression).

Exemple 1

L'implémentation de la discussion ci-dessus est donnée par le code Decltype. Depuis plus d'une variable, une fonction, une classe, etc., ne peut pas avoir le même nom dans la portée identique. L'espace de noms est donc introduit pour résoudre ce problème. Après cela, nous avons établi la fonction «my_func1» qui renvoie la valeur entière «5» car nous avons initialement spécifié le type de données int à la fonction «my_func1».

Encore une fois, nous avons établi une fonction comme «MY_FUNC2» et lui avons attribué un type de données de charbon à lui. Cette fonction renvoie la valeur du caractère «i». Ensuite, nous avons construit l'INT MAIN () du programme, où nous avons déployé le modificateur Decltype. Le modificateur Decltype prend respectivement le «my_func1» et «my_func2» comme argument,. Pour les déclarations, nous avons également défini les deux variables comme «A» et «B».

Les variables «A» et «B» ont les mêmes types de données que le type de retour de «my_func1» et «my_func2». Ensuite, nous avons une instruction COUT où le typeid prend les variables «A» et «B» comme entrée et renverra le type de ces variables.

#inclure
Utilisation de Namespace Std;
int my_func1 () return 5;
char my_func2 () return 'l';
int main()

DecType (my_func1 ()) a;
DecType (my_func2 ()) b;
couter<couter<retour 0;

Comme le type de «my_func1» est int et «my_func2» est char. Ainsi, dans la sortie, le type «I» et «C» est renvoyé, ce qui indique le type INT et CHAR.

Exemple 2

Une illustration supplémentaire de l'utilisation des déclarations est fournie ci-dessous, ce qui est légèrement différent du précédent. Nous avons directement construit le principal () de ce programme particulier après la section d'en-tête. À l'intérieur de l'int main () du programme, nous avons déclaré la variable «num» et lui avons attribué un nombre «10». Ensuite, nous avons appelé le modificateur de déclarations, qui prend la variable «num» comme paramètre. Avec le modificateur de déclarations, nous avons également défini la variable «i» qui a le type int identique au type de la variable «num».

Ensuite, nous avons ajouté le num et le numéro «10» en utilisant l'opérateur plus à l'intérieur de la variable «i». Après cela, nous avons une commande cout où le typeid est invoqué qui prend la variable «i» comme entrée et fournit son type.

#inclure
Utilisation de Namespace Std;
int main()

int num = 10;
DecType (num) i = num + 10;
couter<< "decltype : " <retour 0;

Comme nous fournissons le type int à la variable «num» dans l'extrait de code ci-dessus. La sortie affiche le mot «i» qui est la valeur de type int de la variable «num».

Exemple 3

Les nombres minimums sont renvoyés par la méthode du modèle C ++ Min Type (), qui est visible ci-dessous. Tout type intégral peut être utilisé pour les deux nombres. Le type minimal de deux est utilisé pour déterminer le type de retour.

Avec le modificateur automatique, nous avons créé la fonction SearchMin () et passé les variables x et y comme paramètre à l'intérieur. Ensuite, nous avons attribué les noms de variable au mot clé Decltype. Le déclarant prend la variable avec l'expression conditionnelle. La fonction recherche la valeur minimale et renvoie le type de variable qui a la valeur minimale. Ensuite, dans l'INT Main (), nous avons transmis la valeur à la fonction SeatChmin via la commande cout.

#inclure
Utilisation de Namespace Std;
modèle
Auto Searchmin (T1 X, T2 Y) -> DecType (x < y ? x : y)

retour (x < y) ? x: y;

int main()

couter<couter<retour 0;

La sortie a affiché les valeurs minimales ci-dessous. Comme à partir de la première déclaration de recherche, 4.55 est retourné du double type. Ensuite, la deuxième déclaration, 2, est obtenue à partir du type de données int.

Conclusion

C'est tout au sujet des déclarations C ++. Nous l'avons discuté brièvement avec la définition, sa syntaxe et sa fonctionnalité dans cet article particulier. Ici, nous avons montré le déclarant travaillant avec l'exemple de code en cours d'exécution en C++. Toutes les instances sont distinctes les unes des autres. Les cas diffèrent tous les uns des autres. Le script Dectype avec le préfixe automatique est démontré dans le dernier exemple. Le mot-clé de déduction de type automatique, Auto, est utilisé dans C ++ 11 et au-delà.