Créer vos propres UDLs en C ++

La bibliothèque standard, couplé avec les fonctionnalités intégrées de C ++, vous fournir un éventail intéressant de littéraux. Cependant, la vraie valeur de littéraux devient plus évident lorsque vous créez votre propre.

Il ya beaucoup de besoins différents, vous pouvez répondre en utilisant littéraux définis par l'utilisateur (UDLS), mais trois besoins communs soutiennent les conversions de données, ce qui rend les types personnalisés facile de travailler avec, et l'obtention d'effets secondaires souhaités sans le nombre habituel de problèmes de codage.

Bien-intégré ou littéraux bibliothèque standard viennent dans deux préfixe et le suffixe formulaire, vous ne pouvez créer la forme de suffixe lors de la définition de vos propres littéraux. En outre, le suffixe doit commencer par un trait de soulignement. Le trait de soulignement sert à aider à prévenir les conflits avec des suffixes existants et d'assurer d'autres développeurs savent que le littéral est une forme personnalisée (non standard).

Développer une conversion UDL

Il est possible d'encapsuler les conversions au sein d'un UDL. Tout ce que vous devez faire une fois que vous créez un tel UDL est de fournir le suffixe approprié lors de la définition de la constante pour obtenir le résultat que vous voulez. La CustomUDL01 exemple illustre une technique pour définir une transformation qui modifie le rayon de l'entrée à la surface d'un cercle à la constante.

#comprendre using namespace std-constexpr long double opérateur "" _circ (long double rayon) {return rayon * rayon * 3.141592-} int main () {double x = 5.0_circ-cout lt; lt; «La superficie du cercle est:" lt; lt; X lt; lt; endl-retour 0-}

Afin de créer la UDL, l'exemple repose sur une constexpr avec une valeur de retour d'une long double et une valeur d'entrée, rayon, d'un long double. L'équation pour le calcul de l'aire d'un cercle est # 960-r². Comme vous pouvez le voir, l'exemple effectue le bon calcul dans le cadre du constexpr.

Lorsque vous créez une coutume UDL, le compilateur vous oblige à utiliser le plus grand type pour la conversion. Ce que cela signifie est que vous devez utiliser un long double à virgule flottante littéraux et unsigned long long pour les littéraux entiers. Même si vous choisissez plus tard, d'utiliser un type plus petit, comme on le fait dans cet exemple en déclarant X comme un double, le littéral se doit employer le plus grand type possible.

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

La superficie du cercle est: 78,5398

Développer un type personnalisé UDL

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

#comprendre using namespace std-struct MyType {MyType (à double entrée): Valeur (Entrée) {} valeur double -} - opérateur MyType "" de _mytype (long double de la valeur) {return MyType (Value) -} int main () {auto UDLType = 145.6_mytype-cout lt; lt; UDLType.Value lt; lt; endl-retour 0-}

Pour que cette technique fonctionne, vous devez créer un constructeur pour le type qui accepte le nombre d'entrées nécessaires pour configurer le type. Au minimum, le constructeur doit accepter un type ou la valeur d'entrée l'utilisateur fournit est perdu.

Le type de mesure ne doit pas soutenir le même type de données de taille tel que requis par l'opérateur, mais ils doivent être de la même sorte. Par exemple, vous ne pouviez pas passer une long double à un int.

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

En utilisant une coutume UDL pour les effets secondaires

L'une des utilisations les plus intéressantes pour UDLs est de créer effets secondaires (une opération autre que le fonctionnement habituel ou normal, soit de rendre l'application plus court et plus efficace ou pour fournir une flexibilité supplémentaire). Vous souhaitez 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 représentent pas nécessairement une valeur que vous prévoyez d'utiliser plus tard. La CustomUDL03 exemple montre un tel usage non traditionnel.

#comprendre using namespace std-vide opérateur "" _countdown (unsigned long long valeur) {for (int i = Value- i> = 0- i -) cout lt; lt; je lt; lt; endl-} int main () {10_countdown-retour 0-}

Notez que le _countdown opérateur ne soit pas attaché à quelque chose que vous auriez normalement associer à une valeur. En fait, il ne retourne pas de valeur du tout. Qu'est-ce que vous obtenez à la place est un effet secondaire. Lorsque vous exécutez cet exemple, vous voyez cette sortie.

109876543210

Ce qui est arrivé est que le compilateur a remplacé 10_countdown avec personne cout états, une pour chaque itération de la boucle. Qu'est-ce que vous vous retrouvez avec est 11 cout déclarations que la production des valeurs entre 0 et 10 (dans l'ordre inverse). L'effet secondaire le UDL ouvre toutes sortes de possibilités intéressantes pour la création de code qui simplifie certaines tâches répétitives d'une manière qui rend leur utilisation évidente.