Programação D - Literais

Os valores constantes digitados no programa como parte do código-fonte são chamados literals.

Literais podem ser de qualquer um dos tipos de dados básicos e podem ser divididos em números inteiros, números de ponto flutuante, caracteres, strings e valores booleanos.

Novamente, os literais são tratados como variáveis regulares, exceto que seus valores não podem ser modificados após sua definição.

Literais inteiros

Um literal inteiro pode ser um dos seguintes tipos -

Decimal usa a representação do número normal com o primeiro dígito não pode ser 0, pois esse dígito é reservado para indicar o sistema octal. Isso não inclui 0 por si só: 0 é zero.
Octal usa 0 como prefixo do número.
Binary usa 0b ou 0B como prefixo.
Hexadecimal usa 0x ou 0X como prefixo.

Um literal inteiro também pode ter um sufixo que é uma combinação de U e L, para sem sinal e longo, respectivamente. O sufixo pode ser maiúsculo ou minúsculo e pode estar em qualquer ordem.

Quando você não usa um sufixo, o próprio compilador escolhe entre int, uint, long e ulong com base na magnitude do valor.

Aqui estão alguns exemplos de literais inteiros -

212         // Legal 
215u        // Legal 
0xFeeL      // Legal 
078         // Illegal: 8 is not an octal digit 
032UU       // Illegal: cannot repeat a suffix

A seguir estão outros exemplos de vários tipos de literais inteiros -

85         // decimal 
0213       // octal
0x4b       // hexadecimal 
30         // int 
30u        // unsigned int 
30l        // long 
30ul       // unsigned long 
0b001      // binary

Literais de ponto flutuante

Os literais de ponto flutuante podem ser especificados no sistema decimal como em 1.568 ou no sistema hexadecimal como em 0x91.bc.

No sistema decimal, um expoente pode ser representado adicionando o caractere e ou E e um número depois disso. Por exemplo, 2,3e4 significa "2,3 vezes 10 elevado à potência de 4". Um caractere “+” pode ser especificado antes do valor do expoente, mas não tem efeito. Por exemplo, 2.3e4 e 2.3e + 4 são iguais.

O caractere “-” adicionado antes do valor do expoente muda o significado para ser "dividido por 10 à potência de". Por exemplo, 2,3e-2 significa "2,3 dividido por 10 elevado a 2".

No sistema hexadecimal, o valor começa com 0x ou 0X. O expoente é especificado por p ou P em vez de e ou E. O expoente não significa "10 à potência de", mas "2 à potência de". Por exemplo, o P4 em 0xabc.defP4 significa "abc.de vezes 2 elevado a 4".

Aqui estão alguns exemplos de literais de ponto flutuante -

3.14159       // Legal 
314159E-5L    // Legal 
510E          // Illegal: incomplete exponent 
210f          // Illegal: no decimal or exponent 
.e55          // Illegal: missing integer or fraction 
0xabc.defP4   // Legal Hexa decimal with exponent 
0xabc.defe4   // Legal Hexa decimal without exponent.

Por padrão, o tipo de literal de ponto flutuante é duplo. F e F significam float, e o especificador L significa real.

Literais booleanos

Existem dois literais booleanos e eles fazem parte das palavras-chave D padrão -

Um valor de true representando verdadeiro.
Um valor de false representando falso.

Você não deve considerar o valor de verdadeiro igual a 1 e o valor de falso igual a 0.

Literais de caracteres

Literais de caracteres são colocados entre aspas simples.

Um literal de caractere pode ser um caractere simples (por exemplo, 'x'), uma sequência de escape (por exemplo, '\ t'), um caractere ASCII (por exemplo, '\ x21'), um caractere Unicode (por exemplo, '\ u011e') ou como caractere nomeado (por exemplo, '\ ©', '\ ♥', '\ €').

Existem certos caracteres em D quando são precedidos por uma barra invertida, eles têm um significado especial e são usados para representar como nova linha (\ n) ou tabulação (\ t). Aqui, você tem uma lista de alguns desses códigos de sequência de escape -

Sequência de fuga	Significado
\\	\ personagem
\ '	' personagem
\ "	" personagem
\?	? personagem
\uma	Alerta ou sino
\ b	Backspace
\ f	Feed de formulário
\ n	Nova linha
\ r	Retorno de carruagem
\ t	Aba horizontal
\ v	Guia vertical

O exemplo a seguir mostra alguns caracteres de sequência de escape -

import std.stdio;
  
int main(string[] args) { 
   writefln("Hello\tWorld%c\n",'\x21'); 
   writefln("Have a good day%c",'\x21'); 
   return 0; 
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Hello   World!

Have a good day!

Literais de string

Literais de string são colocados entre aspas duplas. Uma string contém caracteres semelhantes aos literais de caracteres: caracteres simples, sequências de escape e caracteres universais.

Você pode quebrar uma linha longa em várias linhas usando literais de string e separá-los usando espaços em branco.

Aqui estão alguns exemplos de literais de string -

import std.stdio;

int main(string[] args) {
   writeln(q"MY_DELIMITER
      Hello World
      Have a good day
      MY_DELIMITER");

   writefln("Have a good day%c",'\x21'); 
   auto str = q{int value = 20; ++value;}; 
   writeln(str); 
}

No exemplo acima, você pode encontrar o uso de q "MY_DELIMITER MY_DELIMITER" para representar caracteres de várias linhas. Além disso, você pode ver q {} para representar a própria instrução da linguagem D.

↰ Previous page Next page ↱