J2V

Informática & Tecnologia

Autor: Jefferson Ventura Page 1 of 5

C# (C Sharp): Arrays Multidimensionais

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

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

C# (C Sharp): Arrays Unidimensionais

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 ArrayValor Default
númerico (int, float, etc.)0 (zero)
boolFalse
char\0
stringnull

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

C# (C Sharp): Bloco de Comando

É 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

C# (C Sharp): Operadores

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

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"

 

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

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.

C# (Sharp): Tipos de Dados Integer

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"

 

C# (Sharp): Comentários

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

 

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

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)

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

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

Page 1 of 5

Desenvolvido em WordPress & Tema por Anders Norén