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