Criando suas próprias UDLs em C ++ - dummies

A Biblioteca Padrão, juntamente com os recursos internos de C ++, fornecem uma variedade interessante de literais. No entanto, o verdadeiro valor dos literais torna-se mais óbvio quando você cria o seu próprio.

Existem muitas necessidades diferentes que você pode abordar usando literais definidos pelo usuário (UDLs), mas três necessidades comuns são suportar conversões de dados, tornando os tipos personalizados mais fáceis de trabalhar e obtendo os efeitos colaterais desejados sem o número usual de problemas de codificação.

Embora os literais integrados ou de biblioteca padrão venham em formato de prefixo e sufixo, você só pode criar o formulário de sufixo ao definir seus próprios literais. Além disso, o sufixo deve começar com um sublinhado. O sublinhado serve para ajudar a evitar conflitos com sufixos existentes e para garantir que outros desenvolvedores saibam que o literal é uma forma personalizada (não padronizada).

Desenvolvendo uma UDL de conversão

É possível encapsular conversões dentro de uma UDL. Tudo o que você precisa fazer uma vez que você cria uma UDL é fornecer o sufixo apropriado ao definir a constante para obter o resultado desejado. O exemplo CustomUDL01 demonstra uma técnica para definir uma conversão que altera a entrada do raio para a área de um círculo na constante.

#include usando namespace std; constexpr long double operator "_circ (radio duplo longo) {raio de retorno * raio * 3. 141592;} int main () {double x = 5. 0_circ; cout <<" a área do círculo é: "<< x << endl; return 0;}

Para criar a UDL, o exemplo depende de um constexpr com um valor de retorno de um duplo longo e um valor de entrada, raio, de um duplo longo. A equação para calcular a área de um círculo é πr ² . Como você pode ver, o exemplo executa a computação correta como parte do constexpr.

Sempre que você cria uma UDL personalizada, o compilador obriga você a usar o maior tipo de conversão. O que isso significa é que você deve usar um duplo longo para literais de ponto flutuante e não assinado por muito tempo para literais inteiros. Mesmo que depois escolha usar um tipo menor, como é feito neste exemplo, declarando x como um duplo, o próprio literal deve empregar o maior tipo possível.

Para declarar uma UDL do novo tipo, o exemplo cria x, que usa o sufixo _circ. Ele então é exibido s o resultado na tela. Quando você executa este exemplo, você verá que o valor correto foi colocado em x, como mostrado aqui:

A área do círculo é: 78. 5398

Desenvolvendo um tipo personalizado UDL

Um monte de código você O encontro confia em tipos personalizados que são difíceis de seguir e entender.Criar uma UDL para simplificar o código torna as coisas mais claras e reduz o potencial de erro. O exemplo CustomUDL02 mostra um tipo personalizado, o operador usado para criar o UDL, bem como a forma como o UDL é usado para definir um literal.

#include usando namespace std; struct MyType {MyType (entrada dupla): Value (Input) {} double Value;}; Operador MyType "_mytype (valor duplo longo) {return MyType (Value);} int main () {auto UDLType = 145. 6_mytype; cout << uDLType. Valor << endl; return 0;}

Para isso técnica para trabalhar, você deve criar um construtor para o seu tipo que aceite o número de entradas necessárias para configurar o tipo. No mínimo, o construtor deve aceitar um tipo ou o valor de entrada que o usuário fornece é perdido.

O tipo personalizado precisa não suporta o mesmo tipo de dados de tamanho exigido pelo operador, mas eles devem ser do mesmo tipo. Por exemplo, você não pode fazer uma transição de um duplo longo para um int.

Quando você executa este exemplo, você verá uma saída valor de 145. 6, que é o valor que você insere para o tipo personalizado. É possível gerenciar configurações bastante complexas usando esta abordagem. O usuário do seu tipo personalizado obtém a capacidade de criar um código claro que é fácil de seguir e interpretar, mesmo quando os tipos subjacentes são complexos.

Usando um UDL personalizado para efeitos secundários

Um dos mais interessantes você ses para UDLs é criar efeitos colaterais (uma operação diferente da operação normal ou normal, seja para tornar o aplicativo mais curto e mais eficiente ou para proporcionar maior flexibilidade). Você deseja definir um certo tipo de operação que ocorre como resultado da definição do literal.

O que você obtém é ainda um literal, mas um literal que não indica necessariamente um valor que você planeja usar mais tarde. O exemplo CustomUDL03 mostra um uso não tradicional.

#include usando namespace std; operador vazio "_countdown (valor longo não assinado) {for (int i = Valor; i> = 0; i--) cout << i << endl;} int main () {10_countdown; return 0;}

Observe que o operador _countdown não está vinculado a algo que você normalmente associaria a um valor. Na verdade, ele não retorna um valor. O que você obtém é um efeito colateral. Ao executar este exemplo, você veja esta saída.

10 9 8 7 6 5 4 3 2 1 0

O que aconteceu foi que o compilador substituiu 10_countdown por instruções de cout individuais, uma para cada iteração do loop. O que você acaba é 11 instruções de cout que produzem os valores entre 10 e 0 (na ordem inversa). O efeito secundário UDL abre todos os tipos de possibilidades interessantes para a criação de código que simplifica determinadas tarefas repetitivas de uma maneira que torna seu uso óbvio.