Autor: Jefferson Ventura Page 1 of 5

São arrays que possuem mais de uma dimensão, o acesso de cada elemento é feito por meio de dois ou mais índices.

Arrays bidimensionais

Também chamados de matrizes, podem ser comparadas com uma tabela, contendo linhas e colunas. O acesso a cada um de seus elementos é feito por meio de dois índices, um para a linha o outro para a coluna.

Formato tradicional de declaração:

tipo[ , ] nome = new tipo[[n1, n2]];

• tipo: Tipo do array (e de seus elementos);
• [ , ]: Indicando que é um array bidimensional;
• nome: Nome do array;
• n1: Número de linhas do array. Deve ser uma variável ou constante numérica inteira;
• n2: Número de colunas do array. Deve ser uma variável ou constante numérica inteira;

Array com cinco linhas e três colunas, inicializados automaticamente:

int[ , ] valores = new int[5, 3];

Pode ser feito dessa forma também:

int[ , ] valores;
valores = new int[5, 3];

O array criado é visualizado da seguinte forma:

valores[0]	valores[1]	valores[2]	valores[3]	valores[4]
0 1 2	0	1	2	0 1 2	0	1	2	0 1 2	0	1	2	0 1 2	0	1	2	0 1 2	0	1	2
0	1	2
0	1	2
0	1	2
0	1	2
0	1	2

ou assim:

[0][0]	[0][1]	[0][2]	[0][3]	[0][4]
[1][0]	[1][1]	[1][2]	[1][3]	[1][4]
[2][0]	[2][1]	[2][2]	[2][3]	[2][4]

Array bidimensional sendo inicializado no momento de sua declaração:

int[ , ] valores = new valores[5, 3] {{1,2,3,4,5}, {6,7,8,9,10}};
int[ , ] valores = new valores[ , ] {{1,2,3,4,5}, {6,7,8,9,10}};
int[ , ] valores = {{1,2,3,4,5}, {6,7,8,9,10}};

Definindo elemento por elemento:

int[ , ] valores = new int[5, 3];
valores[0][0] = 1;
valores[0][1] = 2;
valores[0][2] = 3;
valores[1][0] = 4;
valores[1][1] = 5;
valores[1][2] = 6;
valores[2][0] = 7;
valores[2][1] = 8;
valores[2][2] = 9;

Em breve atualizaremos com os arrays tridimensionais e os irregulares (jagged).

Também chamados de Vetores, podem ser comparados a uma sequência linear de valores, onde cada valor pode ser acessado através de um índice único.

Tipo do Array	Valor Default
númerico (int, float, etc.)	0 (zero)
bool	False
char	\0
string	null

Formato tradicional de declaração:

tipo[ ] nome = new tipo[n];

• tipo: Tipo do array (e de seus elementos);
• [ ]: Indicando que é um array unidimensional;
• nome: Nome do array;
• n: Número de elementos do array. Deve ser uma variável ou constante numérica inteira;

Exemplo de um array unidimensional com 5 elementos:

int[ ] valores = new int[5];

Outra forma de declaração:

int[ ] valores;
valores = new int[5];

Criando no momento de sua declaração:

int[ ] valores = new int[5]{1,2,3,4,5};
int[ ] valores = new int[ ]{1,2,3,4,5};
int[ ] valores = {1,2,3,4,5};

Atribuindo valores a um array um a um:

int[ ] valores = new int[5];
valores[0] = 1;
valores[1] = 2;
valores[2] = 3;
valores[3] = 4;
valores[4] = 5;

Tipando um array assim como em variáveis:

var pares = new[ ] {2, 4, 6, 8, 10};                      // array do tipo inteiro
var nomes = new[ ] {"Jefferson", "Valerio", "Ventura"};   // array do tipo string

É composto de dois ou mais comandos entre chaves ({…}). Onde isolamos a utilização das variáveis, vejamos um exemplo abaixo.

int x = 19;
{
    int y = 27;
    x = x + 4;
    Console.WriteLine("Valor de X no bloco: " + x);
    Console.WriteLine("Valor de Y no bloco: " + y);  
}

Console.WriteLine("Valor de X fora do bloco: " + x);  
// Console.WriteLine("Valor de Y fora do bloco: " + y);

/*
Saída:
Valor de X no bloco: 23
Valor de Y no bloco: 27

Valor de X fora do bloco: 19
*/

Caso a linha 10 não estivesse comentada, um erro seria lançado, porque a variável y não existe fora do bloco

Operadores aritméticos básicos:

Operador	Operação
*	Multiplicação
/	Divisão
%	Resto da divisão inteira ou ponto flutuante
+	Adição
–	Subtração

Operadores aritméticos de atribuição:

Operador	Operação
*=	Multiplicação com atribuição
/=	Divisão com atribuição
%=	Resto da divisão inteira ou ponto flutuante com atribuição
+=	Adição com atribuição
-=	Subtração com atribuição

Operadores de incremento (++) e decremento (- -):

Operador	Descrição	Forma
++operando	Adiciona 1	de prefixo
operando++	Adiciona 1	de sufixo
–operando	Subtrai 1	de prefixo
operando–	Subtrai 1	de sufixo

Operadores relacionais:

Operador	Descrição
<	Menor que
<=	Menor ou igual a
>	Maior que
>=	Maior ou igual a
==	Igual a
!=	Não igual a

 

Veja a seguir as conversões numéricas implícitas. Conversões que não estejam na tabela a seguir, você deve utilizar o type cast.

/*
 De      | Para
*/
byte     | "short, ushort, int, uint, long, ulong, float, double, decimal"
char     | "ushort, int, uint, long, ulong, float, double, decimal"
float    | "double"
int      | "long, float, double, decimal"
long     | "float, double, decimal"
sbyte    | "short, int, long, float, double, decimal"
short    | "int, long, float, double, decimal"
uint     | "long, ulong, float, double, decimal"
ulong    | "float, double, decimal"
ushort   | "int, uint, long, ulong, float, double, decimal"

Agora vejamos as conversões do tipo explícitas que o podem ser realizadas pelo programador:

/*
 De       | Para
*/
byte      | "char, sbyte"
char      | "byte, sbyte, short"
decimal   | "byte, char, double, float, int, long, sbyte, short, uint, ulong, ushort"
double    | "byte, char, decimal, float, int, long, sbyte, short, uint, ulong, ushort"
float     | "byte, char, decimal, int, long, sbyte, short, uint, ulong, ushort"
int       | "byte, char, sbyte, uint, ulong, ushort"
long      | "byte, char, int, sbyte, short, uint, ulong, ushort"
sbyte     | "byte, char, uint, ulong, ushort"
short     | "byte, char, sbyte, uint, ulong, ushort"
uint      | "byte, char, int, sbyte, short, ushort"
ulong     | "byte, char, int, long, sbyte, short, uint, ushort"
ushort    | "byte, char, sbyte, short"

 

Existem dois tipos de conversões predefinidas, seguem a seguir:

• Implícita (ou automática): Feita automaticamente pelo compilador, desde que seja segura.
• Explícita: Feita pelo próprio programador forçando a conversão de um tipo para outro, utilizando type cast.

Vejamos um exemplo de conversão implícita, do tipo tipo int para long:

int xInt = 27;
long xLong = xInt;

Console.WriteLine("xInt = " + xInt);
Console.WriteLine("xLong = " + xLong);

/*
Saída:
xInt = 27
xLong = 27
*/

Mas afinal o que é Type Cast?

Consiste em forçar a conversão do tipo de uma determinada variável em outro. Utilizado nos casos em que não existe a conversão automática (implícita).

Vejamos um exemplo de conversão explícita, do tipo int para short: (inválida)

int xInt = 88910;
short xShort = (short)xInt; // utilizando o type cast

Console.WriteLine("xInt = " + xInt);
Console.WriteLine("xShort = " + xShort);

/*
Saída:
A conversão foi realizada só que o tipo de informação armazenada 
na conversão não é válido com a informação do tipo anterior.

xInt = 88910
xShort = 23374 (Valor não válido)
*/

Vejamos agora um exemplo de conversão explícita, do tipo int para short: (válida)

int xInt = 1988;
short xShort = (short)xInt; // utilizando o type cast

Console.WriteLine("xInt = " + xInt);
Console.WriteLine("xShort = " + xShort);

/*
Saída:
xInt = 1988
xShort = 1988
*/

Atenção: Conversões dos tipos int, uint e long para o tipo float e do tipo long para double pode ocorrer perda de precisão.

Será publicada no blog uma tabela com as conversões implícitas e explícitas.

Segue abaixo os tipos e subtipos de dados  integer:

/*
 Tipo/Subtipo | Comprimento | Intervalo                                                   | Descrição
*/
int           | 32 bits     | "-2.147.483.648 a 2.147.483.647"                            | Inteiro com sinal
uint          | 32 bits     | "0 a 4.294.967.295"                                         | Inteiro sem sinal
byte          | 8  bits     | "0 a 255"                                                   | Inteiro sem sinal
sbyte         | 8  bits     | "-128 a 127"                                                | Inteiro com sinal
short         | 16 bits     | "-32.768 a 32.767"                                          | Inteiro curto com sinal
ushort        | 16 bits     | "0 a 65.535"                                                | Inteiro curto sem sinal
long          | 64 bits     | "-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807"    | Inteiro longo com sinal
ulong         | 64 bits     | "0 a 18.446.744.073.709.551.615"                            | Inteiro longo sem sinal

Tipos de ponto flutuante:

/*
 Tipo   | Comprimento   | Intervalo de Valores    | Precisão
*/
float   | 32 bits       | "1.5E^-45 a 3.4E^+38"   | "7 dígitos"
double  | 64 bits       | "5E^-324 a 1.7E^+308"   | "15 ou 16 dígitos"

 

Você pode criar comentários em seus códigos, o que além de facilitar lembrar o que foi feito, também é considerado uma boa prática.

using System;

namespace Variaveis
{
    class MainClass
    {
        /*
         Comentário
         em
         Bloco
        */
        public static void Main(string[] args)
        {
            // Comentário de uma linha
            Console.WriteLine("J2V Informática!");
            Console.WriteLine("by Jefferson Ventura"); // Nome do desenvolvedor
        }
    }
}

 

Exemplos de declaração de variáveis:

int x;
int y = 27;
float preco, valor, media;
double desconto = 100.50, saldo;
int total = n1 + n2;
double r = Math.Sqrt(delta);
int x, y, z;
x = y = z = 19;

1. Variável não inicializada;
2. Variável inicializada;
3. Variáveis de um mesmo tipo, não inicializadas;
4. Variáveis de um mesmo tipo, apenas uma inicializada;
5. Variável inicializada com o valor de uma expressão;
6. Variável inicializada com o valor retornado por um método;
7. Inicialização múltipla. As variáveis x, y e z possuem o mesmo valor 19;

Variáveis tipadas implicitamente: (Não pode ser inicializada com o valor null, nem declaração múltipla)

var idade = 28;
var nome = "Jefferson";
var sexo = 'M';
var peso = 75.6;
var ativo = true;

1. Tipo int;
2. Tipo string;
3. Tipo char;
4. Tipo double;
5. Tipo bool;

O C# é Case Sensitivity, ou seja ele faz distinção de caracteres minúsculos e maiúsculos. Sendo assim idade é diferente de IDADE ou Idade. Assim como as palavras reservadas são todas minúsculas; (if, for, foreach) e não (IF, For, FOREACH)