Création de vos propres UDL en C ++ - mannequins

de C ++, vous fournir un tableau intéressant de littéraux. Cependant, la valeur réelle des littéraux devient plus évidente lorsque vous créez le vôtre.

Vous pouvez répondre à de nombreux besoins en utilisant des littéraux définis par l'utilisateur (UDL), mais trois besoins courants sont la prise en charge des conversions de données, le traitement des types personnalisés et l'obtention des effets secondaires souhaités sans le nombre habituel de problèmes de codage.

Bien que les littéraux de bibliothèque standard ou standard soient fournis sous forme de préfixe et de suffixe, vous pouvez uniquement créer le formulaire de suffixe lorsque vous définissez vos propres littéraux. En outre, le suffixe doit commencer par un trait de soulignement. Le soulignement permet d'éviter les conflits avec les suffixes existants et de s'assurer que les autres développeurs savent que le littéral est un formulaire personnalisé (non standard).

Développer une conversion UDL

Il est possible d'encapsuler des conversions dans une UDL. Tout ce que vous devez faire une fois que vous créez une telle UDL est de fournir le suffixe approprié lors de la définition de la constante pour obtenir le résultat souhaité. L'exemple CustomUDL01 illustre une technique pour définir une conversion qui modifie l'entrée de rayon à l'aire d'un cercle dans la constante.

#include utilisant l'espace de noms std; constexpr long double opérateur "_circ (long rayon double) {rayon de retour * rayon * 3. 141592;} int main () {double x = 5. 0_circ; cout <<" la zone du cercle est: "<< x << endl; return 0;}

Pour créer l'UDL, l'exemple repose sur un constexpr avec une valeur de retour d'un double long et une valeur d'entrée, radius, d'un double long. est πr ² Comme vous pouvez le voir, l'exemple effectue le calcul correct dans le cadre du constexpr

Chaque fois que vous créez une UDL personnalisée, le compilateur Cela signifie que vous devez utiliser un double long pour les littéraux en virgule flottante et long pour les littéraux entiers, même si vous choisissez plus tard d'utiliser un type plus petit, comme c'est le cas ici. Par exemple, en déclarant x comme un double, le littéral lui-même doit utiliser le plus grand type possible

Pour déclarer une UDL du nouveau type, l'exemple crée x, qui utilise le suffixe _circ. s le résultat à l'écran. Lorsque vous exécutez cet exemple, vous voyez que la valeur correcte a été placée dans x, comme indiqué ici:

La zone du cercle est: 78. 5398

Développement d'un type personnalisé UDL

Une grande partie du code La rencontre repose sur des types personnalisés difficiles à suivre et à comprendre.Créer une UDL pour simplifier le code rend les choses plus claires et réduit le risque d'erreur. L'exemple CustomUDL02 montre un type personnalisé, l'opérateur utilisé pour créer la bibliothèque UDL, ainsi que la façon dont la bibliothèque UDL est utilisée pour définir un littéral.

#include utilisant l'espace de noms std; struct MyType {MyType (double entrée): Valeur (Entrée) {} double Valeur;}; Opérateur MyType "_mytype (long double Valeur) {return MyType (Valeur);} int main () {auto UDLType = 145. 6_mytype; cout << uDLType. Valeur << endl; return 0;}

Pour cela technique pour fonctionner, vous devez créer un constructeur pour votre type qui accepte le nombre d'entrées requis pour configurer le type Au minimum, le constructeur doit accepter un type ou la valeur d'entrée fournie par l'utilisateur est perdue.

Le type personnalisé a besoin ne prend pas en charge le type de données de même taille requis par l'opérateur, mais doit être du même type Par exemple, vous ne pouvez pas convertir un double long en int.

Lorsque vous exécutez cet exemple, vous voyez une sortie La valeur de 145. 6, qui est la valeur que vous entrez dans le type personnalisé, permet de gérer des configurations assez complexes en utilisant cette approche.L'utilisateur de votre type personnalisé obtient la possibilité de créer un code clair facile à suivre et à interpréter, même lorsque les types sous-jacents sont complexes.

Utiliser un UDL personnalisé pour les effets secondaires

L'un des plus intéressants pour les UDL, créer des effets secondaires (une opération autre que l'opération habituelle ou normale, soit pour rendre l'application plus courte et plus efficace, soit pour offrir une flexibilité supplémentaire). Vous voulez définir un certain type d'opération qui a lieu à la suite de la définition du littéral.

Ce que vous obtenez est toujours un littéral, mais un littéral qui ne dénote pas nécessairement une valeur que vous prévoyez d'utiliser plus tard. L'exemple CustomUDL03 montre une telle utilisation non traditionnelle.

#include utilisant l'espace de noms std; opérateur vide "_countdown (long long non signé) {for (int i = Valeur; i> = 0; i--) cout << i << endl;} int main () {10_countdown; return 0;}

Notez que l'opérateur _countdown n'est pas attaché à quelque chose que vous associeriez normalement à une valeur, en fait, il ne renvoie aucune valeur, ce que vous obtenez à la place est un effet secondaire. voir cette sortie

10 9 8 7 6 5 4 3 2 1 0

Ce qui est arrivé, c'est que le compilateur a remplacé 10_countdown par des instructions personnalisées, une pour chaque itération de la boucle. 11 instructions cout qui affichent les valeurs entre 10 et 0. L'effet secondaire UDL ouvre toutes sortes de possibilités intéressantes pour créer du code qui simplifie certaines tâches répétitives d'une manière qui rend leur utilisation évidente.