C# (C Sharp): Arrays Multidimensionais

em 10/06/2016

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]];

1	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];

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

Pode ser feito dessa forma também:

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

1 2	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

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}};

1

2

3

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;

1

2

3

4

5

6

7

8

9

10

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).

C# (C Sharp): Arrays Unidimensionais

por jefferson

em 10/06/2016

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];

1	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];

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

Outra forma de declaração:

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

1 2	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};

1

2

3

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;

1

2

3

4

5

6

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

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

C# (C Sharp): Bloco de Comando

por jefferson

em 10/06/2016

É 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
*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

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

C# (C Sharp): Operadores

por jefferson

em 10/06/2016

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

C# (C Sharp): Tabelas de Conversões Numéricas Implícitas e Explícitas

por jefferson

em 10/06/2016

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"

1

2

3

4

5

6

7

8

9

10

11

12

13

/*

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"

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

/*

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"

C# (C Sharp): Conversões de Tipos

por jefferson

em 10/06/2016

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
*/

1

2

3

4

5

6

7

8

9

10

11

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)
*/

1

2

3

4

5

6

7

8

9

10

11

12

13

14

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
*/

1

2

3

4

5

6

7

8

9

10

11

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.

C# (Sharp): Tipos de Dados Integer

por jefferson

em 10/06/2016

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

1

2

3

4

5

6

7

8

9

10

11

/*

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"

1

2

3

4

5

/*

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"

C# (Sharp): Comentários

por jefferson

em 09/06/2016

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
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

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

}

C# (Sharp): Declaração de Variáveis

por jefferson

em 09/06/2016

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

2

3

4

5

6

7

8

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;

Variável não inicializada;
Variável inicializada;
Variáveis de um mesmo tipo, não inicializadas;
Variáveis de um mesmo tipo, apenas uma inicializada;
Variável inicializada com o valor de uma expressão;
Variável inicializada com o valor retornado por um método;
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

2

3

4

5

var idade = 28;

var nome = "Jefferson";

var sexo = 'M';

var peso = 75.6;

var ativo = true;

Tipo int;
Tipo string;
Tipo char;
Tipo double;
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)

PHP: Lançamento da versão 7.1.0 Alpha 1

por jefferson

em 09/06/2016

A equipe de desenvolvimento do PHP anunciou hoje o PHP 7.1.0 Alpha 1. Este lançamento marca o início da primeira versão da série PHP 7.x. Todos os usuários do PHP são encorajados a testar esta versão com cuidado, e relatar quaisquer bugs e incompatibilidades no sistema de rastreamento de bugs.

Algumas das novidades:

Para maiores informações acesse: PHP 7.1.0 Aplha 1 / Upgrade File

J2V Blog

Informática & Tecnologia