Este tópico aborda literais
e a importância de se entender e usar corretamente este
recurso, presente em praticamente todas as linguagens de programação.
Cabe, no entanto, uma observação. Você não
precisa, obrigatoriamente, ler o conteúdo deste tópico
antes de prosseguir com o estudo das demais partes. Mas, caso
o faça, é importante escrever e compilar alguns
exemplos a fim de entender o funcionamento de cada literal apresentado
e observar o comportamento do compilador C# em algumas situações
que passariam despercebidas aos olhos dos iniciantes em programação.
Um literal é um valor que definimos
quando escrevemos nosso código, ou seja, é o oposto
de um valor que poderia ser calculado e atribuído a uma
variável em tempo de execução. Desta forma,
estivemos usando literais na maioria dos exemplos apresentados
até este momento. Observe o seguinte trecho de código:
bool aprovado = true;
Aqui true é um literal do tipo bool
(boolean) sendo atribuído à variável
aprovado. Outro exemplo de literal poderia ser um literal string,
mostrado a seguir:
string
site;
site = "Arquivo de Códigos";
Lembre-se de que um literal string pode conter seqüências
de escape (ilustradas mais adiante neste tópico). Desta
forma, podemos causar uma quebra de linha em uma string de forma
bem fácil. Veja um exemplo:
string
frase = "Número 1\nNúmero 2";
A saída deste exemplo será:
Número
1
Número 2
Como podemos ver, uma quebra é causada pela inserção
da seqüência "\n" no ponto onde desejamos
que a quebra de linha ocorra.
Quando falamos de literais do tipo boolean e string, tudo é
muito simples e sob controle. A atenção deve ser
redobrada quando estamos lidando com literais integrais
e de ponto-flutuante. Comecemos com os literais
integrais. Primeiramente veja o que acontece quando tentamos
atribuir um valor maior que aquele permitido a um determinado
tipo de dados:
byte
valor = 400;
Ora, como sabemos que o máximo valor que pode ser armazenado
em uma variável do tipo byte é 255, é de
se esperar que esta definição fosse rejeitada
pelo compilador, uma vez que o literal 400 é no mínimo
do tipo short. E é isso que acontece. Veja a mensagem
de erro de compilação que nos é exibida:
Numero.cs(7,18):
error CS0031: Constant value '400' cannot be converted to a
'byte'
Existem algumas regras bem fáceis de serem entendidas
quando estamos lidando com literais integrais. Vamos a elas:
1) Literais integrais podem ser definidos
em dois tipos de sistemas de numeração: decimal
e hexadecimal. Para definir um literal integral em hexadecimal,
seu valor deverá ser precedido pela seqüência
"0x". Veja um exemplo:
int
valor = 0x43;
Ao exibirmos o valor da variável usando a forma que já
conhecemos, veremos que o valor exibido é 67, ou seja,
o valor hexadecimal é convertido para decimal antes de
ser exibido. Nos próximos capítulos você
aprenderá como exibir valores de variáveis em
hexadecimal usando as opções de formatação
de string.
2) Se o valor do literal
for maior que aquele suportado pelo tipo de dados da variável
a qual este valor será atribuído, um erro de compilação
ocorrerá. O maior valor definido para um literal integral
não poderá ser superior ao maior valor suportado
pelo tipo ulong.
3)
Se o literal não possui sufixo, ele será do primeiro
tipo que suportar seu valor, seguindo a ordem: int,
uint, long, ulong.
4) Se o literal possui o sufixo U ou
u, ele será do primeiro tipo que suportar seu valor,
seguindo a ordem: uint, ulong.
Lembre-se de que os sufixos U ou u são usados para definir
um literal integral sem sinal. Veja um exemplo:
uint
valor = 143U;
5) Se o literal
possui o sufixo L ou l (letra "L" minúscula),
ele será do primeiro tipo que suportar seu valor, seguindo
a ordem: long, ulong. Para
facilitar a leitura do sufixo, encorajamos o uso apenas do sufixo
L (a letra "L" minúscula se parece muito com
o numero 1). Veja um exemplo deste tipo de literal:
long valor = 623465L;
6) Se um literal possui os sufixos UL, Ul, uL, ul, LU, Lu, lU
ou lu, ele será do tipo ulong.
Por ora você não encontrará nenhuma aplicação
prática dos conceitos apresentados nesta parte do texto.
Porém, procure, sempre que puder rever estas anotações.
Elas serão muito úteis durante o seu desenvolvimento.
Veja agora uma das situações clássicas
de erro de compilação envolvendo literais. Observe
o trecho de código a seguir:
float
valor = 6.2;
A primeira vista esta definição está correta.
Temos um literal de ponto flutuante sendo atribuído a
uma variável do tipo float. Porém,
ao tentarmos a compilação obtemos a seguinte mensagem
de erro:
Valores.cs(7,19):
error CS0664: Literal of type double cannot be implicitly converted
to type 'float'; use an 'F' suffix to create a literal of this
type
Esta mensagem de erro nos avisa que um literal do tipo double
não pode ser implicitamente convertido para o tipo float.
E sugere que usemos o sufixo F após o valor do integral.
Façamos isso então:
float
valor = 6.2F;
Ao tentar compilar o código novamente vemos que a mensagem
de erro se foi. Desta experiência concluímos que:
1) Se o literal de ponto-flutuante não
possuir sufixo, ou possuir os sufixos D ou d, ele será
do tipo double.
2) Se o literal possuir
os sufixos F ou f, ele será do tipo float.
3)
Se o literal possuir os sufixos M ou m, ele será do tipo
decimal.
De posse desta informação, nem precisamos de muito
esforço para saber que o trecho de código:
decimal valor =
40.5;
resultará em um erro de compilação, mesmo
sabendo que uma variável do tipo decimal
pode perfeitamente acomodar o valor de um literal do tipo double.
Literais do tipo char podem ser definidos usando-se
aspas simples em torno do caractere desejado. Veja um exemplo:
char letra = 'A';
Outra forma de fornecer um valor a um literal char
é usar valores inteiros na faixa que vai de 0 até
65.535 (lembre-se de que o tipo char ocupa 16 bits na memória
e não possui sinal). Veja um exemplo:
char
letra = (char ) 104;
Esta técnica foi exemplifica no tópico "Os
tipos de dados char, string e referência". Existe,
no entanto, uma outra forma de atribuir valores a um literal
char. Esta forma não é tão freqüente
e consiste em atribuir ao literal o caractere desejado usando-se
um valor hexadecimal que representa o valor Unicode do caractere.
Este valor deverá ser precedido por "\n". Veja
um exemplo:
char
letra = '\u0067';
Aqui o literal letra conterá a letra "g". O
apêndice A "Sistemas de Numeração"
mostrará a você como converter entre os sistemas
de numeração decimais e hexadecimais.
Para finalizar vamos analisar as seqüências de escape
disponíveis na linguagem C#. Veja a tabela a seguir:
| Sequencia |
Nome do Caractere |
Valor Unicode |
| \' |
Aspas Simples |
0x0027 |
| \" |
Aspas Duplas |
0x0022 |
| \\ |
Barra Invertida |
0x005C |
| \b |
Retrocesso |
0x0008 |
| \f |
Avanço de Página |
0x000C |
| \n |
Nova Linha |
0x000A |
| \r |
Voltar |
0x000D |
| \t |
Tabulação Horizontal |
0x0009 |
| \v |
Tabulação Vertical |
0x000B |
Esta tabela de seqüências de escape tem sua importância
compreendida quando precisamos exibir frases que contém
aspas simples ou duplas. Por exemplo, se quiséssemos
exibir a seguinte frase:
Então
ela falou: "Estou muito cansada"
A maneira usual seria escrever um trecho de código assim:
string frase =
"Então ela falou: "Estou muito cansada"";
Porém, ao tentarmos executar tal código temos
uma mensagem de erro semelhante à mostrada a seguir:
testes.cs(7,39):
error CS1002: ; expected
testes.cs(7,51): error CS1002: ; expected
testes.cs(7,58): error CS1002: ; expected
Esta mensagem de erro não ajuda em nada. Mas, já
sabemos o que fazer. Basta "escapar" as aspas internas.
Veja como o código deve ser escrito:
string frase = "Então ela falou: \"Estou muito
cansada\""; |
Precisa de um freelancer, códigos-fonte e exemplos completos?
Códigos-fonte 
Bancos de Dados
Usuários On-Line
Parte 2 :: Variáveis, Constantes
e Tipos de Dados :: Literais
Veja dicas, truques e anotações de 
