CSharp-Conceitos Variaveis Tipos Operadores Condicionais Lacos Vetores
-
Upload
evaldo-oestreich-filho -
Category
Documents
-
view
243 -
download
8
Transcript of CSharp-Conceitos Variaveis Tipos Operadores Condicionais Lacos Vetores
Organizado por: Tiago Kautzmann (www.tiagokautzmann.com.br)
C#
CONCEITOS, VARIÁVEIS, CONSTANTES, TIPOS, OPERADORES, INSTRUÇÕES DE SELEÇÃO, INSTRUÇÕES DE REPETIÇÃO E ARRAYS
Sumário Introdução ...............................................................................................................................................................3
Linguagem de programação C#, Visual Studio, .Net Framework e Commo Language Runtime (CLR) ...................4
Criando a primeira aplicação de console de comando com C# e o Visual Studio 2010 ..........................................7
Métodos da classe Console para entrada / saída de dados na aplicação em console de comando. ................... 16
Instruções ............................................................................................................................................................. 17
Entendendo Instruções ..................................................................................................................................... 17
Identificadores ...................................................................................................................................................... 18
Palavras reservadas no C# (palavras-chave) ..................................................................................................... 18
Variáveis e tipos de dados .................................................................................................................................... 20
Declarando variáveis ........................................................................................................................................ 20
Nomeando variáveis ..................................................................................................................................... 21
Tipos de Dados ................................................................................................................................................. 21
Atribuindo valor às variáveis no C# .................................................................................................................. 22
Operadores ........................................................................................................................................................... 24
Operadores de Atribuição ................................................................................................................................ 24
Operadores aritméticos .................................................................................................................................... 24
Operadores relacionais ..................................................................................................................................... 25
Operadores lógicos ........................................................................................................................................... 26
Operadores de incremento / decremento ....................................................................................................... 26
Precedência de operadores .............................................................................................................................. 27
Constantes ............................................................................................................................................................ 28
Inserindo comentários no código C# .................................................................................................................... 29
Estruturas de Decisão / Instruções de Seleção ..................................................................................................... 30
Instrução de seleção if ...................................................................................................................................... 30
Instrução de seleção switch .............................................................................................................................. 32
Estruturas de repetição / instruções de repetição ............................................................................................... 34
Instrução de repetição while ............................................................................................................................ 34
Instrução de repetição for ................................................................................................................................ 35
Instrução de repetição do ................................................................................................................................. 36
Instruções break e continue ............................................................................................................................. 36
Arrays .................................................................................................................................................................... 38
Declarando variáveis de arrays ......................................................................................................................... 38
Criando uma instância de um array .................................................................................................................. 38
Inicializando variáveis de array ......................................................................................................................... 39
Acessando um elemento de um array .............................................................................................................. 39
Percorrendo os elementos de arrays ............................................................................................................... 39
Bibliografia ............................................................................................................................................................ 41
3
Introdução O objetivo desta apostila é apresentar as principais instruções para o desenvolvimento de
aplicações com a linguagem de programação C#. São conceitos fundamentais na área de
programação de computadores, como declaração de variáveis, tipos de dados, operadores,
instruções de decisão e repetição e vetores.
Para a elaboração desta apostila, foi utilizada a versão 2010 do Microsoft Visual Studio, mas
todos os conhecimentos podem ser aplicados em qualquer versão do programa.
Todos os exemplos serão apresentados através da criação de aplicações de linha de comando
(Console Application). Uma aplicação de Console é uma aplicação executada em prompt de comando,
e que não dispõe de nenhum recurso visual como janelas, caixas de diálogo, botões ou imagens. O
objetivo de apresentar os conhecimentos fundamentais da linguagem de programação C# em uma
aplicação Console é o de nos focarmos na linguagem de programação e seu código e não em recursos
visuais.
Importante lembrar que todos os conhecimentos (com exceção de duas instruções de entrada
e saída de dados, específicas para uma Console Application) poderão ser aplicados em qualquer
outro tipo de aplicação no Visual Studio, como Windows Forms Applications e Web Applications.
4
Linguagem de programação C#, Visual Studio, .Net
Framework e Commo Language Runtime (CLR)
Antes de iniciarmos os estudos sobre os fundamentos básicos de programação de computadores
utilizando a linguagem de programação C#, é importante que o leitor saiba reconhecer algumas tecnologias
envolvidas:
Linguagem de programação C#
O C# é uma linguagem de programação orientada a objetos e é a mais poderosa linguagem de
programação da Microsoft. Se você já conhece uma linguagem de programação como C, C++ ou Java, notará
que a sintaxe do C# é muito parecida com as linguagens citadas. Se o leitor está acostumado a programar em
algumas dessas linguagens, será capaz de assimilar rapidamente a sintaxe e o modo de trabalhar no C#.
Visual Studio
O Visual Studio é um ambiente de desenvolvimento integrado (IDE) da Microsoft, ou seja, é um
programa para desenvolvimento de software. Pode ser utilizado para desenvolver aplicações executadas em
prompt de comando (console) e aplicações com interface gráfica para o sistema operacional Windows e para
ambiente web. O Visual Studio suporta diferentes linguagens de programação como as linguagens C, C++,
Visual Basic, C#, F#, além de outras, e possui inúmeros recursos que facilitam o desenvolvimento de
aplicações.
.Net Framework
O .Net Framework, da Microsoft, é um framework de software para o sistema operacional Windows.
Entenda framework como uma biblioteca de componentes que auxiliam a programação. Além de possuir uma
biblioteca de componentes, o framework .Net possui o que chamamos de máquina virtual, um meio de campo
entre a aplicação desenvolvida e o sistema operacional onde o software será executado. Possui uma idéia
semelhante à plataforma Java, onde o programador deixa de escrever para um sistema operacional específico,
e passa a escrever para a plataforma .Net. (para a máquina virtual). Na sequência é apresentado um gráfico
que ajuda a explicar um pouco do funcionamento da plataforma .Net Framework.
5
O gráfico apresenta alguns detalhes sobre o funcionamento da plataforma .Net Framework. Mostra
que podemos programar com qualquer uma das 20 linguagens suportadas pelo .Net Framework, apesar de
sabermos que a mais utilizada nesta lista é a linguagem C#. Na imagem, porém, são mostradas as linguagens
C#, VB.Net e F#, mas qualquer outra das 20 linguagens suportadas poderiam ser representadas no gráfico.
Quando compilamos nossos programas, o código fonte é transformado pelo compilador da linguagem em uma
linguagem intermediária chamada MSIL (Microsoft Intermediate Language), ou simplesmente IL.
A linguagem intermediária é executada então, por uma máquina virtual (mesmo conceito utilizado na
linguagem Java) que chamamos de Commom Language Runtime (CLR), que faz parte da plataforma .Net. O CLR
é como se fosse a máquina virtual do Java. Nossos programas são executados na CLR, que é responsável por se
comunicar com o sistema operacional. A CLR fornece outros serviços importantes como segurança e
gerenciamento de memória.
No momento da execução do programa, a linguagem intermediária é compilada pela CLR para o
código nativo, de baixo nível, que será executado pelo sistema operacional.
Em linguagens de programação mais antigas, como o Delphi, por exemplo, o código fonte é compilado
diretamente para o código nativo, de baixo nível, para ser executado pelo sistema operacional. Na plataforma
.Net Framework não, o programa é compilado duas vezes, uma para a linguagem intermediária, de execução
da CLR e uma segunda vez, para o sistema operacional.
6
Com uma idéia semelhante à plataforma Java, o programador deixa de escrever código para um
sistema ou dispositivo específico, e passa a escrever para a plataforma .Net. Isso significa que nossos programa
serão executados em qualquer plataforma (sistema operacional) que suporte o .Net Framework.
O .Net Framework é constituído pelo CLR e por uma biblioteca de classes que disponibiliza inúmeras
funcionalidades para o programador.
7
Criando a primeira aplicação de console de comando
com C# e o Visual Studio 2010
Antes de iniciarmos o estudo sobre a linguagem de programação C#, criaremos uma pequena
aplicação que visualiza uma pequena mensagem na tela. Criaremos a tradicional aplicação “Hello
World”.
Para começar, entre no Visual Studio;
A imagem anterior apresenta o Visual Studio 2010 assim que o iniciamos. É exibida a página
Start Page onde podemos abrir os últimos projetos criados através da caixa Recent Projects.
Para criarmos nosso primeiro programa em C# no Visual Studio 2010, criaremos um novo
projeto, clicando no menu FILE, opção NEW, clicando em PROJECT... (CTRL + SHIFT + N).
A caixa de diálogo NEW PROJECT é aberta. Ela permite que criemos um novo projeto
utilizando vários templates, como um Windows Forms Applications, ASP.Net Web Application, Class
Library, Console Application e vários outros. Nesta apostila, criaremos projetos utilizando o template
Console Application, que é uma aplicação de execução em linha de comando. Se fossemos criar uma
aplicação para o Windows (com janelas, caixas de diálogo e botões), utilizaríamos o template
Windows Forms Application. Se fossemos criar uma aplicação para a web, utilizaríamos o template
ASP.Net Web Application.
8
Em Installed Templates, clique em Visual C#. No painel à direita, serão visualizados todos os
templates disponíveis para a linguagem C#.
No painel com os templates, clique em Console Application.
No campo Name digite HelloWorld.
No campo Location, você define o local onde a aplicação será salva.
Clique em OK.
9
O painel SOLUTION EXPLORER mostra os nomes dos arquivos associados ao seu projeto. Para
abrir cada arquivo, basta dar um clique duplo para exibi-lo no painel de código (code pane). Confira
algumas características dos arquivos que o visual Studio criou como parte do novo projeto Console
Application:
HelloWorld.csproj é o arquivo do projeto C#. Pode ser associado a vários arquivos de código. É
reconhecido no Solution Explorer pelo nome do projeto apenas, no entanto é gravado no disco com a
extensão .csproj.
Program.cs é um arquivo de código do C#. Você vai escrever seu código neste arquivo. O Visual
Studio já adicionou algum código nele automaticamente.
AssemblyInfo.cs é um outro arquivo de código do C#. Você pode usar esse arquivo para adicionar
atributos ao programa, como por exemplo, nome do autor, data que o programa foi escrito e outros.
Para visualizar os arquivos do projeto no Windows Explorer, clique com o botão direito do mouse
sobre o nome da aplicação (HelloWorld), e clique na opção Open Folder in Windows Explorer.
O arquivo Program.cs define uma classe chamada Program que contém um método chamado
Main. Todos os métodos precisam ser definidos dentro de uma classe. O método Main é especial
porque ele é o primeiro a ser executado quando o programa é iniciado, por isso ele precisa ser
designado como static (estático).
Os conhecimentos apresentados no parágrafo anterior são relacionados a um paradigma
existente na programação de computadores chamado de programação orientada a objetos. Este
paradigma de programação orientado a objetos não será alvo de estudo desta apostila. Nesta
apostila serão apresentados apenas conhecimentos fundamentais relativos à programação de
computadores, como declaração de variáveis, operadores, instruções condicionais e de repetição,
vetores e matrizes, entre outros. Portanto, para este material e para nossos programas iniciais, saiba
apenas, por enquanto, que colocaremos nosso código dentro do método Main, pertencente à classe
Program, no arquivo Program.cs.
Importante: A linguagem de programação C# é case-sensitive, ou seja, ela diferencia letras
minúsculas de maiúsculas, onde um M é interpretado diferente de um m. Consequentemente, Main
é diferente de main.
Nosso primeiro exemplo é bem simples, e um clássico para quem está aprendendo qualquer
linguagem de programação. Ele escreve a string “Hello World” na tela, no caso, no console (linha de
comando).
10
Dentro do método Main, entre colchetes, digite Console.
Estamos utilizando a classe Console, que possui métodos para exibir mensagens na tela (em
prompt de comando) e pegar as entradas do teclado. Tudo o que o usuário digita no teclado pode ser
lido através da classe Console. A classe Console só é significante para aplicações que rodam no
prompt de comando (linha de comando), como neste nosso primeiro exemplo:
Agora digite um ponto depois de Console.
Uma lista aparece logo após digitar um ponto. A lista é chamada de IntelliSense, que não é um
recurso exclusivo do Visual Studio, e que ajuda muito na programação, principalmente em linguagens
case-sensitive, como é o C#. O IntelliSense exibe todos os métodos, propriedades e campos da classe.
11
Na lista do IntelliSense, selecione o método WriteLine, usando o mouse ou teclado, e tecle
Enter ou dê um duplo clique sobre o WriteLine.
O IntelliSense é fechado e o método WriteLine é adicionado ao código.
12
IMPORTANTE: Um método é um conjunto de instruções que define um comportamento de uma
classe ou objeto. No caso, o método WriteLine é um método da classe Console que tem a função de
escrever uma string (mensagem) na tela (na linha de comando).
Abra parênteses (
É mostrado uma outra forma do IntelliSense, que mostra os parâmetros do método WriteLine.
O método WriteLine tem o que chamamos de sobrecarga (overload). Para cada sobrecarga do
método WriteLine usamos parâmetros diferentes. Cada sobrecarga e seus respectivos parâmetros
podem ser visualizados clicando com o mouse na seta do IntelliSense ou navegando pelas setas do
teclado.
Conhecimentos relativos sobre métodos, como a sobrecarga (overload) não é alvo de estudo dessa
apostila.
13
Feche o parênteses ) e digite ponto-e-vírgula.
Digite entre os parênteses a string “Hello World”. Vamos aprender sobre tipos de dados nesta
apostila, mas por enquanto o importante é saber que string é um tipo de dado.
14
Pronto. Nossa aplicação que mostra uma mensagem com a string “Hello World” esta pronta.
O método Main, da nossa classe Program possui apenas uma única instrução. Esta instrução chama o
método WriteLine (que escreve uma mensagem na linha de comando) da classe Console, passando
como parâmetro a string “Hello World”.
Vamos agora compilar nossa aplicação, ou seja, transformar nosso código de alto nível para
um código de baixo nível, que permita a execução da aplicação.
No menu Debug, clique em Start Without Debugging para executar a aplicação no prompt de
comando.
O programa escreve a mensagem “Hello World“ no prompt de comando.
Pressione qualquer tecla para sair do prompt de comando.
Na janela Solution Explorer, clique no botão Show All Files.
Aparece em nosso projeto os nomes bin e obj. Essas pastas são criadas quando você executa a
aplicação e contém uma versão executável do programa e outros arquivos necessários para depurar
o programa.
No Solution Explorer, clique no sinal de + à esquerda do nome bin.
Um outro nome aparece, representando a pasta chamada debug.
Clique no sinal de + à esquerda do nome debug.
15
Repare nos arquivos: HelloWorld.exe e HelloWorld.pdb.
O arquivo .exe é o executável da aplicação.
O arquivo .pdb contém informações sobre a depuração da aplicação.
Como vimos até agora, o Visual Studio compilou automaticamente nosso programa e criou os
arquivos necessários automaticamente, durante o processo de compilação. Em resumo, compilação é
o processo que transforma seus arquivos fonte (escritos em uma linguagem de programação de alto
nível, como C#) em um arquivo executável (com linguagem de baixo nível) pelo sistema operacional,
um .exe, por exemplo.
16
Métodos da classe Console para entrada / saída de
dados na aplicação em console de comando.
Lembro que todos os exemplos desta apostila serão executados em aplicações com o
template Console Application, ou seja, desenvolveremos aplicações que rodarão no prompt de
comando (console de comando).
E muitos dos exemplos se utilizarão de comandos para imprimir mensagens na tela (dados de
saída) e comandos que fazem a leitura da digitação do teclado (dados de entrada).
Método de Entrada de Dados:
Para a entrada de dados, ou seja, para que a aplicação capture um valor digitado pelo usuário
no teclado (entrada de dados), utilizaremos o método ReadLine da classe Console, que retorna um
dado do tipo string com o valor digitado no teclado . Exemplo:
String nome = Console.ReadLine();
No exemplo acima, temos uma variável identificada como nome, do tipo string, que recebe o retorno do método ReadLine da classe Console. Ou seja, a variável string recebe o valor do que foi digitado no teclado pelo usuário. Método de Saída de Dados:
Para a saída de dados, ou seja, para imprimir na tela alguma informação, utilizaremos em
nossos exemplos o método WriteLine da classe Console, que imprime na tela do prompt de comando
um valor que á passado por parâmetro. Exemplo:
Console.WriteLine("Bem-vindos ao programa");
No exemplo acima, temos uma chamada ao método Writeline, da classe Console, que
imprime no prompt de comando o valor passado como parâmetro, no caso, o valor do tipo string
“Bem-vindos ao programa”.
Em todos os exemplos desta apostila em que tivermos a entrada e saída de dados,
utilizaremos os dois métodos apresentados acima.
As duas instruções apresentadas acima são as únicas instruções que só funcionarão em uma
aplicação do tipo Console Application. Todas as demais instruções apresentadas nesta apostila
funcionarão em outros tipos de aplicações, como Windows Forms Applications e Web Applications.
17
Instruções
Entendendo Instruções
Uma instrução é um comando que executa uma “ação”. Você combina instruções para criar
blocos de instruções ou métodos (métodos não serão abordados em detalhes nesta apostila, mas
saiba que um método é um conjunto de instruções que determina um comportamento de uma
classe).
Uma das regras de sintaxe mais simples e mais importantes no C# diz que todas as instruções
devem ser terminadas com um ponto-e-vírgula. Exemplo de uma instrução:
Console.WriteLine("Hello World");
A instrução acima chama o método WriteLine da classe Console, passando como parâmetro a
string “Hello World”.
18
Identificadores Identificadores são os nomes utilizados para identificar os elementos nos seus programas, como variáveis,
classes, métodos, namespaces, entre outros. No C#, devem ser seguidas algumas regras para definir os
identificadores:
Utilizar apenas letras (maiúsculas ou minúsculas), dígitos e o caractere de sublinhado.
Um identificador deve iniciar com uma letra ou com o caractere de sublinhado.
Um identificar não pode conter espaços em branco em seu interior.
Importante lembrar: A linguagem de programação C# é case-sensitive, ou seja, ela diferencia letras
minúsculas de maiúsculas, onde um M é interpretado diferente de um m.
Exemplos de identificadores válidos:
resultado
_placar
timeDeFutebol
clube15
Exemplos de identificadores não válidos:
resultado$
15clube
_placar@
Palavras reservadas no C# (palavras-chave)
A linguagem de programação C# reserva determinadas palavras para seu próprio uso. As palavras
reservadas são identificadores reservados e predefinidos que possuem um significado especial para o
compilador C#. Estas palavras não podem ser utilizadas como identificadores em nossos programas contanto
que seja incluído o caractere arroba (@) como prefixo.
Confira uma lista que identifica estas palavras reservadas (palavras-chave):
abstract as base bool
break byte case catch
char checked class const
continue decimal default delegate
do double else enum
19
event explicit extern false
finally fixed float for
foreach goto if implicit
in in (generic modifier) int interface
internal is lock long
namespace new null object
operator out out (generic modifier) override
params private protected public
readonly ref return sbyte
sealed short sizeof stackalloc
static string struct switch
this throw true try
typeof uint ulong unchecked
unsafe ushort using virtual
void volatile while
No Visual Studio as palavras reservadas são identificadas com uma cor azul.
20
Variáveis e tipos de dados Variáveis são espaços na memória do computador reservados para armazenar dados.
A referência aos dados de uma variável pode ser feita de duas maneiras:
1. Por valor, chamado de Value-Type;
2. Por referência, chamada de Reference-Type.
A principal diferença entre os dois tipos é que quando você faz referência a uma variável Value-
Type ela contém diretamente um dado, enquanto uma variável Reference-Type contém uma
referência ao dado. Vamos analisar um pouco melhor os dois tipos de variáveis:
Variável Value-Type:
Contém diretamente o dado;
Cada cópia da variável contém uma cópia do dado;
Operações em uma variável não afetam a sua cópia;
Exemplos de variáveis Value-Type são: integers, doubles, floats.
Variável Reference-Type:
Armazenam uma referência ao dado (conhecido como objetos).
Duas variáveis Reference-Type podem conter referência a um mesmo objeto.
Operações em uma afetam a outra;
Exemplos de References-Type são: strings, arrays, classes;
Os conceitos referentes às variáveis Reference-Type apresentados acima fazem mais sentido
quando trabalhamos com objetos em C#, já que todas as variáveis que armazenam objetos são do
tipo Reference-Type. Porém, nesta apostila não será tratado o assunto orientação a objetos, então
até este momento não será importante entender ainda o que significam objetos, classes, métodos.
Por enquanto, saiba apenas que a referência aos dados de uma variável pode ser feita de duas
maneiras: Value-Type ou Reference-Type. E que os principais tipos de dados primitivos que
utilizaremos em nossos estudos são do tipo Value-Type. Quando você estudar programação
orientada a objetos com C#, esses conhecimentos farão mais sentido.
Declarando variáveis
Antes de usar uma variável é necessário declará-la.
Declaramos uma variável especificando o tipo de dado seguido do identificador da variável, como no exemplo:
int contador;
O exemplo declara uma variável identificada como contador, do tipo integer. Ou seja, quando essa
variável for criada na memória, ela armazenará apenas números inteiros.
21
Podemos também declarar múltiplas variáveis do mesmo tipo, em uma única linha de comando, da
seguinte maneira:
int contador, numeros;
No exemplo anterior , estamos declarando duas variáveis do tipo inteiro, uma identificada como
contador e a outra como numeros.
O C# não permite a criação de duas ou mais variáveis locais com o mesmo identificador.
Nomeando variáveis
Existem recomendações para a escolha de identificadores de variáveis:
Não utilize o caractere de sublinhado nos identificadores de variáveis.
Não crie identificadores de variáveis que se diferenciem apenas pela sua forma. Exemplo:
minhaVariavel e MinhaVariavel;
Procure iniciar o identificador da variável com letra minúscula;
Quando o identificador da variável tiver mais de uma palavra, a primeira palavra inicia com letra
minúscula, e as demais com letra maiúscula (notação camelo ou camelCase). Exemplo: minhaVariavel,
nomeCompletoPessoa;
Tipos de Dados
Quando declaramos uma variável, alocamos espaço para a mesma no computador. Sempre que
declaramos uma variável precisamos dizer que tipo de dado pode ser armazenado nela. A linguagem de
programação C# possui vários tipos de dados predefinidos denominados tipos de dados primitivos.
A tabela a seguir mostra os tipos de dados primitivos mais utilizados no C# e o intervalo de valores
que podem ser armazenados neles:
C# Type Descrição Valor Possíveis de se armazenar Exemplos
bool Booleano Recebe os valores true (verdadeiro) ou false (falso)
bool ligado; ligado = true;
sbyte Números inteiros
Valores entre -128 e 127 8 bits com sinal bool valor; valor = 125;
byte Números inteiros
Valores entre 0 e 255 8 bits sem sinal byte valor; valor = 200;
short Números inteiros
Valores entre -32768 e 32767 16 bits com sinal (216) 1
short valor; valor = -30;
ushort Números inteiros
Valores entre 0 e 65535 16 bits sem sinal ushort valor; valor = 65000;
22
int Números inteiros
Valores entre –2147483648 e 2147483647
32 bits com sinal int valor; valor = 228371;
uint Números inteiros
Valores entre 0 e 4294967295 32 bits sem sinal uint valor; valor = 229981;
long Números inteiros
Valores entre –9223372036854775808 e 9223372036854775807
64 bits com sinal long valor; valor = -222001;
ulong Números inteiros
Valores entre 0 e 18446744073709551615
64 bits sem sinal ulong valor; valor = 8827332;
float Números de ponto flutuante
Valores entre 1.5 × 10−45 a 3.4 × 1038 com precisão de 7 digitos
32 bits float valor; valor = 4.873;
double Números de ponto flutuante
Valores entre 5.0 × 10−324 to 1.7 × 10308 com precisão de 15-16 dígitos
64 bits double valor; valor = 23.982;
decimal Valores monetários
Para cálculos financeiros e monetários com 28-29 dígitos.
128 bits decimal moeda; moeda = 1.99;
object Qualquer tipo object valor; valor = 6;
object nome; nome = “Elias”;
char Caractere único
Um caractere de 16 bits. char sexo; sexo = ‘M’;
string Sequência de caracteres
16 bits por caractere
string nome; nome = “Elias”;
1 O valor de 2
16 é 65.536.
Atribuindo valor às variáveis no C#
Quando declaramos uma variável no C#, precisamos atribuir um valor a ela. Uma variável não poderá
ser utilizada sem antes atribuir um valor a ela. Se tentarmos utilizar uma variável sem antes atribuir um valor a
ela, irá ocorrer um erro durante a compilação.
Exemplo de como atribuir um valor a uma variável:
int numeroVagas; numeroVagas = 10;
23
Primeiro declaramos a variável identificada como numeroVagas, do tipo inteiro. Depois atribuímos o
valor 10 a ela. O sinal de igual (=) atribui o valor que está à direita á variável que está à esquerda do operador
de atribuição. Assim, a variável numeroVagas recebe o valor 10.
Também podemos atribuir um valor a uma variável na mesma linha da sua declaração, como no
exemplo:
int numeroVagas = 10;
Outros exemplos:
char sexo = 'M';
byte numerosPequenos = 123;
double numerosComVirgula = 32.767;
24
Operadores
Operadores de Atribuição
A linguagem de programação C# possui vários operadores de atribuição. Considere que cada operador
de atribuição atribui o valor da direita do operador no local de armazenamento (variável) do lado esquerdo do
operador.
= Atribui o valor do operando do lado direito no operando do lado esquerdo (local de armazenamento). O valor do operando do lado direito deve ser do mesmo tipo do local de armazenamento do lado esquerdo (ou o valor do lado direito deve poder ser convertido implicitamente para o tipo do operando do lado esquerdo).
int numero = 10;
string nome = “Carlos”;
+= Atribui ao operando do lado esquerdo (local de armazenamento) a soma ou concatenação (dependendo do tipo de dado) do operando do lado esquerdo com o operando do lado direito. A expressão x += y é o equivalente à x = x + y; Se os operandos forem numéricos, realiza a adição dos mesmos. Se forem operandos do tipo string faz a concatenação dos mesmos.
x += y
-= Atribui ao operando do lado esquerdo (local de armazenamento) a subtração do operando do lado esquerdo com o operando do lado direito. A expressão x -= y é o equivalente à x = x - y;
x -= y
*= Atribui ao operando do lado esquerdo (local de armazenamento) a multiplicação do operando do lado esquerdo com o operando do lado direito. A expressão x *= y é o equivalente à x = x * y;
x *= y
/= Atribui ao operando do lado esquerdo (local de armazenamento) a divisão do operando do lado esquerdo com o operando do lado direito. A expressão x /= y é o equivalente à x = x / y;
x /= y
Operadores aritméticos
Utilizamos operadores aritméticos para a construção de expressões aritméticas. Uma expressão
aritmética retorna sempre um valor numérico:
Exemplos de expressões aritméticas:
1 + 2 -> retorna o valor numérico 3
2 + 4 * 2 -> retorna o valor numérico 10
2 - (4 * 2) -> retorna o valor numérico -6
25 Para a construção das expressões aritméticas no C#, podemos utilizar os seguintes operadores aritméticos:
+ Para tipos numéricos, é utilizado para realizar a soma dos tipos numéricos. Para tipos string é utilizado para a concatenação de strings.
int x = 1 + 5; resposta: x = 6
string y = “t” + “iago”; resposta: y = “tiago”
- Utilizado para a subtração dos tipos numéricos. int x = 6 - 2; resposta: x = 4
* Utilizado para a multiplicação dos tipos numéricos. int x = 6 * 2; resposta: x = 12
/ Utilizado para a divisão dos tipos numéricos. A divisão de tipos integer retorna um integer. A divisão de tipos ponto flutuante retorna ponto flutuante.
float x = 5.0 / 2; resposta: x = 2.5
% Retorna o resto da divisão entre dois números. int x = 5 / 2; resposta: x = 1
Operadores relacionais
Utilizamos os operadores relacionais para a construção de uma expressão condicional (também
chamada de expressão booleana). Diferente de uma expressão aritmética, que retorna sempre um valor
numérico, as expressões condicionais retornam sempre duas possibilidades de valor (true ou false). Exemplos
de expressões condicionais:
1 == 2 -> retorna false, já que 1 não é menor que 2
100 >= 100 -> retorna true, já que 100 é igual a 100.
Para a construção das expressões condicionais no C#, podemos utilizar os seguintes operadores relacionais:
== igual Em tipos Value-Type, o operador de igualdade retorna true (verdadeiro) se os valores de seus operandos forem iguais, e false, se não forem iguais. Em tipos Reference-Type, que não uma string, o operador de igualdade retorna true se os dois operandos se referem ao mesmo objeto. Para tipos string, compara os valores das strings.
1 == 2 retorna false
2 == 2 retorna true
“oi” == “oi” retorna true
> maior que Em tipos numéricos, retorna true se o primeiro operando for maior que o segundo operando. Em caso contrário, retorna false.
1 > 2 retorna false
11 > 1 retorna true
< menor que Em tipos numéricos, retorna true se o primeiro operando for menor que o segundo operando. Em caso contrário, retorna false.
1 < 2 retorna true
11 < 1 retorna false
>= maior ou igual que Em tipos numéricos, retorna true se o primeiro operando for maior ou igual que o segundo operando. Em caso contrário, retorna false.
1 >= 2 retorna false
11 >= 1 retorna true
11 >= 11 retorna true
<= menor ou igual que Em tipos numéricos, retorna true se o primeiro operando for menor ou igual que o segundo operando. Em caso contrário, retorna false.
1 <= 2 retorna true
11 <= 1 retorna false
11 <= 11 retorna true
26
!= diferente que Em tipos Value-Type, o operador retorna true (verdadeiro) se os valores de seus operandos são diferentes, e false, se forem iguais. Em tipos Reference-Type, que não uma string, o operador retorna true se os dois operandos não se referem ao mesmo objeto. Para tipos string, compara os valores das strings.
Operadores lógicos
Para que possamos juntar mais de uma expressão condicional, utilizamos os operadores lógicos.
Expressões com operadores lógicos sempre retornarão o valor true ou false.
Exemplo de utilização dos operadores lógicos em expressões condicionais:
1 > 2 AND 1 < 2 -> retorna false
1 > 2 OR 1 < 2 -> retorna true
1 <= 2 AND 3 > 2 -> retorna true
Para a construção das expressões condicionais com operadores lógicos no C#, podemos utilizar os
seguintes operadores lógicos:
! Operador de negação
Operador que nega seu operando. Retorna true se, e somente se, seu operando for false.
!true resposta: false
&& Operador condicional AND
Realiza a lógica AND para seus operandos do tipo booleano. Retorna true se os operandos conterem true.
true && true resposta true
false && true resposta false
false && false resposta false
|| Operador condicionar OR
Realiza a lógica OR para seus operandos do tipo booleano. Retorna true se um dos operandos conter true.
true || true resposta true
false || true resposta true
false || false resposta false
Operadores de incremento / decremento
A linguagem de programação C# possui alguns operadores de incremento / decremento de variáveis:
++ Operador de incremento
O operador de incremento incrementa seu operando em 1. O operador pode aparecer antes ou depois de seu operando. Quando o operador aparece antes de seu operando é uma operação de pré-incremento, onde o resultado da operação é o valor do operando após ele ser incrementado. Quando o operador aparece depois de seu operando é uma operação de pós-incremento, onde o resultado da operação é o valor do operando antes de ser incrementado.
int x = 1;
int y = ++x
resultado: y = 2 e x = 2
int x = 1;
int y = x++
resultado: y = 1 e x = 2;
-- Operador de O operador de decremento decrementa seu operando em 1. O operador pode aparecer antes ou depois de
int x = 1;
27
decremento seu operando. Quando o operador aparece antes de seu operando é uma operação de pré-decremento, onde o resultado da operação é o valor do operando após ele ser decrementado. Quando o operador aparece depois de seu operando é uma operação de pós-decremento, onde o resultado da operação é o valor do operando antes de ser decrementado.
int y = --x
resultado: y = 0 e x = 0
int x = 1;
int y = x--
resultado: y = 1 e x = 0;
Precedência de operadores
Algumas operações mais complexas podem exigir mais de um operador lógico e relacional. A sequência de
execução neste tipo de expressão é a seguinte:
1º Operadores relacionais
2º Operadores lógicos
Vejamos alguns exemplos:
Veículo = “Bicicleta” && Preço < 300
Primeiro são resolvidos os operadores relacionais, depois os operadores lógicos. No exemplo, o resultado será verdadeiro se Veiculo = “Bicicleta” for verdadeiro E se o preço for menor que 300.
Veiculo = “Carro” || Preço < 500 Primeiro são resolvidos os operadores relacionais, depois os operadores lógicos. No exemplo, o resultado será verdadeiro se Veiculo = “Carro” for verdadeiro OU se o preço for menor que 300.
!Preço < 100 Será Verdadeiro se o preço não for menor que 100.
Em expressões aritméticas, a precedência é a seguinte:
1º / divisão
2º * multiplicação
3º + soma
4º - subtração
Por exemplo, a expressão x + y * z é resolvida como x + (y * z) porque o operador * possui uma precedência
mais alta que o operador +.
28
Constantes Constantes são valores imutáveis que não podem ser modificadas durante o tempo de vida da
aplicação. Constantes são declaradas com o modificador const.
Os seguintes tipos de dados podem ser utilizados para constantes: bool, byte, sbyte, char, decimal,
Double, float, int, uint, long, ulong, object, short, ushort, string.
Constantes devem ser inicializadas quando são declaradas. Por exemplo:
const int meses = 12;
No exemplo, a constante identificada como meses possui sempre o valor 12 e não pode ser
modificada.
É útil utilizar constantes quando queremos utilizar nomes descritivos, ao invés de valores numéricos
literais. Por exemplo:
const double Pi = 3.14159; const int velocidadeDaLuz = 300000;
Nos exemplos acima, criamos duas constantes, uma que armazena o valor de Pi, e outra que armazena
a velocidade da luz em quilômetros por segundo. Sempre que precisarmos utilizar esses valores em alguma
instrução, não será necessário lembrar-se dos valores, já que faremos referência à constante.
29
Inserindo comentários no código C# Como em qualquer linguagem de programação, podemos inserir alguns comentários no código C# que
facilitam a compreensão do código por quem escreve e para terceiros.
Podemos criar comentários no C# de duas formas: o comentário de linha e o comentário de múltiplas
linhas. Veja um exemplo de comentário de linha:
string nome = "Tiago"; Console.WriteLine(nome); // Exibe o resultado
Agora um exemplo de comentário com múltiplas linhas que utiliza o delimitador /* para a abertura do
comentário e */ para o fechamento do comentário:
/* O trecho de código abaixo armazena a string "Tiago" na variável do tipo string identificada como nome. Na próxima instrução, o valor da variável é apresentada ao usuário na tela. */ string nome = "Tiago"; Console.WriteLine(nome); // Exibe o resultado
30
Estruturas de Decisão / Instruções de Seleção Estruturas de decisão são muito utilizadas na programação de computadores. Criamos estruturas de
decisão através de instruções de seleção. O objetivo de uma estrutura de decisão é direcionar o fluxo do
programa de acordo com uma condição, utilizando uma expressão condicional.
Primeiramente vamos reforçar o que é uma expressão condicional. Uma expressão condicional,
diferente de uma expressão aritmética que retorna um valor numérico, retorna sempre um valor booleano, ou
seja, verdadeiro (true) ou falso (false).
Uma expressão condicional é formada por dois operandos separados por um operador relacional.
Exemplo:
PREÇO < 100
PREÇO e 100 são os operandos, enquanto que o sinal de menor (<) é um operador relacional. Se preço
for menor que 100, então o resultado da expressão condicional é verdadeiro (true). Caso contrário o resultado
é falso (false).
No item “Operadores relacionais”, desta apostila, são apresentados os operadores relacionais
utilizados na linguagem de programação C#.
Agora que reforçamos a idéia do que é uma expressão condicional, vamos estudar o que é uma
ESTRUTURA DE DECISÃO. Uma estrutura de decisão é um código que utiliza as expressões condicionais para
direcionar o fluxo do programa. Utilizamos instruções de seleção para criar uma estrutura de decisão. As
principais estruturas de seleção utilizadas, não somente na linguagem C#, são o if e o switch.
Instrução de seleção if
Uma sintaxe possível do if é a seguinte:
if (EXPRESSÃO CONDICIONAL) { BLOCO DE CÓDIGO 1 } else { BLOCO DE CÓDIGO 2 }
Se o resultado da expressão condicional for verdadeiro (true) então o bloco de código 1 será
executado. Se a expressão for falsa (false), então o bloco de código 2 será executado.
Caso os blocos de código 1 e 2 tiverem apenas uma linha de código não será necessário usar os
colchetes, já que o uso de colchetes é obrigatório quando um bloco de código possuir mais que uma instrução.
A boa prática de programação indica que sempre se utilize os colchetes, mesmo quando um bloco de código
conter apenas uma instrução.
31 Mais alguns exemplos:
double salario = 1200; if (salario > 500) {
salario += 50; } else {
salario += 100; }
No exemplo acima, armazenamos o valor do salário na variável identificada como salario, do tipo
double, com o valor 1200. A instrução de seleção if verifica, através de uma expressão condicional, se o valor
da variável salário é maior que 500. Se a expressão condicional retornar verdadeiro (true), então a instrução
que atribui à variável salario o resultado da soma da variável salário com o valor 50 é executada. Se a
expressão for falsa (false), entra em ação o bloco de código de else com uma instrução que atribui à variável
salario a soma do valor da variável salario com 100;
double salario = 1200; if (salario < 500) salario += 100; else if ((salario >= 500) && (salario < 2000)) salario += 75; else salario += 50;
No exemplo acima, caso o valor de salario for menor que 500, a variável salario recebe o valor dela
somado com o valor 100. Senão, verifica se o salário for maior ou igual a 500 e menor que 2000, e em quando
positivo (verdadeiro), a variável salario recebe o valor da soma dela mesmo com o valor 75. Se o segundo if
tiver uma expressão condicional negativa (false), então o salário é somado com 50.
Perceba que na expressão condicional do segundo if, foi utilizado o operador lógico && (AND) que é
utilizado quando queremos testar mais de uma expressão condicional. Os outros operadores lógicos existentes
são o || (OR) e o ! (NOT) e são apresentados nesta apostila no item “Operadores lógicos”.
Instruções if em cascata
Como no exemplo anterior, é possível aninhar as instruções if dentro de outras instruções if. Assim, é
possível encadear uma sequência de expressões condicionais, que são testadas uma após a outra até que uma
delas seja avaliada como verdadeira (true). Exemplo do if em cascata:
int dia = 5; string diaSemana; if (dia == 0) diaSemana = "Domingo"; else if (dia == 1) diaSemana = "Segunda-Feira"; else if (dia == 2) diaSemana = "Terça-Feira"; else if (dia == 3) diaSemana = "Quarta-Feira";
32 else if (dia == 4) diaSemana = "Quinta-Feira"; else if (dia == 5) diaSemana = "Sexta-Feira"; else if (dia == 6) diaSemana = "Sábado"; else diaSemana = "Desconhecido";
No exemplo temos o uso da instrução de seleção if em cascata. A segunda instrução if só será
alcançada se a primeira for false. Da mesma forma, o terceiro if só será alcançado se o primeiro e o segundo if
forem false.
Instrução de seleção switch
A segunda estrutura de decisão que iremos estudar é a instrução de seleção switch.
O switch, assim como o if, direciona o fluxo do programa baseado no valor de uma expressão
condicional.
Algumas vezes, ao escrever uma instrução if em cascata, todos os ifs são semelhantes, porque todas
avaliam uma expressão condicional parecida, como é o caso do último exemplo apresentado de if em cascata.
A única diferença é que cada instrução if compara o resultado da expressão com um valor diferente.
Podemos escrever o mesmo exemplo apresentado anteriormente do if em cascata utilizando a
instrução de seleção switch.
A sintaxe de uma instrução switch é a seguinte:
switch ( expressão de controle )
{
case expressãoConstante:
instruções
break;
case expressãoConstante:
instruções
break;
...
default
instruções
break;
}
33
Por exemplo, vamos reescrever o último exemplo apresentado de if em cascata, porém utilizando a
instrução de seleção switch:
int dia = 5; string diaSemana; switch (dia) { case 0: diaSemana = "Domingo"; break; case 1: diaSemana = "Segunda-Feira"; break; case 2: diaSemana = "Terça-Feira"; break; case 3: diaSemana = "Quarta-Feira"; break; case 4: diaSemana = "Quinta-Feira"; break; case 5: diaSemana = "Sexta-Feira"; break; case 6: diaSemana = "Sábado"; break; default: diaSemana = "Desconhecido"; break; }
A instrução switch é muito útil, mas todas as instruções switch devem obedecer às seguintes regras:
A instrução switch só pode ser utilizada em tipos de dados primitivos, como int ou string. Com
qualquer outro tipo (incluindo float e double), você terá de utilizar uma instrução if.
Os rótulos de caso devem ser expressões constantes, como 42 ou “42”. Senão, deve ser utilizada uma
instrução if.
Os rótulos de caso devem ser expressões únicas. Ou seja, dois rótulos de caso não podem ter o mesmo
valor.
34
Estruturas de repetição / instruções de repetição Em determinado momento, há a necessidade de executarmos um determinado conjunto de comandos
várias vezes. Para que não precisemos rescrevê-los tantas vezes quanto o número de vezes que precisamos
que eles sejam executados, utilizamos estruturas de repetição. Alguns autores descrevem como estruturas de
laço ou estruturas de iteração. Em linguagens de programação, para que possamos criar estruturas de
repetição, utilizamos algumas instruções de repetição, onde encontramos as instruções while, for e do.
Cada uma das estruturas / instruções utiliza uma sintaxe particular, mas com a mesma função:
executar um determinado número de vezes um conjunto de instruções.
A determinação de quantas vezes o conjunto de comandos (instruções) será executado é definido pelo
programador, que deve explicitar no comando utilizado quantas vezes deverão ser executados os comandos.
Instrução de repetição while
A instrução de iteração while é utilizada para executar uma instrução repetidamente enquanto alguma
expressão condicional se mantiver verdadeira (true). A sintaxe de uma instrução while é a seguinte:
while (expressão condicional)
instrução
A expressão condicional é avaliada e, se for verdadeira, a instrução é executada e a expressão booleana é
avaliada novamente. Enquanto a expressão condicional se mantiver verdadeira, a instrução é repetida e a
expressão condicional é avaliada novamente. Este processo ocorre até que a expressão condicional seja
avaliada como falsa (false), e quando isso ocorre a instrução de iteração while termina e a execução continua
com a primeira instrução após a instrução while.
A expressão condicional deve retornar um valor booleano (true ou false);
A expressão condicional deve ser escrita entre parênteses;
Se a expressão condicional for avaliada como falsa na primeira avaliação, a instrução interior não será
executada;
Se for necessário executar duas ou mais instruções sob o controle de uma instrução while, deve ser
utilizado chaves para agrupar as instruções em um bloco.
Exemplo de uso da instrução while:
int cont = 0; while (cont < 10) { Console.WriteLine(cont); cont++; }
Todas as instruções while devem terminar em algum ponto. Um erro comum é esquecer de incluir uma
instrução para fazer com que a expressão condicional seja, em determinado momento, avaliada como false e
terminar a iteração, o que resulta em um programa que é executado de modo contínuo. No exemplo acima, a
instrução cont++ desempenha esse papel, permitindo que em determinado momento a expressão condicional
seja avaliada como false, finalizando a iteração da instrução while. De acordo com o exemplo anterior, diz-se
que a variável cont é uma variável de controle da instrução de repetição while, enquando que a instrução
cont++ é uma instrução de atualização da variável de controle.
35
Instrução de repetição for
Refletindo sobre a instrução de repetição while, perceba que foi necessário inicializar uma variável de
controle, realizar uma atualização da variável de controle e indicar uma expressão condicional:
inicialização da variável de controle
while (expressão condicional)
{
instruções .....
atualização da variável de controle
}
Com uma instrução for, é possível escrever uma versão mais formal desse tipo de construção,
combinando a inicialização da variável de controle, a expressão condicional e a atualização da variável de
controle. A instrução for é útil porque ao escrevê-la somos obrigados a lembrar dessas três partes. A sintaxe da
instrução for é a seguinte:
for (inicialização da variável de controle; expressão condicional; atualização da variável de controle)
instrução
O mesmo exemplo utilizado para a instrução while pode ser escrito da seguinte forma com a instrução for:
for (int cont = 0; cont < 10; cont++) Console.WriteLine(cont);
Perceba que o exemplo da instrução for acima realiza a mesma operação que o exemplo utilizado para a
instrução while:
int cont = 0; while (cont < 10) { Console.WriteLine(cont); cont++; }
Na instrução for, a inicialização ocorre uma vez no início da iteração (loop). Portanto, se a expressão
condicional for avaliada com true, a instrução interior do for será executada. A atualização da variável de
controle ocorre e então a expressão condicional é reavaliada. Enquanto a expressão condicional for
verdadeira, a instrução do bloco de for é executada.
Observe que a inicialização da variável de controle ocorre apenas uma vez, no início, e que a instrução
no bloco da instrução for é executada antes que a atualização da variável de controle ocorra, e que a
atualização da variável de controle ocorre antes da expressão condicional ser avaliada.
É considerada uma boa prática de programação utilizar chaves para delinear explicitamente o bloco de
instrução para o corpo das instruções if, while e for, mesmo quando o bloco contém uma única instrução.
36
Instrução de repetição do
As instruções while e for testam suas expressões condicionais no início da iteração (loop). Isso significa
que se a expressão condicional é avaliada como false no primeiro teste, o corpo do loop não é executado nem
mesmo uma vez. A instrução de repetição do é diferente. Sua expressão condicional é avaliada após cada
iteração e, portanto, o corpo é executado pelo menos uma vez.
A sintaxe da instrução do é a seguinte:
do
instrução
while (expressão condicional);
Como exemplo para a instrução do, faremos o mesmo que nas instruções while e for, em um exemplo que
escreve os valores inteiro de 0 a 9 no console (prompt de comando):
int cont = 0; do { Console.WriteLine(cont); cont++; } while (cont < 10);
Instruções break e continue
A instrução break é utilizada dentro das instruções de repetição para sair do corpo de uma instrução
de iteração (repetição). Já a instrução continue faz com que a o programa execute imediatamente a próxima
iteração do loop.
Exemplo de utilização da instrução break:
for (int i=0; i<=1000; i++){
if (i == 333) { break; } }
No exemplo acima, temos uma instrução de iteração for que inicializa uma variável de controle com o
valor zero (0), possui uma expressão condicional que retornará true enquanto que o valor da variável de
controle i for menor ou igual a 1000, e uma atualização da variável de controle i que incrementa o valor 1 a
cada iteração. Porém, quando o valor de i for igual a 333, será executado o corpo da instrução if que possui
uma instrução break. Ou seja, quando i conter o valor 333, o programa sairá do corpo da instrução de
repetição for, terminando a iteração. No exemplo acima, o valor da variável de controle i nunca passará de
333;
37 Exemplo de utilização da instrução continue:
int c = 0; string resposta; while (c < 10) { Console.WriteLine("Deseja incrementar a variável c? (Digite S para Sim)"); resposta = Console.ReadLine(); if (resposta != "S") { continue; } else { c++; } Console.WriteLine("O valor atual da variavel c é " + c); }
No exemplo acima a instrução de repetição while fará a iteração enquanto que o valor da variável de
controle c for menor que 10. No corpo da instrução while, é feito uma pergunta se o usuário deseja
incrementar a variável. Se o usuário digitar a string ‘S’ significa que a variável c será incrementada. Se a
resposta do usuário for diferente da string ‘S’ será executada a instrução continue, que interromperá a
iteração atual, pulando imediatamente para a próxima iteração, sem fazer a atualização da variável de
controle. Teste você mesmo o código do exemplo.
38
Arrays As variáveis, por definição, armazenam somente um valor de cada vez. Quando colocamos um valor
numa variável que já possuía um conteúdo, o conteúdo anterior é substituído pelo novo valor.
Se fosse necessário manipular um conjunto de dados do mesmo tipo, seria necessário declarar
diversas variáveis. Mas existe um tipo de variável que pode assumir vários valores de uma vez. Chamamos esse
tipo de array. Veremos ainda que um array pode possuir uma única dimensão ou várias dimensões. Um array
de única dimensão também é chamado por vários autores de vetor, e um array de várias dimensões,
geralmente duas, é chamado pelos mesmos autores de matriz.
Um array é uma das mais simples estruturas de dados na programação de computadores. É uma
sequência de elementos de dados. Na linguagem de programação C#, todos os elementos de um array possui
o mesmo tipo. Os elementos de array residem em um bloco contíguo de memória e são acessados por meio de
um índice.
Declarando variáveis de arrays
Em C#, uma variável de array é declarada especificando o tipo dos elementos que o array guardará,
seguido por um par de colchetes, seguido pelo identificador da variável. Os colchetes significam que a variável
é um array. Por exemplo, para declarar um array de variáveis do tipo int identificada como numeros, é
necessário escrever:
int[] numeros;
Criando uma instância de um array
Os arrays são variáveis do tipo Reference-Type, independente dos tipos de seus elementos internos.
Isso significa que uma variável de array referência um bloco contíguo de memória armazenando elementos de
array no heap da aplicação e não armazena seus elementos de array diretamente na variável.
O tamanho de um array deve ser especificado quando criamos uma instância de array. Exemplo de
como instanciar um array:
int[] numeros; numeros = new int[4];
Para criar uma instância de array, você utiliza a palavra-chave new seguido pelo nome do tipo de
elemento, seguido pelo tamanho do array que você está criando entre colchetes.
Na primeira linha do último exemplo criamos a variável de array. Na segunda linha instanciamos um
array de 4 posições na variável números. Poderíamos fazer o mesmo procedimento em uma única linha:
int[] numeros = new int[4];
Caso você tenha achado estranho o termo instância, não identificando muito bem do que se trata, e as
palavras new e heap descritas anteriormente, não se assuste. Estes termos são muito abordados quando se
estuda o paradigma de programação orientado a objetos, que não é o alvo de estudo desta apostila, como já
foi citado algumas vezes. No momento, apenas aceite que para a criação de arrays é necessário atribuir a uma
39 variável do tipo array uma instância de array, colocando-se o operador new, seguido do tipo dos elementos
internos do array, seguido pelo tamanho do array, descrito entre colchetes.
Inicializando variáveis de array
Quando você cria um array, todos os elementos desse array são inicializados com um valor padrão
dependendo do seu tipo (elementos do tipo int inicializam com o valor 0). Se você quiser, você poderá
modificar esse comportamento e inicializar os elementos de um array com valores específicos. É possível isso
fornecendo uma lista de valores separados por vírgulas e entre chaves. Por exemplo, para criar um array com
4 números inicializando os valores do array com 9, 3, 10 e 20, o exemplo seria escrito assim:
int[] numeros = new int[4]{9, 3, 10, 20};
Acessando um elemento de um array
Para acessar um elemento de um array, você deve formecer um índice indicando que elemento você
quer. Cada elemento de um array possui um índice, que começa sempre em zero (0). Ou seja, se um array
conter 4 elementos, o índice do primeiro elemento será zero (0), o do segundo elemento será um (1), do
terceiro será dois (2) e do quarto elemento será três (3).
Veja o exemplo:
int[] numeros = new int[4]{9, 3, 10, 20}; Console.WriteLine(numeros[1]);
No exemplo abaixo temos a criação de um array na variável numeros. Este array armazena 4
elementos do tipo int. Estes elementos já foram inicializados com os valores 9, 3, 10 e 20, respectivamente,
nas posições zero (0), um (1), dois(2) e três (3) do array. Na segunda instrução do exemplo, é escrito no
Console o valor do elemento de índice (posição) um (1) do array numeros. A referência ao índice um (1) do
array foi realizada colocando-se o índice 1 entre colchetes. No exemplo, será escrito no Console o número 3.
Outro exemplo:
int[] numeros = new int[4]{9, 3, 10, 20}; int numero = numeros[0];
No segundo exemplo foi criada uma variável do tipo int identificada como numero que recebe o valor
do elemento de índice zero (0) do array numeros. Ao final desse código a variável numero receberá o valor 9.
Percorrendo os elementos de arrays
Uma forma simples de percorrer os elementos de arrays é através de uma instrução de repetição específica
para arrays, o foreach. Exemplo:
int[] numeros = new int[4]{9, 3, 10, 20}; foreach (int numero in numeros) { Console.WriteLine(numero); }
40
A instrução de repetição foreach declara uma variável de iteração (neste exemplo, int numero) que
recebe automaticamente o valor de cada elemento do array (neste exemplo, o array numeros). O tipo da
variável de iteração deve ser do mesmo tipo dos elementos do array que se deseja percorrer. A instrução
foreach é a maneira preferida pelo programadores de iterar (percorrer) um array.
Também é possível percorrer um array utilizando a instrução de repetição for:
int[] numeros = new int[4]{9, 3, 10, 20}; for(int cont = 0; cont < numeros.Length; cont++) { Console.WriteLine(numeros[cont]); }
No exemplo acima, percorremos o array numerous utilizando a instrução de repetição for. É muito
simples. Inicializamos a variável de controle (cont) do for em 0, já que 0 é o índice (posição) inicial de um array.
A instrução for vai iterar enquanto que o valor da variável de controle for menor que o número de elementos
do array numeros. A cada iteração, a variável de controle é incrementada em 1.
Como um array é um objeto (mais uma vez temos uma referência á programação orientada a objetos),
utilizamos o método Length que retorna o número de elementos do array.
A cada iteração do for é escrito no Console o valor de uma posição do array, posição essa que é
definida pela variável de controle do for.
41
Bibliografia
SHARP, John. Microsoft Visual C# - Passo a Passo. Editora Bookman. Porto Alegre. 2008. 624 pg.
VIÉGAS, Fabian; ASSIS, Gilda Aparecida de. Algoritmos. Edit. Feevale. Novo Hamburgo. 2003. 100 pg.
STELLMAN, Andrew; GREENE, Jennifer. Use a Cabeça – C#. Editora Alta Books. Rio de Janeiro. 2008.
618 pg.
MSDN – Visual C# Developer Center.
Endereço: http://msdn.microsoft.com/pt-br/vcsharp/default
MSDN – Guia de Programação C#
Endereço: http://msdn.microsoft.com/pt-br/library/67ef8sbd.aspx
MSDN – Visual C#
Endereço: http://msdn.microsoft.com/pt-br/library/kx37x362.aspx