Esta lição introduz aos operadores, tipos e variáveis do C#. Seu objetivo é atender as seguintes necessidades:

- Entenda o que é uma variável.
- Familiarização com C # built-in types.
- Obter uma introdução aos operadores.
- Saiba como usar Arrays.

Variáveis e tipos

"Variáveis" são simplesmente locais de armazenamento de dados. Você pode colocar os dados e recuperá-los em seu conteúdo como parte de uma expressão. A interpretação dos dados em uma variável é controlada através de "Tipos" ou no inglês "types".

Todas as operações sobre variáveis são realizadas com consideração de que a variável do "Type". Existem regras que definem quais as operações são legais, a fim de manter a integridade dos dados que você colocou em uma variável.

Há tipos simples que consistem do tipo booleana e três tipos numéricos - Integer, Float, Decimal, e String. O termo "Integer", que é definido no C # Programming Language Specification, refere-se à classificação dos tipos que incluem sbyte, byte, short, ushort, int, uint, long, ulong, e char. Mais informações estão disponíveis na seção Integral Tipos posteriormente nesta lição. O termo "Float" refere-se à float e double types, que são discutidos, juntamente com o tipo decimal, com mais detalhes no Ponto Flutuante e Decimal Tipos secção posteriormente nesta lição. A string tipo representa um conjunto de caracteres e é discutido na secção String Types, posteriormente nesta lição. A próxima seção introduz o tipo booleano.

Tipo Boolean

Booleano ou boolean são declarados usando a palavra-chave, bool. Eles têm dois valores: verdadeiro ou falso. Em outras linguagens, como C, C + +, condições podem ser satisfeitos onde 0 significa falso e qualquer outra coisa, significa verdadeira. No entanto, em C # apenas os valores que satisfazem uma condição boolean é verdadeiro e falso (true, false), que são as palavras-chave oficiais. Listagem 2-1 mostra uma das muitas maneiras que tipos boolean podem ser usados em um programa.

Listagem 2-1. Mostrando tipo booleano: Boolean.cs

using System;

class Booleans
{
public static void Main()
{
bool content = true;
bool noContent = false;

Console.WriteLine("It is {0} that C# Station provides C# programming language content.", content);
Console.WriteLine("The statement above is not {0}.", noContent);
}
}

Na Listagem 2-1, so valores boolean são escritos para o console como parte de uma frase. Os únicos valores válidos para o tipo bool ou são verdadeiras ou falsas, como demonstra a atribuição de verdade ao content e aos falsos noContent. Quando executado, esse programa produz os seguintes resultados:

It is True that C# Station provides C# programming language content.
The statement above is not False.

Tipo Integer

Em C #, o tipo inteiro ou integer é de uma categoria de tipos para números. A palavra inteiro soa como uma expressão matemática, a partir da perspectiva de programação C #, estas são, na realidade, definidas como Integer types na linguagem de programação C#. São números inteiros, quer assinado ou não assinado.

Tabela 2-1 mostra o integrante tipos, a sua dimensão e alcance.


Inteiros são bem adequados para as operações que envolvem cálculos numéricos. O tipo char é a excepção, o que representa um único caracter Unicode. Como você pode ver a partir do quadro acima, você tem uma vasta gama de opções de escolha, dependendo de suas necessidades.

Tipo Float e Decimal

O ponto flutuante é tanto float ou double. Eles são usados a qualquer momento que você precisa para representar um número real, tal como definido pelo IEEE 754. Para mais informações sobre o IEEE 754, visite o Web Site IEEE. O tipo Decimal deve ser usado quando representa um valor financeiro, dinheiro ou valores.

Tabela 2-2 mostra o ponto flutuante e decimal, a sua dimensão, a precisão, e variação.


Tipos de ponto flutuante são usados quando se necessita para realizar as operações que exijam representações fracionária. No entanto, para cálculos financeiros, o tipo decimal é a melhor opção, porque você pode evitar erros de arredondamentos.

Tipo String

Uma string é uma seqüência de caracteres texto. Você normalmente cria uma string com uma string literal, delimitada entre aspas: "Este é um exemplo de uma string." Você viu strings sendo usado desde Aula 1, em que utilizou o método Console.WriteLine para enviar saída para o console.

Alguns caracteres não são impressos, mas ainda precisa usá-los em strings. Portanto, C # tem uma sintaxe especial onde personagens podem ser escaped para representar caracteres não imprimíveis. Por exemplo, é comum a utilização newlines (quebra de linha) no texto, que é representada pela 'n'. A barra invertida, '', representa a fuga. Quando antecedida pela fuga personagem, o 'n' já não é interpretada como um carácter alfabético, mas já representa uma nova linha.

Você pode estar pensando como você agora pode representar uma barra de caracteres em seu código. Temos de escape que também escrevendo dois barra, como em ' '.

Tabela 2-3 mostra uma lista de seqüências comuns escapar.

Operadores

Os resultados são calculados pela construção expressões. Estas expressões são construídas pela combinação de variáveis e operadores juntos em declarações. A tabela a seguir descreve os operadores admissíveis, a sua precedência, e associativity.

Tabela 2-4. Operadores com sua precedência e Associativity


Associativity left significa que as operações são avaliadas da esquerda para a direita. Associativity right significar todas as operações ocorrem da direita para a esquerda, como a cessão operadores à direita onde tudo é avaliado antes o resultado seja colocado em uma variável à esquerda.

A maioria dos operadores são ou unário ou binário. Unário operadores forma expressões em uma única variável, mas operadores forma binária expressões com duas variáveis.

Listagem 2-2 demonstra como unário operadores são usados.

    using System;

    class Unary
    {
        public static void Main()
        {
            int unary = 0;
            int preIncrement;
            int preDecrement;
            int postIncrement;
            int postdecrement;
            int positive;
            int negative;
            sbyte bitNot;
            bool logNot;

            preIncrement = ++unary;
            Console.WriteLine("pre-Increment: {0}", preIncrement);

            preDecrement = --unary;
            Console.WriteLine("pre-Decrement: {0}", preDecrement);

            postdecrement = unary--;
            Console.WriteLine("Post-Decrement: {0}", postdecrement);

            postIncrement = unary++;
            Console.WriteLine("Post-Increment: {0}", postIncrement);

            Console.WriteLine("Final Value of Unary: {0}", unary);

            positive = -postIncrement;
            Console.WriteLine("Positive: {0}", positive);

            negative = +postIncrement;
            Console.WriteLine("Negative: {0}", negative);

            bitNot = 0;
            bitNot = (sbyte)(~bitNot);
            Console.WriteLine("Bitwise Not: {0}", bitNot);

            logNot = false;
            logNot = !logNot;
            Console.WriteLine("Logical Not: {0}", logNot);
        }
    }

o avaliar expressões, pós-incremento (x + +) e pós-decrementar (x -) operadores retornar seu valor atual e, em seguida, aplicar as operadoras. No entanto, quando se utiliza pré-incremento (+ + x) e pré-decrementar (- x) operadores, o operador é aplicado a uma variável antes de retornar o valor final.

Em Listing 2-2, o unário variável é inicializado a zero. Quando o pré-incremento (+ + x) operador é utilizado, unário a 1 e é incrementado o valor 1 é atribuído ao preIncrement variável. O pré-decrementar (- x) operador unário vira costas a um 0 e, em seguida, atribui o valor à variável preDecrement.

Quando o pós-decrementar (x -) operador é utilizado, o valor de unário, 0, é colocado na postdecrement variável e, em seguida, unário é diminuído para -1. Em seguida o pós-incremento (x + +) operador move o valor atual da unário, -1, a postIncrement variável e, em seguida, incrementos unário a 0.

A variável bitNot é inicializado a zero e não o bitwise (~) operador é aplicada. A não bitwise (~) vira o operador bits na variável. Neste caso, a representação binária de 0, "00000000", foi transformada em -1, "11111111".

Aviso a expressão (sbyte) (~ bitNot). Qualquer operação realizada em tipos sbyte, byte, short, int ou ushort retornar valores. Para atribuir o resultado para a variável bitNot tivemos que utilizar um cast (Type) operador, em que tipo é o tipo que você deseja converter (neste caso - sbyte). O elenco operador é apresentado como o Unary operador "(T) x" na tabela 2-4. Cast operadores devem ser realizadas explicity quando você passar de um maior para um tipo menor tipo, porque o potencial de perda de dados. De uma forma geral, atribuição de um tipo menor para um maior tipo é nenhum problema, uma vez que o maior tipo tem espaço para realizar todo o valor. Também estar conscientes dos perigos de casting entre tipos assinados e não assinados. Você quer ter a certeza de preservar a integridade dos seus dados. Muitos textos básicos de programação contém boas descrições de bit representações de variáveis e os perigos de casting explícito.

A lógica não (!) Operador lhe permite mudar o valor de uma variável booleana. No exemplo, o logNot variável é alterado de false para true. Você pode esperar o resultado do referido programa.

Pré-Incremento: 1
Pré-Decrement 0
Post-Decrement: 0
Pós-Incremento: -1
O valor final do Unary: 0
Positivo: 1
Negativo: -1
Não bitwise: -1
Não é lógico: true

Além de unário operadores, C # tem binário operadores que formam expressões de duas variáveis. Listagem 2-3 mostra como usar o binário operadores.

Listagem 2-3. Operadores Binários: Binary.cs
using System;

class Binary
{
public static void Main()
{
int x, y, result;
float floatresult;

x = 7;
y = 5;

result = x+y;
Console.WriteLine("x+y: {0}", result);

result = x-y;
Console.WriteLine("x-y: {0}", result);

result = x*y;
Console.WriteLine("x*y: {0}", result);

result = x/y;
Console.WriteLine("x/y: {0}", result);

floatresult = (float)x/(float)y;
Console.WriteLine("x/y: {0}", floatresult);

result = x%y;
Console.WriteLine("x%y: {0}", result);

result += x;
Console.WriteLine("result+=x: {0}", result);
}
}

A saída é:

x+y: 12
x-y: 2
x*y: 35
x/y: 1
x/y: 1.4
x%y: 2
result+=x: 9

Listagem 2-3 mostra vários exemplos de operadores binários. Como você poderia esperar, os resultados de adição (+), subtração (-), a multiplicação (*), ea divisão (/) produzir os resultados esperados matemático.

O floatresult variável é um tipo de ponto flutuante. Nós explicitamente o elenco inteiro variáveis x e y para calcular um valor de ponto flutuante.

Existe também um exemplo do restante (%) operador. Ele executa uma operação divisão, em dois valores e retorna o resto.

A última declaração revela uma outra forma de cessão com a operação (+ =) operador. Todas as vezes que você utilizar a atribuição com operação operador, que é o mesmo que a aplicação do operador binário para tanto a mão esquerda ea mão direita lados do operador e colocar os resultados para o lado esquerdo. O exemplo poderia ter sido escrita como resultado resultado + = x; e retornado o mesmo valor.

Tipo Array

Outro tipo de dados é o Array, que podem ser consideradas como um contentor que tem uma lista de locais de armazenamento de um tipo especificado. Ao declarar um Array, especificar o tipo, nome, dimensões e tamanho.

Listagem 2-4. Operadores Arrays: Array.cs

using System;

class Array
{
public static void Main()
{
int[] myInts = { 5, 10, 15 };
bool[][] myBools = new bool[2][];
myBools[0] = new bool[2];
myBools[1] = new bool[1];
double[,] myDoubles = new double[2, 2];
string[] myStrings = new string[3];

Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0], myInts[1], myInts[2]);

myBools[0][0] = true;
myBools[0][1] = false;
myBools[1][0] = true;
Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0], myBools[1][0]);

myDoubles[0, 0] = 3.147;
myDoubles[0, 1] = 7.157;
myDoubles[1, 1] = 2.117;
myDoubles[1, 0] = 56.00138917;
Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}", myDoubles[0, 0], myDoubles[1, 0]);

myStrings[0] = "Joe";
myStrings[1] = "Matt";
myStrings[2] = "Robert";
Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}", myStrings[0], myStrings[1], myStrings[2]);

}
}

A saída:

myInts[0]: 5, myInts[1]: 10, myInts[2]: 15
myBools[0][0]: true, myBools[1][0]: true
myDoubles[0, 0]: 3.147, myDoubles[1, 0]: 56.00138917
myStrings[0]: Joe, myStrings[1]: Matt, myStrings[2]: Robert

Listagem 2-4 mostra diferentes implementações de Arrays. O primeiro exemplo é o myInts Array, que é uma dimensão única-array. É inicializada no tempo com a declaração explícita valores.

Seguinte é um array retalhadas, myBools. É essencialmente um array de arrays. Precisávamos de usar o novo operador que exemplificam o tamanho do array primário e, em seguida, usar o novo operador novamente para cada sub-array.

O terceiro exemplo é um array bidimensional, myDoubles. Arrays podem ser multi-dimensional, com cada dimensão separados por uma vírgula. Por outro lado, deve ser instanciado com o novo operador.

Uma das diferenças entre arrays retalhadas, myBools [][], e multi-dimensão arrays, myDoubles [,], que é um programa multi-dimensão array irá alocar memória para cada elemento de cada dimensão, que um array retalhadas só irá alocar memória Para o tamanho de cada variedade de cada dimensão que você define. Na maioria das vezes, você estará usando arrays multi-dimensão, se você precisar de múltiplas dimensões, e só usar retalhadas arrays em circunstâncias muito especiais, quando você é capaz de guardar significativo memória por explicitamente especificando os tamanhos dos arrays em cada dimensão .

Finalmente, temos o único-dimensional variedade de tipos string, myStrings.

Em cada caso, você pode ver que a matriz elementos são acessados por inteiro para identificar o índice para o item que você deseja referir-se. Arrays tamanho pode ser qualquer tipo int valor. Os índices começam em 0.

Resumo

A variável é um identificador com um tipo que detém um valor desse tipo. Simple tipos incluem as integrais, pontos flutuantes, decimal, e bool. C # tem vários operadores lógicos e matemáticos que participam na formação de expressões. C # também oferece a única dimensão, multi-dimensão e retalhadas array tipos.

Nesta lição você aprendeu como escrever simples declarações e código de um programa que funciona linearmente do começo ao fim. No entanto, este não é tão útil como ele pode ser porque você precisa ser capaz de tomar decisões e executar diferentes blocos de código dependendo das diferentes condições. Convido você a troco de Aula 3: Controle Declarações - Seleção, onde você pode aprender a sucursal sua lógica para a tomada de decisões mais poderosas.

Tradução do artigo: http://www.csharp-station.com/Tutorials/Lesson02.aspx

  Dica: Confira todo nosso conteúdo de C# no site.