Apostila: Linguagem Cpluzzardi.w.pw/CSharp.doc · Web viewCSharp básico por Prof. Dr. Paulo Roberto Gomes Luzzardi facebook: Paulo Roberto Gomes Luzzardi e-mail: [email protected]

C#: A Linguagem de ProgramaçãoCSharp básico

por

Prof. Dr. Paulo Roberto Gomes Luzzardi

facebook: Paulo Roberto Gomes Luzzardie-mail: [email protected] e [email protected]

dropbox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m

Hostinger: http://pluzzardi.zz.mu e http://pluzzardi.w.pw

OS X Server (Apple): http://pluzzardi.no-ip.info:8080

Versão 1.0307-04-2014

Bibliografia recomendada:

Deitel, Harvey M. and Deitel, Paul J. C# Como Programar. Makron Books, 2003.

Pelotas, segunda-feira, 7 de abril de 2014 (09:40:57 am)

http://pluzzardi.no-ip.info:8080/

http://pluzzardi.w.pw/

http://pluzzardi.zz.mu/

https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m

https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m

mailto:[email protected]

mailto:[email protected]

Sumário

1. Arquitetura de um programa em C# 51.1 Elementos básicos de um programa em C#...............................................................51.2 Elementos básicos de um método estático em C#..............................................61.3 Como compilar um programa em C# via Terminal................................................61.4 Como executar um programa em C# via Terminal................................................61.5 Pasta contendo os projetos/arquivos em C#.......................................................6

2. Estrutura de um programa em C# 62.1 Identificadores em C#.......................................................................................................62.2 Comentários do programador em C#.............................................................................62.3 Regras gerais para escrever um programa em C#..............................................72.4 Palavras reservadas do C#..............................................................................................72.5 Declaração de variáveis em C#....................................................................................82.5.1 Onde as variáveis podem ser declaradas em C#.......................................82.5.2 Inicialização de variáveis em C#..................................................................10

2.6 Constantes em C#.................................................................................................................102.6.1 Constantes hexadecimais e octais em C#....................................................102.6.2 Constantes Strings em C#.....................................................................................112.6.3 Constantes especiais em C#.................................................................................12

2.7 Comandos do pré-processador do C#.........................................................................122.7.1 O comando using...........................................................................................................12

3. Tipos de dados em C# 123.1 Tipos básicos em C#..........................................................................................................123.2 Escrevendo uma classe em C#.......................................................................................133.2.1 Conceitos básicos sobre orientação à objetos.........................................133.2.2 Referência this em C#.................................................................................................193.2.3 Lista de Exercícios sobre Classes em C#.....................................................203.3 Sobrecarga de métodos em C#.......................................................................................313.4 Ponteiros, referências e endereços em C#........................................................31Operadores de ponteiros..........................................................................................................33

4. Métodos de entrada e saída de dados 334.1 Entrada e saída de dados usando TextReader e TextWriter....................334.2 Entrada e saída de dados utilizando Console.................................................344.3 Leitura de uma tecla em C# (pausa por teclado).........................................34

5. Operadores em C# 355.1 Operadores aritméticos em C#.....................................................................................355.2 Operadores relacionais em C#.....................................................................................355.3 Operadores lógicos em C#..............................................................................................355.4 Incremento e decremento em C#..................................................................................365.5 Operador de atribuição em C#.....................................................................................365.6 Casts em C#.............................................................................................................................375.7 Expressões em C#.................................................................................................................38

6. Métodos para funções matemáticas padrões em C# 386.1 Math.Abs.....................................................................................................................................386.2 Math.Asin..................................................................................................................................386.3 Math.Acos..................................................................................................................................386.4 Math.Atan..................................................................................................................................396.5 Math.Sin.....................................................................................................................................396.6 Math.Cos.....................................................................................................................................396.7 Math.Tan.....................................................................................................................................396.8 Math.Exp.....................................................................................................................................396.9 Math.Pow.....................................................................................................................................396.10 Math.Sqrt................................................................................................................................396.11 Math.Log..................................................................................................................................396.12 Convert.ToDouble...............................................................................................................40

2

6.13 Convert.Int?? (16, 32 ou 64)..................................................................................406.14 Convert.ToByte....................................................................................................................406.15 Math.Log10.............................................................................................................................406.16 Random.......................................................................................................................................406.17 Math.PI.....................................................................................................................................406.18 Conversão de graus para radianos.........................................................................41

7. Comandos em C# 417.1 Tipos de comandos em C#.................................................................................................417.1.1 Sequência em C#...........................................................................................................417.1.2 Seleção em C#................................................................................................................417.1.3 Repetição em C#...........................................................................................................43

7.2 Comando if em C#.................................................................................................................437.2.1 if encadeados em C#.................................................................................................44

7.3 O comando switch em C#...................................................................................................457.4 Comando while no C#..........................................................................................................487.5 O comando for no C#..........................................................................................................507.6 O loop do { } while no C#............................................................................................527.7 Interrupção de loops em C#.........................................................................................527.7.1 O comando break em C#.............................................................................................527.7.2 O comando continue no C#.....................................................................................53

7.8 O método Environment.Exit ().....................................................................................548. Saída formatada com String.Format 549. Lista de exercícios (comandos) 5710. Vetores, Matrizes e Strings em C# 6010.1 Vetores em C#......................................................................................................................6110.2 Strings em C#......................................................................................................................6210.3 Matrizes (Multidimensional) em C#......................................................................6310.4 Vetor de Strings em C#.................................................................................................6410.5 Inicialização de matrizes e vetores em C#...................................................6510.6 Inicialização de um vetor de caracteres em C#.........................................6510.7 Inicialização de matrizes multidimensionais em C#................................6510.8 Inicialização de vetores e matrizes sem tamanho em C#......................6510.9 Classificação de dados ou ordenação (sort) em C#..................................6710.10 Lista de exercícios (vetores).............................................................................69

11. Manipulação de Strings em C# 7211.1 Métodos para manipular Strings em C#...............................................................7211.2 Lista de exercícios (Strings)................................................................................74

12. Métodos estáticos definidos pelo programador em C# 7612.1 Valores de retorno em C#............................................................................................7712.2 Passagem de parâmetros por valor em C#..........................................................8012.3 Passagem de parâmetros por referênciaem C#.................................................8012.4 Métodos que devolvem valores não-inteiros em C#.....................................8212.5 Argumentos do Main (String [] args) em C#...................................................8212.6 Recursividade em C#........................................................................................................8412.7 Lista de Exercícios (métodos)................................................................................86

13. Classes existentes em C# 8813.1 Object (classe base de objetos) em C#.............................................................8913.2 List (lista tipada de objetos) em C#...............................................................8913.3 ArrayList (lista de arrays) em C#......................................................................9113.4 IList (lista de objetos indexados) em C#.....................................................9213.5 Stack (Pilha) em C#........................................................................................................9313.6 Queue (Fila) em C#..........................................................................................................94

14. Entrada e saída em disco (Arquivos) em C# 9514.1 Métodos para manipular arquivos em C#.............................................................9514.2 Abertura de um arquivo texto em C#....................................................................9514.3 Listar um diretório em C#.........................................................................................96

3

14.4 Manipulação de um arquivo texto de palavras em C#................................9814.5 Arquivo Texto em C#......................................................................................................10114.6 Lista de exercícios (arquivos)...........................................................................10514.7 Arquivos binários em C#............................................................................................109

15. Conceitos diversos em C# 11115.1 Operadores bit a bit em C#.....................................................................................11115.2 Formas abreviadas de C#............................................................................................112

16. Listas Lineares: Pilha, Fila e Fila Circular em C# 11216.1 Implementação de um lista em vetor em C#...................................................11316.2 Implementação de uma Pilha em C#.......................................................................11616.3 Implementação de uma Fila em C#.........................................................................11816.4 Implementação de uma Fila Circular em C#...................................................119

17. Tratamento de erros em C# 12117.1 Tratamento de exceções em C#................................................................................12217.2 Tratamento de erros na entrada de número inteiro em C#..................12217.3 Tratamento de erros: Divisão por zero em C#............................................123

18. Herança em C# 12418.1 Herança simples em C#.................................................................................................12418.2 Controle de acesso na definição de uma classe derivada em C#. . .12518.3 Tipos de acessos (especificadores de acesso) em C#...........................12618.4 Lista de exercícios sobre Herança em C#......................................................12818.4.1 Herança (primeiro) em C#.....................................................................................12818.4.2 Herança (segundo) em C#.......................................................................................12918.4.3 Herança (terceiro) em C#.....................................................................................130

19. Coletor de Lixo (Garbage Collector) em C# 13220. Construtor e finalizador em C# 13321. Data e Hora em C# 13422. Eliminar problemas na conversão na entrada de dados 135

4

1. Arquitetura de um programa em C#

1.1 Elementos básicos de um programa em C#

using diretiva;

namespace nomePrograma{ class nome_da_classe {

public static void Main(string[] args) // método principal {

corpo_da_classe; } }}

Exemplos:

// -------------------------------------------- Fonte: ProgA.cs

using System;

namespace ProgA{ class MainClass { public static void Main (string[] args) { float x = 3, y = 4, t = x + y;

Console.WriteLine ("Soma: " + t); // imprimir na tela } }}

Resultado do Programa:

Soma: 7

// -------------------------------------------- Fonte: ProgB.cs

using System;

namespace ProgB{ class MainClass { public static void Main (string[] args) { float x, y, t;

Console.Write ("x = "); x = float.Parse (Console.ReadLine()); // ler do teclado Console.Write ("y = "); y = float.Parse (Console.ReadLine()); // ler do teclado t = x + y; Console.WriteLine ("Soma: {0}", t); // forma alternativa de imprimir na tela } }}


x = 3y = 4Soma: 7

Programa Fonte: nome_da_classe.cs // ProgA.cs e ProgB.cs

1.2 Elementos básicos de um método estático em C#

5

static tipo_de_retorno nome_do_método(tipo_do_agumento nome_do_argumento, ...) {

corpo_do_método;return(valor_de_retorno);

}

1.3 Como compilar um programa em C# via Terminal

$ gmcs Prog1.cs <enter> // gera o arquivo “Prog1.exe”$

1.4 Como executar um programa em C# via Terminal

$ mono Prog1.exe <enter>$

1.5 Pasta contendo os projetos/arquivos em C#

/Users/pluzzardi/Projects // MacOsX

2. Estrutura de um programa em C#

2.1 Identificadores em C#

São os nomes criados pelo programador para fazer referência a namespaces, variáveis, constantes, argumentos, atributos e métodos.

Regras para a criação de identificadores:

O primeiro caracter pode ser uma letra ou sublinha ( _ ); Os caracteres seguintes devem ser letras, números ou sublinhas; Não é permitido a utilização de caracteres em branco (caracter

espaço); Podem ser letras maiúsculas e minúsculas.

Exemplos em variáveis: int numeroDentes = 32;double inflacao;char a, _a;

Exemplos em constantes: final char letra = ‘A’;final int tamanho = 10;final double d = 123.45;

Exemplos de argumentos: public int Div(int x, int y) { public bool strChr(String s, char ch) {

Exemplos de atributos: private int numElementos;private int []vetor;private int topo;

Exemplos em métodos: x = raizQuadrada(y);Console.WriteLine(“Valor: {0}”, inverso(n));

Observação: o método “inverso” é definido pelo programador (1/n).

2.2 Comentários do programador em C#

6

Os comentários do programador são linhas de código que não são compiladas pelo compilador, ou seja, servem apenas como anotações (documentação) para serem lembradas mais tarde (por exemplo, quando forem feitas manutenções no programa). Em C# os comentários podem ser feitos de duas formas:

/* Assim pode ser usado para comentário de várias linhas */// Isto é um comentário de uma linha apenas

Um comentário, pode ainda, utilizar várias linhas do programa. Veja o exemplo abaixo:

/* ---------------------------------------------------- Método: STRING Argumentos de entrada: x, y Argumentos de saída: c[], t[] Retorno: Sem Retorno------------------------------------------------------- */

2.3 Regras gerais para escrever um programa em C#

Um programa em CSharp é constituído de uma ou mais classes delimitadas por chaves { }, onde uma destas classes, obrigatoriamente possui um método chamada Main(). As principais regras são:

Letras maiúsculas e minúsculas são tratadas como caracteres diferentes; O formato do texto é livre; O método Main(){} especifica onde o programa começa e termina de ser

executado; Todos os comandos são terminados por ponto e vírgula; Todas as variáveis devem ser declaradas; { método começa a ser executado; } método termina de ser executado.

Programa exemplo: Imprimir a data no seguinte formato: [Data: dd/mm/aaaa].

// -------------------------------------------- Fonte: Prog1.cs

using System;

namespace Prog1{ class MainClass { public static void Main (string[] args) { int dia, mes, ano;

dia = 16; mes = 11; ano = 2013; // Console.WriteLine ("Data: " + dia + "/" + mes + "/" + ano); // forma alternativa de imprimir na tela Console.WriteLine ("Data: {0}/{1}/{2}", dia, mes, ano); } }}


Data: 16/11/2013

7

2.4 Palavras reservadas do C#

As palavras reservadas não podem ser utilizadas como identificadores pelo programador para nomes de namespaces, variáveis, constantes, argumentos, atributos ou métodos.

abstract event new structas explicit null switchbase extern object thisbool false operator throwbreak finally out truebyte fixed override trycase float params typeofcatch for private uintchar foreach protected ulongchecked goto public uncheckedclass if readonly unsafeconst implicit ref ushortcontinue in return usingdecimal int sbyte virtualdefault interface sealed volatiledelegate internal short voiddo is sizeof whiledouble lock stackallocelse long staticenum namespace string

Palavras reservadas não específicas ao C#

from join select yieldget let set grouporderby value into partial

2.5 Declaração de variáveis em C#

Sintaxe: tipo_dado_base lista_de_variáveis;

tipo_dado_base: deve ser um tipo de dado válido (bool, byte, sbyte, char, decimal, double, float, int, uint, long, ulong, object, short, ushort e String)lista_de_variáveis: um ou mais identificadores separados por vírgulas.

Exemplos:

int i, j ,k; float a, b; char ch;

2.5.1 Onde as variáveis podem ser declaradas em C#

Definidas fora de todas os métodos, incluindo o método Main() são chamadas de variáveis globais e podem ser acessadas em qualquer parte do programa. Estas variáveis são alocadas estaticamente na memória RAM (Random Access Memory – Memória de acesso randômico).

Quando definidas dentro de um método são chamadas de variáveis locais e só podem ser acessadas dentro deste método. Estas variáveis são alocadas dinamicamente na memória RAM.

8

Na declaração de parâmetros formais (argumentos) de um método. Sendo estas locais e alocadas dinamicamente na memória RAM.

Observação: Memória ROM (Read Only Memory – Memória somente de leitura).

Alocação de memória: Forma de reservar espaço de memória (RAM) para alocar uma informação (estática ou dinâmica).

Alocação estática de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM durante toda a execução do programa. Este espaço de memória é desalocado somente quando o programa acaba.

Alocação dinâmica de memória: Tipo de alocação de memória em que uma variável é alocada (tem um espaço reservado) na memória RAM temporariamente. Este espaço de memória é desalocado quando o espaço não é mais necessário (coleta automática de lixo – garbage collector).

Coletor de lixo explícito em C#: GC.Collect();

Programa exemplo: O programa realiza uma operação de potência Xy.

// -------------------------------------------- Fonte: Prog2.cs

using System;

namespace Prog2 {

class MainClass { static double resultado; // variável global // ---------------------------------- método estático POTENCIA

static double POTENCIA (double x, double y) { // corpo do método POTENCIA definido pelo programador // os argumentos x e y são variáveis locais

// definição de uma variável local double resp;

resp = Math.Exp (Math.Log (x) * y); return(resp); // retorno do método }

public static void Main(String[] args) {

// definição das variáveis locais double Base, Expoente;

// método que permite imprimir na tela em modo texto Console.Write ("Base: ");

// método que permite entrada de dados via teclado em terminal texto String s = Console.ReadLine ();

// método que converte String em float Base = float.Parse (s);

Console.Write ("Expoente: "); s = Console.ReadLine (); Expoente = float.Parse (s);

// chamada do método POTENCIA resultado = POTENCIA (Base, Expoente);

// método que imprime a resposta na tela

9

Console.WriteLine ("Resposta = {0}\n", resultado); } }}


Base: 3Expoente: 4Resposta = 81

Variáveis globais: resultadoVariáveis locais: base, expoente, resp, x, y

Compilar por linha de comandos (via terminal):

$ gmcs Prog2.cs <enter> // gera arquivo Prog2.exe$

Executar por linha de comandos (via terminal):

$ mono Prog2.exe <enter> // executa o arquivo Prog2.exe

2.5.2 Inicialização de variáveis em C#

Em CSharp é possível fornecer valores iniciais a maioria das variáveis ao mesmo tempo em que elas são declaradas, colocando um sinal de igual e uma constante após o nome da variável.

tipo_dado_base nome_da_variável = constante;Exemplos:

char ch = 'a'; // tipo_dado_base nome_da_variável = constante_caracterString s = “Pelotas”; // tipo_dado_base nome_da_variável = constante_stringint n = 0; // tipo_dado_base nome_da_variável = constante_inteirafloat y = 123.45f; // tipo_dado_base nome_da_variável = constante_realdouble z = 123.45;int [] v = {10, 20, 30}; // vetor unidimensionalint [,] t = {{1, 2}, {3, 4}, {5, 6}}; // matriz bidimensionalString [] cidade = {“Pelotas”, “Rio Grande”, “Poa”};char [] caracter = {‘S’, ‘s’, ‘N’, ‘n’};

2.6 Constantes em C#

Valores fixos que o programa não pode alterar. As constantes podem ser de qualquer tipo básico.

Tipo Exemplos de constantes

char 'a' 'n' '9'int 1 123 2100 -234float 123.23 4.34e-3String "CSharp" (classe String)

Forma de declarar uma constante tipada em C#:

const int numeroElementos = 10;const char ch = 'A';const float f = 1.234f;

2.6.1 Constantes hexadecimais e octais em C#

A linguagem de programação CSharp permite especificar constantes inteiras em octal. Uma constante octal começa com um 0 (zero) antes dos demais números.

10

Exemplos:

int hexadecimal = 0xf; // 15 em decimalint octal = 011; // 9 em decimal

Observações:

Qualquer número octal é formado por oito números ( 0 .. 7 ). Qualquer número hexadecimal é formado por dezesseis números

(0 ..9, A, B, C, D, E, F).

// ------------------------------------------------------- Fonte: Hexadecimal.cs

using System;

namespace Hexadecimal{ class MainClass { public static void Main (string[] args) { for (int valorDecimal = 0;valorDecimal < 16; valorDecimal++) { string valorHexadecimal = valorDecimal.ToString("X"); Console.WriteLine ("Hexadecimal: "+ valorHexadecimal); // int hexaToDecimal = int.Parse(valorHexadecimal, System.Globalization.NumberStyles.HexNumber); // Console.WriteLine("Hexadecimal para Decimal: " + hexaToDecimal); } } }}


Hexadecimal: 0Hexadecimal: 1Hexadecimal: 2Hexadecimal: 3Hexadecimal: 4Hexadecimal: 5Hexadecimal: 6Hexadecimal: 7Hexadecimal: 8Hexadecimal: 9Hexadecimal: AHexadecimal: BHexadecimal: CHexadecimal: DHexadecimal: EHexadecimal: F

2.6.2 Constantes Strings em C#

Uma String é um conjunto de caracteres delimitados por aspas duplas. Em C# existe uma classe específica para trabalhar com Strings (classe String).

Uma String é finalizada pelo caracter especial ‘\0’ (chamado de null).

Exemplo: String s = "Senac";‘\0’ é igual a null

0 1 2 3 4 5‘S’ ‘e’ ‘n’ ‘a’ ‘c’ null

Figura 1: StringMemória ocupada: 6 bytes

Observação: 'a' é diferente de "a"

11

'a' ocupa 1 byte na memória RAM (é do tipo char)"a" ocupa 2 bytes na memória (toda String é terminada com o caracter null)

A palavra null quer dizer nulo.

Vetor de Strings:

String [] s = {“Paulo”, “Roberto”, “Gomes”, “Luzzardi”};

Vetor de caracteres:

char [] s = {'U', 'C', 'P', 'e', 'l'}; char ch = ‘\0’;

2.6.3 Constantes especiais em C#

As constantes especiais são usadas para representar caracteres que não podem ser inseridos pelo teclado. São elas:

Tabela 1: Constantes especiais

2.7 Comandos do pré-processador do C#

2.7.1 O comando using

O comando using faz o compilador incluir um pacote de classes dentro do programa fonte. Cada pacote possui diversas classes.

using System;

Na URL abaixo você encontra as diversas api C#:

URL: http://msdn.microsoft.com/en-us/library/d11h6832%28v=vs.71%29.aspx

3. Tipos de dados em C#

3.1 Tipos básicos em C#

A tabela abaixo exibe os quinze (15) tipos de dados básicos que podem ser utilizados pelo programador para definir suas variáveis e constantes em C#. Na Tabela 2 são exibidos os tipos básicos, a faixa de valores válida, a quantidade de bits, e o tipo de framework (using) que cada tipo de dados ocupa ou representa na memória RAM (memória principal) ou em disco (quando armazenados na memória secundária).

Tabela 2: Tipos de dados

Tipo Faixa de valores Bits bytes Tipo de FrameWorkbool verdadeiro ou falso System.Booleanbyte 0 à 255 8 1 System.Bytesbyte -128 à 127 8 1 System.SBytechar um caracter 16 2 System.Char

12

Constante Significado‘\b’ Retrocesso‘\f’ Alimentação de formulário‘\n’ Nova linha‘\r’ Retorno de carro <CR>‘\t’ Tab horizontal‘\”’ Aspas duplas‘\’’ Aspas simples‘\\’ Barra invertida‘\o’ Constante octal‘\x’ Constante hexadecimal

http://msdn.microsoft.com/en-us/library/d11h6832(v=vs.71).aspx

decimal ±1.0 × 10−28 à ±7.9 × 1028 128 16 System.Decimaldouble ±5.0 × 10−324 à ±1.7 × 10308 64 8 System.Doublefloat ±1.5 × 10−45 à ±3.4 × 1038 32 4 System.Singleint -2147483648 à 2147483647 32 4 System.Int32uint 0 à 4294967295 32 4 System.UInt32long –9223372036854775808 à

922337203685477580764 8 System.Int64

ulong 0 à 18446744073709551615 64 8 System.UInt64object qualquer tipo System.Objectshort 32768 à 32767 16 2 System.Int16ushort 0 à 65535 16 2 System.UInt16string Seqüência de caracteres 16

(cada)2 System.String

3.2 Escrevendo uma classe em C#

3.2.1 Conceitos básicos sobre orientação à objetos

O paradigma orientado à objetos possui cinco componentes básicos: objetos (possui atributos e métodos), mensagens (chamada dos métodos), classes (tipo de dado), instâncias (criação de objetos de uma classe específica - new) e métodos (funções definidas pelo programador que manipulam os atributos).

Objetos, mensagens, classes, instâncias e métodos

Objetos são entidades lógicas que contém atributos (dados armazenados em variáveis) e métodos (funções) que manipulam estes dados. Um objeto pode ser definido através de um tipo de dado chamado classe (class).

Resumo:

a) Atributos: São as variáveis definidas e declaradas para cada objeto.

b) Métodos: São as funções definidas pelo programador que servirão para manipular os atributos.

c) Mensagens: São as chamadas dos métodos.d) Classe: É um tipo de dado definido por class. Uma classe não é

um objeto, é sim uma descrição do objeto.e) Instância: Os objetos são instâncias de uma classe, ou seja, é

criado um objeto pertencente a uma classe específica. O objeto pode responder chamadas dos métodos e armazenar informações nos atributos.

Resumidamente, objetos são instâncias de classes que respondem as mensagens através dos métodos escritos pelo programador.

Uma linguagem de programação orientada à objetos pode suportar ou implementar seis propriedades: abstração, encapsulamento, polimorfismo, herança, associação (agregação e composição) e classes abstratas e concretas.

Exemplo de uma classe “ Vetor ” em C# :

// -------------------------------------------------------- Prog3.cs

using System;

namespace Prog3{ public class Vetor

13

{ // -------------------------- atributos

private int[] vetor; private int n; private int max;

// ------------------------------ construtor

public Vetor(int tam) // obrigado o modificador de acesso public { max = tam; vetor = new int[max]; n = 0; }

// ------------------------------ add

public void add(int valor) { if (n < max) { vetor[n] = valor; n++; } else { Console.WriteLine("Erro: Vetor excedeu Limite"); } }

// ------------------------------ exibe

public void exibe() { Console.Write("Vetor: ["); for (int i = 0; i < n; i++) { Console.Write(vetor[i] + " "); } Console.WriteLine("]"); } }}

// ----------------------------------------------- Prog3.cs

using System;

namespace Prog3{ class MainClass { public static void Main (string[] args) { Vetor v = new Vetor (5); // declaração do objeto “v” da classe Vetor

v.add (10); v.add (20); v.add (30); v.add (40); v.add (50); v.exibe (); v.add (60); // testar o limite do vetor de 5 elementos v.exibe (); } }}


Vetor: [10 20 30 40 50 ]Erro: Vetor excedeu LimiteVetor: [10 20 30 40 50 ]

Tente implementar os seguintes métodos para a classe Vetor:

v.remove(); v.exibe();

14

Console.WriteLine("Total de Elementos: " + v.length()); int pri = v.primeiro(); Console.WriteLine("Primeiro: " + pri); int ult = v.ultimo(); Console.WriteLine("Último: " + ult); int elemento = 20; bool flag = v.existe(elemento); if (flag) { Console.WriteLine("Status: Existe elemento 20"); } else { Console.WriteLine("Status: Não Existe elemento 20"); } v.removeElemento(elemento); flag = v.existe(elemento); if (flag) { Console.WriteLine("Status: Existe elemento " + elemento); } else { Console.WriteLine("Status: Não Existe elemento " + elemento); } v.exibe(); v.removePosicao(1); v.exibe();


Vetor: [10 20 30 40 50 ]Erro: Vetor excedeu LimiteVetor: [10 20 30 40 50 ]Vetor: [10 20 30 40 ]Total de Elementos: 4Primeiro: 10Último: 40Status: Existe elemento 20Status: Não Existe elemento 20Vetor: [10 30 40 ]Vetor: [10 40 ]

// -------------------------------------------------------- Prog3a.cs

using System;

namespace Prog3a{ class MainClass { public static void Main (string[] args) { Vetor v = new Vetor (5);

v.add (10); v.add (20); v.add (30); v.add (40); v.add (50); v.exibe (); v.add (60); // testa o limite do vetor de 5 elementos v.exibe (); v.remove(); v.exibe(); Console.WriteLine("Total de Elementos: " + v.length()); int pri = v.primeiro(); Console.WriteLine("Primeiro: " + pri); int ult = v.ultimo(); Console.WriteLine("Último: " + ult); int elemento = 20; bool flag = v.existe(elemento); if (flag) { Console.WriteLine("Status: Existe elemento 20"); } else { Console.WriteLine("Status: Não Existe elemento 20"); } v.removeElemento(elemento); flag = v.existe(elemento); if (flag) { Console.WriteLine("Status: Existe elemento " + elemento);

15

} else { Console.WriteLine("Status: Não Existe elemento " + elemento); } v.exibe(); v.removePosicao(1); v.exibe(); } }}

Solução do Problema:

using System;

namespace Prog3a{ public class Vetor { // -------------------------- atributos

private int[] vetor; private int n; private int max;

// ------------------------------ construtor

public Vetor(int tam) // é obrigado o modificador de acesso public { max = tam; vetor = new int[max]; n = 0; }

// ------------------------------ add

public void add(int valor) { if (n < max) { vetor[n] = valor; n++; } else { Console.WriteLine("Erro: Vetor excedeu Limite"); } }

// ------------------------------ remove

public void remove() { if (n > 0) { n--; } else { Console.WriteLine("Erro: Vetor vazio"); } }

// ------------------------------ removeElemento

public void removeElemento(int num) { if (n == 0) { Console.WriteLine ("Erro: Vetor vazio"); } else { for (int i = 0; i < n; i++) { if (num == vetor[i]) { for (int j = i; j < n; j++) { vetor [j] = vetor [j + 1]; } n--; break; } } } }

16

// ------------------------------ removePosicao

public void removePosicao(int pos) { int fim = length (); if (pos < 0 || pos > fim) { Console.WriteLine ("Erro: Posição Inválida"); } else { for (int i = pos; i < n; i++) { vetor [i] = vetor [i + 1]; } n--; } }

// ------------------------------ exibe

public void exibe() { Console.Write("Vetor: ["); for (int i = 0; i < n; i++) { Console.Write(vetor[i] + " "); } Console.WriteLine("]"); }

// ------------------------------- length

public int length() { return(n); }

// ------------------------------- primeiro

public int primeiro() { return(vetor[0]); }

// ------------------------------- ultimo

public int ultimo() { return(vetor[n-1]); }

// ------------------------------- existe

public bool existe(int num) { bool exist = false;

for (int i = 0; i < n; i++) { if (num == vetor[i]) { exist = true; break; } } return(exist); } }}


Vetor: [10 20 30 40 50 ]Erro: Vetor excedeu LimiteVetor: [10 20 30 40 50 ]Vetor: [10 20 30 40 ]Total de Elementos: 4Primeiro: 10Último: 40Status: Existe elemento 20

17

Status: Não Existe elemento 20Vetor: [10 30 40 ]Vetor: [10 40 ]

Uma linguagem de programação, orientada à objetos, pode suportar e/ou implementar seis (6) propriedades: abstração, encapsulamento, polimorfismo, herança, associação (agregação e composição) e classes abstratas e concretas.

Abstração

Objetos devem representar dados do mundo real.

Encapsulamento (“encapsulação”)

Os objetos possuem internamente atributos e métodos agrupados no mesmo local, onde os métodos manipulam os atributos. Esta característica protege os dados (atributos) de alterações indevidas, somente os membros da classe podem acessar os atributos, desde que eles sejam privados (private) ou protegidos (protected) (caso das classes derivadas, que herdam o direito de acesso aos atributos).

Polimorfismo (grego: “muitas formas”)

É a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem padrão. Significa que o nome de um objeto pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada principalmente na sobrecarga de métodos, sobrecarga de operadores e nas classes abstratas, onde os métodos são declarados mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal (inclusão [como em Java, por exemplo, List lista = new LinkedList();] e paramétrico [templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores).

Sobrecarga de operador: Permite sobrecarregar operadores para realizar diferentes tipos de operações;

Sobrecarga de método: Permite que um método retorne diferentes tipos de informações e aceite argumentos de vários tipos, inclusive com quantidade diferentes de argumentos;

Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de código. Classes concretas implementam todos os métodos e podem ser instanciadas.

Herança

É o processo pelo qual uma classe de objetos pode adquirir as propriedades de outra classe de objetos, em outras palavras, um objeto herda as características de outro (herança simples) ou vários objetos (herança múltipla). A classe Base é chamada de superclasse, enquanto a classe derivada pode ser chamada de subclasse.

18

http://pt.wikipedia.org/wiki/M%C3%A9todo_abstrato

http://pt.wikipedia.org/wiki/M%C3%A9todo_abstrato

Associação

É um vínculo que permite que objetos de uma ou mais classes se relacionem entre si. Esta associação pode ser: unária (o vínculo é entre objetos da mesma classe), binária (vínculo ocorre entre dois objetos de classes diferentes) ou múltipla (vínculo ocorre entre mais de 2 objetos de classes diferentes). Cada associação pode possuir características de (a) cardinalidade ou multiplicidade (indica quantos objetos são possíveis em cada associação) e (b) navegação (existe a possibilidade dos objetos acessarem outros objetos da mesma associação).

Uma associação pode ser de duas formas: agregação (Relacionamento com características onde existe um grau menos intenso de coesão entre os elementos, pode haver um certo grau de independência) ou composição (relacionamento com características onde existe um alto grau de coesão e total grau de dependência entre os elementos).

Classes Abstratas e Concretas

Criada para representar entidades e conceitos abstratos. Uma classe abstrata é sempre uma superclasse ou classe base que não possui instâncias. Ela define apenas o modelo (como um template em C++) para uma funcionalidade e fornece uma implementação incompleta chamada de parte genérica sendo compartilhada por um conjunto de classes derivadas ou subclasses. As classes derivadas completam as funcionali-dades da classe abstrata anexando um comportamento específico. Classes abstratas possuem métodos abstratos. Esses métodos são implementados nas suas classes derivadas concretas com o objetivo de definir o comportamento específico. O método abstrato define apenas a assinatura do método não contendo nenhum código. Classes concretas implementam seus métodos e permitem instanciar objetos. Classes concretas não possuem métodos abstratos quando são classes derivadas de uma classe abstrata.

Vantagens da Orientação a Objetos: (a) reutilização de código, (b) proteção aos dados; (c) organização ou estruturação dos dados em forma de classes e objetos; (d) sobrecarga de métodos e de operadores; (e) criação de pacotes de classes; (f) ter um conjunto de pacotes pré-definidos e (g) permitir ao desenvolvedor criar seus próprios pacotes.

Em C#, o programador pode criar suas próprias classes. Uma classe possui duas partes distintas: atributos (variáveis) e métodos (funções ou procedimentos) que manipulam estes atributos.

3.2.2 Referência this em C#

Em C#, quando um método de uma classe é chamado, é passado automaticamente um argumento que é uma referência para o objeto que gerou a chamada. Esta referência é chamada “this”, ou seja, a referência “this” referencia o objeto que chamou o método.

Cada objeto tem acesso a uma referência a ele próprio, chamada this. Esta referência faz referências aos atributos e métodos de um objeto.

Exemplo da utilização da referência this em C#:

// -------------------------------------------------------- Data.cs

19

using System;

namespace Prog4{ public class Data { // ------------------------------- atributos

private int dia, mes, ano;

// ------------------------------- construtor

public Data(int dia, int mes, int ano) { this.dia = dia; this.mes = mes; this.ano = ano; }

public String toString() { String data = "Data: " + String.Format("{0:00}", dia) + "/"; data = data + String.Format ("{0:00}", mes) + "/"; data = data + String.Format ("{0:0000}", ano) ; return(data); } }}

// ----------------------------------------------------------- Prog4.cs

using System;

namespace Prog4{ class MainClass { public static void Main (string[] args) { Data data = new Data(7, 6, 2013);

Console.WriteLine (data.toString ()); } }}


Data: 07/06/2013

3.2.3 Lista de Exercícios sobre Classes em C#

3.2.3.1 Dado o seguinte programa principal, implemente a classe Circulo e seus métodos:

// ------------------------------------------ TestaCirculo.cs

using System;

namespace TestaCirculo{ class MainClass { public static void Main (string[] args) { Circulo circ = new Circulo();

circ.setaRaio(3); circ.calculaArea(); double area = circ.getArea(); Console.WriteLine("Área: " + area); } }}

20

2Observação: area = pi . raio onde pi é 3.1416

Círculodouble area, raio

setaRaiocalculaArea

getArea Diagrama de classe

3.2.3.2 Dado o seguinte programa principal, implemente a classe PesoIdeal e seus métodos:

// --------------------------------------------- Peso.cs

using System;

namespace Peso{ class MainClass { public static void Main (string[] args) { PesoIdeal piHomem = new PesoIdeal('H', 1.67); PesoIdeal piMulher = new PesoIdeal('m', 1.65);

piHomem.calculaPesoIdeal(); Console.WriteLine("Peso Ideal Homem: " + piHomem.getPesoIdeal());

piMulher.calculaPesoIdeal(); Console.WriteLine("Peso Ideal Mulher: " + piMulher.getPesoIdeal()); } }}


Peso Ideal Homem: 63,41Peso Ideal Mulher: 57,77

Cálculo do Peso Ideal:

PIH = 72,7 x altura – 58PIM = 62,1 x altura – 44,7

PesoIdealdouble altura, pi

char sexocalculaPesoIdeal

getPesoIdeal Diagrama de classe

3.2.3.3 Dado o seguinte programa principal, implemente a classe CPF e seus métodos:

// --------------------------------------------------------------- ValidaCPF.cs

using System;

namespace ValidaCPF{ class MainClass { public static void Main (string[] args) { String s = "123456789"; CPF cpf = new CPF(s);

int digitoVerificador = cpf.verificaCPF(); Console.WriteLine("Digito verificador: {0:00} ", digitoVerificador); Console.WriteLine("CPF: {0}-{1:00}", s , digitoVerificador);

21

} }}


Digito verificador: 09CPF: 123456789-09

CPFString cpfint digitoverificaCPF

Diagrama de classe

Como calcular os Dígitos do CPF:

Entrada: CPF: 123456789

1) Primeiramente pega-se os dígitos da base do CPF e se faz a soma da multiplicação individual dos dígitos, iniciando por 10 e indo até 2 como exemplificado abaixo:

1 2 3 4 5 6 7 8 9 x x x x x x x x x 10 9 8 7 6 5 4 3 2 -- -- -- -- -- -- -- -- --10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 = 210

2) O valor do primeiro dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a seguir:

11 - (210 % 11) = 10

3) O cálculo do segundo dígito é feito da mesma forma que o primeiro, porém com os 9 dígitos da base do CPF e o primeiro dígito verificador encontrado, iniciando por 11 e indo até 2.

1 2 3 4 5 6 7 8 9 0 x x x x x x x x x x11 10 9 8 7 6 5 4 3 2-- -- -- -- -- -- -- -- -- --11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0 = 255

4) O valor do segundo dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado conforme vê-se a seguir:

11 - (255 % 11) = 9

Saída: CPF válido é 123.456.789-09 ou 123456789-09

3.2.3.4 Dado o seguinte programa principal, implemente a classe DiaSemana e seus métodos:

// ------------------------------------------------------- TestaDiaSemana.cs

using System;

namespace TestaDiaSemana{ class MainClass { public static void Main (string[] args) { DiaSemana dia = new DiaSemana(17, 11, 2013);

dia.verificaDiaSemana(); dia.exibeDiaSemana(); } }}

22


Dia da Semana: Terça-Feira

DiaSemanaint dia, mes, anoString semama

verificaDiaSemanaexibeDiaSemana

Diagrama de classe

Como calcular o Dia da Semana:

Deve-se calcular o Dia do Século:

Para qualquer cálculo com datas é essencial que se disponha do Dia do Século para a(s) data(s) em questão. O Dia do século é o número de dias decorridos desde o inicio do século (1º de janeiro de 1901) até a data em questão. Se usa como referência 1901 porque a maioria das datas com as quais se trabalha ainda são do século passado. Lá por 2040 ou mais poderá se mudar para 2001.

A fórmula (válida para datas entre 1901 e 2099) é a seguinte:

Dia_do_Seculo = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) *31 - [(mês * 4 + 23) DIV 10] * [(mês + 12) DIV 15] + [(4 - ano MOD 4) DIV 4) * [(mês + 12) DIV 15]

Entrada: Dia [1..31]: 18Mês [1..12]: 12Ano [1901..2099]: 2007

Dia_do_Seculo = 39.068 (para a data acima)

Verificação do Dia da Semana:

Para saber o Dia_da_Semana basta dividir por 7 e entrar com o resto na tabela abaixo:

0 Segunda1 Terça2 Quarta3 Quinta4 Sexta5 Sábado6 Domingo

Saída: 18/12/2007 é uma Terça-Feira

Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de dois números

3.2.3.5 Dado o seguinte programa principal, implemente a classe Data e seus métodos:

// ------------------------------------------------- TestData.cs

using System;

namespace TestData{ class MainClass { public static void Main (string[] args) { Data data = new Data();

data.setaData(17, 11, 2013); data.extenso(); } }}


23

Data: 17 de novembro de 2013

Dataint dia, mes, ano

setaDataextenso

Diagrama de classe

3.2.3.6 Implemente os métodos “sortForcaBruta” e “bubleSort” na classe Vetor vista no item 3.2.

// --------------------------------------------------- Ordena.cs

using System;

namespace Ordena{ class MainClass { public static void Main (string[] args) { Vetor v = new Vetor (5);

v.add (30); v.add (20); v.add (10); v.add (50); v.add (40); v.exibe (); v.add (60); // testar o limite do vetor de 5 elementos v.exibe (); v.sortForcaBruta(); v.exibe(); // v.bubbleSort(); // v.exibe(); } }}

3.2.3.7 Dado o seguinte programa principal, implemente a classe Pessoa e seus métodos.

// --------------------------------------------------- TestaPessoa.cs

using System;

namespace TestaPessoa{ class MainClass { public static void Main (string[] args) { Pessoa p1 = new Pessoa(); Pessoa p2 = new Pessoa(); Pessoa p3 = new Pessoa();

p1.setaDados("Paulo Roberto", 1962, 'm'); p2.setaDados("Renato Luis", 1965, 'm'); p3.setaDados("Francisco Carlos", 1959, 'm'); p1.calculaIdade(); p2.calculaIdade(); p3.calculaIdade(); p1.exibePessoa(); p2.exibePessoa(); p3.exibePessoa(); } }}


24

Nome: Paulo RobertoIdade: 51 ano(s)Sexo: MasculinoNome: Renato LuisIdade: 48 ano(s)Sexo: MasculinoNome: Francisco CarlosIdade: 54 ano(s)Sexo: Masculino

PessoaString nome, ano

char sexosetaDados

calculaIdadeexibePessoa

Diagrama de classe


// ----------------------------------------------------- TestaPessoaVetor2.cs

using System;

namespace TestaPessoa2{ class MainClass { public static void Main (string[] args) { Pessoa [] pessoa = new Pessoa[3];

pessoa[0] = new Pessoa(); pessoa[0].setaDados("Paulo Roberto", 1962, 'm'); pessoa[0].calculaIdade(); pessoa[0].exibePessoa();

pessoa[1] = new Pessoa(); pessoa[1].setaDados("Renato Luis", 1960, 'm'); pessoa[1].calculaIdade(); pessoa[1].exibePessoa();

pessoa[2] = new Pessoa(); pessoa[2].setaDados("Francisco Carlos", 1959, 'm'); pessoa[2].calculaIdade(); pessoa[2].exibePessoa(); } }}


Nome: Paulo RobertoIdade: 51 ano(s)Sexo: MasculinoNome: Renato LuisIdade: 53 ano(s)Sexo: MasculinoNome: Francisco CarlosIdade: 54 ano(s)Sexo: Masculino

PessoaString nome, ano

char sexosetaDados

calculaIdadeexibePessoa

Diagrama de classe


25

// -------------------------------------------------- Sort.cs

using System;

namespace Sort{ class MainClass { public static void Main (string[] args) { Pessoa pessoa = new Pessoa(7);

pessoa.insereDados("Beatriz", 11); pessoa.insereDados("Debora", 13); pessoa.insereDados("Fátima", 15); pessoa.insereDados("Geni", 16); pessoa.insereDados("Carla", 12); pessoa.insereDados("Eva", 14); pessoa.insereDados("Ana", 10); pessoa.exibeDados(); pessoa.sort(); pessoa.exibeDados(); } }}


Lista de PessoasNome: Beatriz Idade: 11Nome: Debora Idade: 13Nome: Fátima Idade: 15Nome: Geni Idade: 16Nome: Carla Idade: 12Nome: Eva Idade: 14Nome: Ana Idade: 10Lista de PessoasNome: Ana Idade: 10Nome: Beatriz Idade: 11Nome: Carla Idade: 12Nome: Debora Idade: 13Nome: Eva Idade: 14Nome: Fátima Idade: 15Nome: Geni Idade: 16

PessoaString [] nomeint [] idade

int ninsereDadosexibeDados

sort Diagrama de classe

3.2.3.10 Dado o seguinte programa principal, implemente a classe Agenda e seus métodos.

// ------------------------------------------------------- TestAgenda.cs

using System;

namespace TestAgenda{ class MainClass { public static void Main (string[] args) { Agenda agenda = new Agenda(5);

agenda.insereTelefone("Ana", "99811234"); agenda.insereTelefone("Beatriz", "99812345"); agenda.insereTelefone("Carla", "99813456"); agenda.insereTelefone("Debora", "99814567");

26

agenda.insereTelefone("Eva", "99815678"); agenda.insereTelefone("Fátima", "99816789"); String fone = "99815678"; String nome = agenda.consultaNome(fone); if (nome.CompareTo("") != 0) { Console.WriteLine("Nome: " + nome + " - Telefone: " + fone); } else { Console.WriteLine("ERRO: Usuário não Encontrado"); } fone = "99810123"; nome = agenda.consultaNome(fone); if (nome.CompareTo("") != 0) { Console.WriteLine("Nome: " + nome + " - Telefone: " + fone); } else { Console.WriteLine("ERRO: Usuário não Encontrado"); } } }}


ERRO: Excedeu limite do VetorNome: Eva - Telefone: 99815678ERRO: Usuário não Encontrado

AgendaString [] nomeString [] fone

int nint max

insereTelefoneconsultaNome

Diagrama de classe

Exemplo da definição de uma classe “ Data ” :

// ----------------------------------------------- Fonte: Data.cs

using System;

namespace TestaData{ public class Data { private int dia, mes, ano; // atributos da classe

public Data () { }

public Data(int dia, int mes, int ano) { // construtor da classe this.dia = dia; this.mes = mes; this.ano = ano; }

// ------------------------------- sobrecarga do método toString

public String toString() { return(dia + "/" + mes + "/" + ano); }

}}

Programa exemplo que utiliza a classe “ Data ” :

// --------------------------------------------- Fonte: TestaData.csusing System;

namespace TestaData{

27

class MainClass { public static void Main (string[] args) { Data data = new Data(19, 11, 2013);

Console.WriteLine(data.toString()); } }}

Exemplo da definição de uma classe “ Calculadora ” :

// -------------------------------------------------------- Fonte: Calculadora.cs

using System;

namespace Calc{ public class Calculadora { // ............................................. lista de atributos da classe private double x, y, resp; private char op; private int erro;

// ............................................. métodos públicos da classe public Calculadora () // construtor { erro = 0; }

// ---------------------------- entradaDados public void entradaDados () { Console.Write ("Digite um Valor: "); String s = Console.ReadLine (); x = Convert.ToDouble (s); do { Console.Write ("Operador [+ - * / Rr Pp Ss Cc Tt]: "); s = Console.ReadLine (); op = s [0]; } while (!strChr ("+-*/RrPpSsCcTt", op)); if (!strChr ("RrSsCcTt", op)) { Console.Write ("Digite outro Valor: "); s = Console.ReadLine (); y = Convert.ToDouble (s); } }

// ---------------------------- operaCalculadora public void operaCalculadora () { switch (op) { case '+': resp = soma (x, y); break; case '-': resp = subtracao (x, y); break; case '*': resp = multiplicacao (x, y); break; case '/': if (y == 0) erro = 1; // divisao por zero else resp = divisao (x, y); break; case 'R': case 'r': if (x < 0) erro = 2; // raiz negativa else

28

resp = raizQuadrada (x); // Raiz Quadrada break; case 'P': case 'p': resp = power (x, y); // potencia break; case 'S': case 's': resp = seno (x); // seno break; case 'C': case 'c': resp = cosseno (x); // cosseno break; case 'T': case 't': if (x == 90 || x == 180) { erro = 3; } else { resp = tangente (x); // tangente } break; } }

// ---------------------------- exibeCalculadora public void exibeCalculadora () { if (erro == 1) { Console.WriteLine ("Erro: Divisao por Zero"); } else { if (erro == 2) { Console.WriteLine ("Erro: Raiz Complexa"); } else { if (erro == 3) { Console.WriteLine ("Erro: Tangente Infinita"); } else { Console.WriteLine ("Resposta: " + resp); } } } }

// ................................................ métodos privados da classe // ---------------------------- strChr private bool strChr (String s, char ch) { for (int i = 0; i < s.Length; i++) { if (s [i] == ch) { return(true); } } return(false); }

// ---------------------------- soma private double soma (double x, double y) { return(x + y); }

// ---------------------------- subtracao private double subtracao (double x, double y) { return(x - y); }

// ---------------------------- multiplicacao private double multiplicacao (double x, double y) { return(x * y); }

// ---------------------------- divisao private double divisao (double x, double y)

29

{ if (y == 0) { erro = 1; return(-1); } return(x / y); }

// ---------------------------- raizQuadrada private double raizQuadrada (double x) { return(Math.Sqrt (x)); }

// ---------------------------- power private double power (double x, double y) { return(Math.Pow (x, y)); }

// ---------------------------- seno private double seno (double x) { const double pi = 3.14158; double rads;

rads = x * pi / 180.0; return(Math.Sin (rads)); }

// ---------------------------- cosseno private double cosseno (double x) { const double pi = 3.14158; double rads;

rads = x * pi / 180.0; return(Math.Cos (rads)); }

// ---------------------------- tangente private double tangente (double x) { const double pi = 3.14158; double rads;

rads = x * pi / 180.0; return(Math.Tan (rads)); } }}

Programa exemplo que utiliza a classe “ Calculadora ” :

// ---------------------------------------------- Fonte: Calc.cs

using System;

namespace Calc{ class MainClass { public static void Main (string[] args) { Calculadora calc = new Calculadora();

calc.entradaDados(); calc.operaCalculadora(); calc.exibeCalculadora(); } }}

Modificadores de Acesso:

30

public: Os atributos e métodos tornam-se públicos, ou seja, qualquer outro método pode chamar ou utilizar estes atributos e/ou métodos.

private: Somente os métodos da classe (membros) da classe podem chamar ou utilizar atributos ou métodos privados.

protected: Utilizado em herança simples de classe (construção de subclasses), ou seja, uma subclasse herda todos os atributos e métodos da classe base (superclasse). Deixa acessível os atributos e/ou métodos para todas as outras classes (classe base) e subclasses (classe derivada).

3.3 Sobrecarga de métodos em C#

CSharp permite que métodos estáticos sejam sobrecarregados, desta forma, o retorno, número de argumentos ou mesmo o tipo de dados dos argumentos possam ser diferentes.

// ------------------------------------------ Fonte: SobreCarga.cs

using System;

namespace SobreCarga{ class MainClass { public static void Main (string[] args) { imprime ("Pelotas-RS"); imprime (123.45); imprime (123.45f); imprime (123); imprime ('A'); }

static void imprime (String s) { Console.WriteLine ("String: " + s); }

static void imprime (double d) { Console.WriteLine ("Double: " + d); }

static void imprime (float f) { Console.WriteLine ("Float: " + f); }

static void imprime (int i) { Console.WriteLine ("Inteiro: " + i); }

static void imprime (char ch) { Console.WriteLine ("Caracter: " + ch); } }}

Resultado do programa:

String: Pelotas-RSDouble: 123,45Float: 123,45Inteiro: 123

31

Caracter: A

3.4 Ponteiros, referências e endereços em C#

A seguir são mostrados alguns conceitos e diferenças entre Ponteiros, Referências e Endereços.

Endereço é um local na memória aonde um dado está armazenado, ou seja, corresponde a uma posição de memória capaz de armazenar os dados de um programa com um determinado quantidade de bytes.

Ponteiro é um tipo de dado (variável) que permite acessar um endereço qualquer.

Referência é um grau de abstração de um endereço mas de forma que o programador não pode alterar, somente usá-lo. É uma referência a um item de dados ou a um objeto. O programador/compilador não pode manipular uma referência diretamente.

// ------------------------------------------ Fonte: Ponteiro.cs

using System;

namespace Ponteiro{ class MainClass { public static void Main (string[] args) { unsafe { // é necessário configurar para executar char x = 'A'; char *p;

p = &x; // p recebe o endereço de x (&x) Console.WriteLine("Valor de x...: {0}", x); // *p valor é 65 Console.WriteLine("Caracter ....: {0}", *p); // caracter 'A' } } }}


Valor de x...: ACaracter ....: A

Observa ção : Para utilizar este código é necessário configurar o compilador ou ambiente de programação (Permitir código inseguro).

32

Resumo: x -> 65&x -> 100p -> &x -> 100*p -> 65&p -> 200

Definição:

tipo_dado_base *nome_do_ponteiro;

tipo_dado_base: qualquer tipo básico válido em C#.nome_da_ponteiro: nome da variável que representa o ponteiro.

O tipo de dados do ponteiro define para que tipos de variáveis o ponteiro pode apontar e qual o tamanho ocupado na memória por estas variáveis.

Operadores de ponteiros

& - endereço de memória do operando.* - conteúdo do endereço apontado pelo ponteiro.

Exemplo: ponteiro = &variável;

Logo: variável = *ponteiro;

4. Métodos de entrada e saída de dados

A seguir são mostrados alguns métodos que permitem fazer entrada de dados via teclado e saída de dados via monitor (tela).

4.1 Entrada e saída de dados usando TextReader e TextWriter

A seguir é visto um exemplo de entrada de dados usando as classes TextReader e TextWriter.

33

Programa exemplo: Entrada de Dados via teclado em terminal de texto usando a classe TextReader e saída via monitor utilizando a classe TextWriter.

// ---------------------------------------------- Fonte: Input.cs

using System.IO;

namespace Input{ class MainClass { public static void Main (string[] args) { TextReader leitor = System.Console.In; TextWriter escritor = System.Console.Out; escritor.Write("Digite seu nome: "); string nome = leitor.ReadLine(); escritor.WriteLine("Número de Caracteres: {0}", nome.Length); } }}


Digite seu nome: Paulo Roberto Gomes LuzzardiNúmero de Caracteres: 28

4.2 Entrada e saída de dados utilizando Console

A seguir é visto outra forma de entrada e saída utilizando a classe Console.

Programa exemplo: Entrada de dados via teclado em caixa de diálogo gráfica sobreposta a interface usando a classe Console.

// --------------------------------------------- Fonte: EntradaSaida.cs

using System;

namespace EntradaSaida{ class MainClass { public static void Main (string[] args) { Console.Write("Digite seu Nome: "); string nome = Console.ReadLine(); Console.WriteLine("Número de Caracteres: {0}", nome.Length); } }}


Digite seu nome: Paulo Roberto Gomes LuzzardiNúmero de Caracteres: 28

4.3 Leitura de uma tecla em C# (pausa por teclado)

Em C# é possível ler via teclado uma tecla.

// --------------------------------------------- Fonte: Caracter.cs

using System;

34

namespace Caracter{ class MainClass { public static void Main (string[] args) { for (int ch = 0; ch < 255; ch++) { Console.Write ("Código: " + ch + " - Caracter: " + (char)ch); Console.ReadKey (); } } }}


Código: 35 - Caracter: #Código: 36 - Caracter: $Código: 37 - Caracter: %Código: 38 - Caracter: &Código: 39 - Caracter: 'Código: 40 - Caracter: (Código: 41 - Caracter: )Código: 42 - Caracter: *Código: 43 - Caracter: +Código: 44 - Caracter: ,Código: 45 - Caracter: -Código: 46 - Caracter: .Código: 47 - Caracter: /Código: 48 - Caracter: 0Código: 49 - Caracter: 1Código: 50 - Caracter: 2Código: 51 - Caracter: 3Código: 52 - Caracter: 4

5. Operadores em C#

São símbolos especiais que obrigam o compilador a executar determinadas operações. Estas operações podem ser aritméticas, comparativas ou lógicas.

5.1 Operadores aritméticos em C#

São operadores que realizam uma operação matemática.

Tabela 3: Operadores aritméticos

Operador aritmético Ação- Subtração+ Adição* Multiplicação/ Divisão% Resto inteiro da divisão

-- ++ Decremento/incremento

Precedência dos operadores aritméticos (Hierarquia nas Operações)

Tabela 4: Precedência dos operadores aritméticos

Hierarquia Operação1 Parênteses2 Métodos3 ++ --4 - (menos unário)5 * / %6 + -

Observação: Quando houver duas ou mais operações de mesma hierarquia, o compilador executa-as da esquerda para a direita.

35

5.2 Operadores relacionais em C#

São operadores que permitem comparar valores, ou seja, são utilizados principalmemte em comandos que possuem condições.

Tabela 5: Operadores relacionais

Operador Ação> Maior que>= Maior ou igual a< Menor que<= Menor ou igual== Igual a!= Diferente de

5.3 Operadores lógicos em C#

São operadores utilizados em comandos que tem mais de uma condição.

Exemplo: if (condição1 && condição2 || condição3)

Tabela 6: Operadores lógicosOperador lógica Ação

&& ou & AND (e)|| ou | OR (ou)

! NOT (não)

Observação: $$ e || são chamados Short Circuit Operator, ou seja, quando o resultado das condições não puder mais ser alterado, há um truncamento nas próximas condições.

Precedência (Hierarquia dos operadores)

Tabela 7: Precedência dos operadores relacionais e lógicos

Hierarquia Operação1 !2 > >= < <=3 == !=4 &&5 ||

Observação: As expressões que utilizam operadores relacionais e lógicos retornam 0 (zero) para falso e !0 (não zero) para verdadeiro, ou seja:

true é diferente de 0 (!= 0) e false é igual 0 (== 0)

5.4 Incremento e decremento em C#

São operadores aritméticos que permitem realizar operações de soma e subtração de forma simplificada.

++ adiciona (1) ao operando subtrai (1) ao operando

As seguintes operações são equivalentes:x++; x = x + 1;x--; x = x - 1;

36

Observação:

Os operadores (++ ou --) podem ser colocados antes ou depois do operando. Quando precede seu operando, C# efetua a operação de incremento ou decremento antes de utilizar o valor do operando. Quando o operador vier depois do operando, C# utiliza o valor do operando antes de incrementá-lo ou decrementá-lo.

Exemplo:Equivalência

x = 10; // y será 11 x = 10;y = ++x; // x será 11 x = x + 1;

y = x;

x = 10; // y será 10 x = 10;y = x++; // x será 11 y = x;

x = x + 1;

5.5 Operador de atribuição em C#

O operador de atribuição é o sinal de igual =. A sintaxe do operador de atribuição pode ser escrito em uma das seguintes formas:

variável = constante; x = 3;variável = variável; x = y;variável = expressão; x = a + b;variável = método(x); x = Math.sqrt(y);

Programa exemplo: O programa calcula a idade de uma pessoa.

// ------------------------------------------ Fonte: Operadores.cs

using System;

namespace Operadores{ class MainClass { public static void Main (string[] args) { // leitura do ano atual Console.Write("Ano ATUAL: "); String s = Console.ReadLine(); int ano_atual = Convert.ToInt32 (s);

Console.Write("Ano de NASCIMENTO: "); s = Console.ReadLine();

// leitura do ano de nascimento int ano_nasceu = Convert.ToInt32(s);

// atribuição – cálculo da idade int idade = ano_atual - ano_nasceu; Console.WriteLine("Sua IDADE é " + idade + " anos"); } }}


Ano ATUAL: 2013Ano de NASCIMENTO: 1962Sua IDADE é 51 anos

A linguagem de programação CSharp permite utilizar o operador de atribuição em expressões, junto com operadores matemáticos, lógicos, relacionais, chamada de métodos, e outros (como foi mencionado acima).

37

if ((produto = x * y) < 0)

Funcionamento: Primeiramente C# atribui o valor x * y a variável produto, para depois avaliar a expressão, ou seja, comparar se o produto é menor (<) que zero.

5.6 Casts em C#

É possível forçar que o resultado de uma expressão seja de um determinado tipo. Para tanto deve ser utilizado uma construção chamada de cast, ou seja, pode ser utilizado para "tipar" uma variável com um tipo diferente do resultado da expressão.

variável = (tipo) expressão;

Programa exemplo: O programa imprime na tela o resultado de uma divisão.

// -------------------------------------------- Fonte: Cast.cs

using System;

namespace Cast{ class MainClass { public static void Main (string[] args) { Console.Write("x = "); String s = Console.ReadLine(); int x = Convert.ToInt32(s); Console.Write("y = "); s = Console.ReadLine(); int y = Convert.ToInt32(s); // é necessário um cast (float) pois a divisão de dois inteiros resula em um inteiro float resp = (float) x / y; // CAST para float Console.WriteLine("Divisão: {0:0.00}", resp); } }}


x = 3y = 4Divisão: 0,75

Observação: Em C#, o tipo resultante de um inteiro dividido por outro inteiro é um inteiro, logo, deve-se utilizar um cast (float) para que o tipo resultante atribuído a variável resp seja float.

5.7 Expressões em C#

Uma expressão em C# é qualquer combinação válida de operadores (aritméticos, relacionais, lógicos), constantes, variáveis e métodos.

Exemplo: c = Math.Sqrt (a) + b / 3.4;

6. Métodos para funções matemáticas padrões em C#

CSharp possui uma classe: Math que possui diversos métodos para resolver funções matemáticas. Algumas são descritas a seguir:

38

6.1 Math.Abs

O método Math.Abs retorna o valor positivo (absoluto).

Sintaxe: int Math.Abs(int x);float Math.Abs(float x);long Math.Abs(long x);double Math.Abs(double x);

6.2 Math.Asin

O método Math.Asin retorna o valor do arco seno. A variável x deve estar em radianos.

Sintaxe: double Math.Asin (double x);Faixa: -pi / 2 à pi / 2

6.3 Math.Acos

O método Math.Acos retorna o valor do arco cosseno. A variável x deve estar em radianos.

Sintaxe: double Math.Acos (double x);Faixa: 0 à pi

6.4 Math.Atan

O método Math.Atan retorna o valor do arco tangente. A variável x deve estar em radianos.

Sintaxe: double Math.Atan (double x);Faixa: -pi / 2 à pi / 2

6.5 Math.Sin

O método Math.Sin retorna o valor do seno. A variável x deve estar em radianos.

Sintaxe: double Math.Sin (double x);Faixa: -1 à 1

6.6 Math.Cos

O método Math.Cos retorna o valor do cosseno. A variável x deve estar em radianos.

Sintaxe: double Math.cos (double x);Faixa: -1 à 1

6.7 Math.Tan

O método Math.Tan retorna o valor da tangente. A variável x deve estar em radianos.

Sintaxe: double Math.Tan (double x);

6.8 Math.Exp

39

O método Math.Exp retorna o valor do expoente (ex).

Sintaxe: double Math.Exp (double x);

6.9 Math.Pow

O método Math.Pow (power) retorna o valor da potência (xy).

Sintaxe: double Math.Pow (double x, double y);

6.10 Math.Sqrt

O método Math.Sqrt (square root) retorna o valor da raiz quadrada.

Sintaxe: double Math.Sqrt (double x);

6.11 Math.Log

O método Math.Log retorna o valor do logaritmo natural.

Sintaxe: double Math.Log (double x);

6.12 Convert.ToDouble

O método Convert.ToDouble converte string em ponto flutuante.

Sintaxe: double Convert.ToDouble (String s);

6.13 Convert.Int?? (16, 32 ou 64)

Os métodos Convert.ToInt?? convertem uma string em inteiro.

Sintaxe: int Convert.ToInt?? (String s);

6.14 Convert.ToByte

O método Convert.ToByte converte uma string em byte.

Sintaxe: byte Convert.ToByte (String s);

6.15 Math.Log10

O método Math.Log10 retorna o logarítmo na base 10.

Sintaxe: double Math.Log10 (double x);

6.16 Random

A classe Random permite gerar um número aleatório. Veja o exemplo abaixo:

// ------------------------------------------ Fonte: Gera.cs

using System;

namespace Gera

40

{ class MainClass { public static void Main (string[] args) { Random rnd = new Random (); int numero = rnd.Next (10); Console.WriteLine ("Número: " + numero); } }}


Número: 6

6.17 Math.PI

O método Math.PI retorna o valor do pi radianos.

Sintaxe: double Math.PI (void);Valor: 3.141592653589793

6.18 Conversão de graus para radianos

Figura 2: Conversão de graus para radianos

Conversão de graus para radianos:

rads = graus * Math.PI / 180.0;

Conversão de radianos para graus:

graus = rads * 180.0 / Math.PI;

7. Comandos em C#

7.1 Tipos de comandos em C#

7.1.1 Sequência em C#

São comandos, que no fluxo de controle do programa, são sempre executados passando a execução para a próxima instrução, ou seja, todos os comandos de seqüência são executados desde que eles não dependem de um comando de seleção.

Exemplo: (todas as instruções abaixo são de seqüência)

Console.Write("Digite uma número: "); // imprime na tela

41

String s = Console.ReadLine(); // entrada de dados via teclado float valor = Convert.ToFloat(s); // conversão de String para float float resp = valor * 1.25; // atribuição é um comando de seqüência

7.1.2 Seleção em C#

São comandos, que no fluxo de controle do programa, permitem a seleção entre duas ou mais instruções, ou seja, este tipo de comando faz com que alguns comandos não sejam executados.

Exemplo:

if (numero % 2 == 0) // testa se o número é par ou ímpar{ Console.WriteLine("Número: PAR");}else { Console.WriteLine("Número: ÍMPAR");}

ou

Programa Exemplo: Programa extrai a raiz quadrada de um número.

// ------------------------------------------ Fonte: Raiz.cs

using System;

namespace Raiz{ class MainClass { public static void Main (string[] args) { Console.Write("Digite um valor: "); String s = Console.ReadLine(); Double x = Convert.ToDouble(s); if (x < 0) { // esta instrução só é executada se o valor de x for negativo x = Math.Abs(x); } Double raiz = Math.Sqrt(x); Console.WriteLine("Raiz Quadrada: {0:0.00}", raiz); } }}


Digite um valor: -16Raiz Quadrada: 4,00

Operador Ternário (?) em C#:

Funcionamento: Se a condição for verdadeira, executa comando1 senão executa comando2.

condição ? comando1 : comando2; | ^ ^ | | | +--------+ | | | +-------------------+

Exemplo (1): int menor = x <= y ? x : y;

// se x <= y ... menor = x;

42

// se x > y ... menor = y;

Exemplo (2): int menor; x <= y ? menor = x : menor = y;

// se x <= y ... menor = x;// se x > y ... menor = y;

// --------------------------------------------------------------- Fonte: Ternario.cs

using System;

namespace Ternario{ class MainClass { public static void Main (string[] args) { Console.Write("Digite um valor: "); String s = Console.ReadLine(); int x = Convert.ToInt32(s); Console.Write("Digite outro valor: "); s = Console.ReadLine(); int y = Convert.ToInt32(s); int menor = x < y ? x : y; // operador ternário Console.WriteLine("menor: " + menor); int maior = x > y ? x : y; // operador ternário Console.WriteLine("maior: " + maior); } }}


Digite um valor: 3Digite outro valor: 4menor: 3maior: 4

7.1.3 Repetição em C#

São comandos, que no fluxo de controle do programa, permitem a repetição de uma ou mais instruções.

Programa Exemplo: O programa exibe na tela de 0 até 9.

// ----------------------------------------------- Fonte: Repete.cs

using System;

namespace Repete{ class MainClass { public static void Main (string[] args) { const int n = 10; int i = 0;

do { Console.WriteLine("n = " + i); i++; } while (i < n); } }}


n = 0n = 1n = 2

43

n = 3n = 4n = 5n = 6n = 7n = 8n = 9

7.2 Comando if em C#

O comando if é um comando de seleção que permite selecionar um comando entre dois outros comandos (comandos simples) ou dois conjuntos de comandos (comandos compostos). Isto é feito através da avaliação de uma condição. O resultado desta avaliação (teste da condição) pode ser verdadeiro (true) ou falso (false). Dependendo deste resultado um dos comandos é executado e o outro não. Sintaxe:

if (condição) if (condição) { { comando 1; comando;} ou }else { comando 2;}

Observação: O else é opcional.

Se a condição for avaliada como verdadeira (qualquer valor diferente de 0), o comando 1 será executado, caso contrário (condição falsa, valor igual a zero) o comando 2 será executado. Comando 1, comando 2 ou comando podem ser simples ou compostos (quando há mais de um comando ligado a outro, deve-se utilizar chaves ({ }). Veja exemplos abaixo

if (condição) if (condição) { { comando 1; comando 1; comando 2; comando 2; } comando 3;else } { comando 3; comando 4; // todos os comando são compostos }

Programa exemplo: O usuário digita um número e o programa diz se este é par ou ímpar.

// ------------------------------------------- Fonte: Par.cs

using System;

namespace Par{ class MainClass { public static void Main (string[] args) { Console.Write("Digite um número: "); String s = Console.ReadLine(); int numero = Convert.ToInt32(s); if ((numero % 2) == 0) { Console.WriteLine ("Número é PAR"); }

44

else { Console.WriteLine ("Número é IMPAR"); } } }}


Digite um número: 7Número é IMPAR

7.2.1 if encadeados em C#

Um if aninhado (ou encadeado) é um comando if dentro de outro comando if ou if ... else.

Programa exemplo: O usuário digita um número e o programa diz se este é zero, positivo ou negativo.

// -------------------------------------------- Fonte: Numero.cs

using System;

namespace Numero{ class MainClass { public static void Main (string[] args) { Console.Write ("Digite um número: "); String s = Console.ReadLine (); int num = Convert.ToInt32 (s); if (num == 0) { Console.WriteLine ("Número é Zero"); } else { if (num > 0) { Console.WriteLine ("Número é Positivo"); } else { Console.WriteLine ("Número é Negativo"); } } } }}


Digite um número: 0Número é Zero

7.3 O comando switch em C#

O comando switch é um comando de seleção que permite selecionar um comando entre vários outros comandos. Isto é feito através da comparação de uma variável a um conjunto de constantes. Cada um dos comandos está ligado a uma constante.

Sintaxe:

switch (variável){ case constante_1 : seqüência de comandos; break; case constante_2 : seqüência de comandos; break; . .

45

. default: seqüência de comandos;}

O programa testa uma variável sucessivamente contra uma lista de constantes inteiras ou caracteres (int ou char). Depois de encontrar uma coincidência, o programa executa o comando ou bloco de comandos que estejam associados àquela constante. O comando default é executado se não houver nenhuma coincidência.

O comando break é utilizado para obrigar a saída do comando switch.

A opção default é opcional.

Observação: A variável não pode ser uma String e nem real (float ou double).

Programa exemplo: O programa recebe um dígito de 0 à 9 e imprime na tela, este dígito, por extenso. Neste exemplo a variável dígito é inteira.

// ---------------------------------------------- Fonte: TestaSwitch.cs

using System;

namespace TestaSwitch{ class MainClass { public static void Main (string[] args) { Console.Write ("Digito: "); String s = Console.ReadLine (); byte digito = Convert.ToByte (s); switch (digito) { case 0: Console.WriteLine ("Zero"); break; case 1: Console.WriteLine ("Um"); break; case 2: Console.WriteLine ("Dois"); break; case 3: Console.WriteLine ("Três"); break; case 4: Console.WriteLine ("Quatro"); break; case 5: Console.WriteLine ("Cinco"); break; case 6: Console.WriteLine ("Seis"); break; case 7: Console.WriteLine ("Sete"); break; case 8: Console.WriteLine ("Oito"); break; case 9: Console.WriteLine ("Nove"); break; default: Console.WriteLine ("ERRO: Não é um Dígito"); break; } }

46

}}


Digito: 7Sete

Programa exemplo: O programa recebe um dígito de 0 à 9 e imprime na tela, este dígito, por extenso. Neste exemplo a variável dígito é caracter, por causa disto as constantes estão entre apostrofes.

// ----------------------------------------- Fonte: SwitchChar.cs

using System;

namespace SwitchChar{ class MainClass { public static void Main (string[] args) { Console.Write ("Digito: "); String s = Console.ReadLine (); char digito = s [0]; switch (digito) { case '0': Console.WriteLine ("Zero"); break; case '1': Console.WriteLine ("Um"); break; case '2': Console.WriteLine ("Dois"); break; case '3': Console.WriteLine ("Três"); break; case '4': Console.WriteLine ("Quatro"); break; case '5': Console.WriteLine ("Cinco"); break; case '6': Console.WriteLine ("Seis"); break; case '7': Console.WriteLine ("Sete"); break; case '8': Console.WriteLine ("Oito"); break; case '9': Console.WriteLine ("Nove"); break; default: Console.WriteLine ("ERRO: Não é um Dígito"); break; } } }}


Digito: 6Seis

Programa exemplo (21): O programa constrói um menu com três métodos: inclusão, alteração e término.

// ------------------------------------------ Fonte: SwitchMenu.cs

47

using System;

namespace SwitchMenu{ class MainClass { static void inclusao() { Console.WriteLine("Opção Escolhida: Inclusão"); }

static void alteracao() { Console.WriteLine("Opção Escolhida: Alteração"); }

static void termino() { Console.WriteLine("Opção Escolhida: Término"); }

public static void Main (string[] args) { Console.WriteLine("[I]nclusão"); Console.WriteLine("[A]lteração"); Console.WriteLine("[T]érmino"); Console.Write("Qual a opção: "); String s = Console.ReadLine(); char opcao = s[0]; switch (opcao) { case 'i': case 'I': inclusao(); break; case 'a': case 'A': alteracao(); break; case 't': case 'T': termino(); break; default: Console.WriteLine("ERRO: Opção Inválida"); break; } } }}


[I]nclusão[A]lteração[T]érminoQual a opção: aOpção Escolhida: Alteração

7.4 Comando while no C#

O comando while é um comando de repetição que permite executar um comando (simples) ou vários comandos (composto) diversas vezes. Isto é feito através da avaliação de uma condição. Enquanto a condição for verdadeira os comandos são repetidos. Quando a condição se tornar falsa o comando while é finalizado. O teste da condição é feita no início do comando, ou seja, antes que todos os comandos sejam executados.

Observação: Note que os comandos podem não ser executados nenhuma vez, basta a condição começar como falsa.

Sintaxe:

while (condição) { ou while (condição) comando; {} comando 1; comando 2;

48

}Condição: Qualquer expressão válida em C# com resultado 0 (false) ou !0 (true). Na condição podem ser utilizados ainda variáveis, constan-tes, métodos, operadores (aritméticos, relacionais e lógicos).

Funcionamento do comando: O loop (laço) é repetido enquanto a condição for verdadeira. Quando a condição se tornar falsa o controle do programa passa para a próxima instrução. O laço while verifica a condição no início do laço, por causa disto, normalmente, a variável de controle do laço deve ser inicializado.

Exemplo:

int i = 0; // inicialização da variável de controlewhile (i <= 10) { // condição i <= 10

Console.WriteLine(“i = {0}”, i);i = i + 1; // incremento

}

Comando: Pode ser um comando vazio, simples ou composto que serão repetidos.

Comando vazio: while (1); // comando while não repete nenhum comandofor (int i = 0; i <= 1000; i++); // comando for não repete nenhum comando Verifique: Note que no final dos dois comandos (while e for) existe apenas um ponto-e-vírgula, isto é o sinal de comando vazio, ou seja, os comandos while e for que teriam outros comandos não os tem, caracterizando comandos vazios.

Problema freqüente de digitação: Muitas vezes o programador insere um ponto-e-vírgula no final de um comando for ou while por engano. Isto é um grave problema, pois este ponto-e-vírgula (inserido acidentalmente) faz com que os comandos que seriam repetidos, não são. Veja o exemplo abaixo:

Exemplo:

for (int x = 1; x <= 10; x++); // note o ponto-e-vírgula no final do comando for Console.WriteLine(“x = {0}”, x); // é impresso x = 11 na tela, porque?

Explicação: O comando Console.WriteLine não faz parte do comando if devido ao ponto-e-vírgula no comando for. O comando for termina quando a variável de controle x chega ao valor 11.

Comando correto: for (int x = 1; x <= 10; x++) {Console.WriteLine(“x = {0}”, x);

}

Programa exemplo: O programa imprime caracteres de ‘A’ até ‘Z’ na tela.

// ----------------------------------------- Fonte: Letras.cs

using System;

namespace Letras{ class MainClass { public static void Main (string[] args) { char letra = 'A'; // inicialização da variável de controle

while (letra != 'Z') { Console.WriteLine ("Letra: {0}", letra);

49

letra++; // incremento } } }}


Letra: ALetra: BLetra: CLetra: DLetra: ELetra: FLetra: GLetra: HLetra: ILetra: JLetra: KLetra: LLetra: MLetra: NLetra: O...Letra: VLetra: WLetra: XLetra: Y

7.5 O comando for no C#

O comando for é um comando de repetição que permite executar um comando (comando simples) ou vários comandos (comando composto) diversas vezes. Isto é feito através da avaliação de uma condição. Enquanto a condição for verdadeira os comandos são repetidos. Quando a condição se tornar falsa o comando for é finalizado.

Sintaxe: for (inicialização; condição; incremento ou decremento) { comando;}

Exemplos:

Com uma variável de controle:for (int i = 0;i < 9;i++) {

Console.WriteLine(i);}

Com duas variável de controle:for (int i = 1, int j = 5;i != j;i++, j--) { Console.WriteLine(i + “-“ + j);}

Inicialização: É um comando de atribuição (ou vários, separados por vírgula) que o compilador utiliza para inicializar a(s) variável(is) de controle do laço.

Condição: É uma expressão qualquer, que testa a variável de controle do laço contra algum valor para determinar quando o laço terminará.

Incremento ou decremento: Define a maneira como a(s) variável(is) de controle do laço serão alteradas após a repetição do laço.

O laço (for) é repetido enquanto a condição é verdadeira. A condição é sempre testada no começo do laço.

50

Qualquer uma das 3 partes do comando for (inicialização; condição; incremento) podem ser qualquer expressão válida em C#.

Programa exemplo: O programa imprime de 1 até 10 na tela.

// --------------------------------------------- Fonte: For.cs

using System;

namespace For{ class MainClass { public static void Main (string[] args) { for (int i = 1; i <= 10; i++) { // inicialização: i = 1 Console.Write("{0} ",i); // condição: i <= 10 } // incremento: i++ Console.WriteLine (); } }}


1 2 3 4 5 6 7 8 9 10

Programa exemplo: O programa imprime na tela: i = 1 - j = 9i = 2 - j = 8

// --------------------------- Fonte: For2.cs i = 3 – j = 7i = 4 – j = 6

using System;

namespace For2{ class MainClass { public static void Main (string[] args) { for (int i = 1, j = 9; i != j; i++,j--) { Console.WriteLine ("i = {0} - j = {1}", i, j); } } }}


i = 1 - j = 9i = 2 - j = 8i = 3 - j = 7i = 4 - j = 6

O laço for é equivalente ao seguinte comando:

inicialização;while (condição) { comando; incremento; // ou decremento }

ou

inicialização;do { comando; incremento; // ou decremento } while (condição);

51

C# possui ainda um for especial chamado foreach que pode ser utilizado para iteração com array, Strings, ArrayList, dentre outras classes do C#. Veja exemplo abaixo:

// --------------------------------------------- Fonte: ForReach.cs

using System;

namespace ForReach{ class MainClass { public static void Main (string[] args) { string[] nomes = { "Paulo", "Roberto", "Gomes", "Luzzardi" }; foreach (string nome in nomes) { Console.WriteLine (nome); } } }}


PauloRobertoGomesLuzzardi

7.6 O loop do { } while no C#

O comando do ... while é um comando de repetição que permite executar um comando (comando simples) ou vários comandos (comando composto) diversas vezes. Isto é feito através do teste de uma condição. Enquanto a condição for verdadeira os comandos são repetidos. Quando a condição se tornar falsa o comando do ... while é finalizado. O teste da condição é feita no final do comando, ou seja, depois que os comandos são executados (Note que os comandos são executados pelo menos uma vez).

Sintaxe:

do { comando;} while (condição);

Repete o laço enquanto a condição for verdadeira. Testa a condição no final, fazendo com que o laço seja executado

pelo menos uma vez.

Programa exemplo: Imprime na tela de 1 até 10.

// ----------------------------------------------- Fonte: While.cs

using System;

namespace While{ class MainClass { public static void Main (string[] args) { int i = 1;

do { Console.Write("{0} ",i); i++;

52

} while (i <= 10); Console.WriteLine (); } }}


1 2 3 4 5 6 7 8 9 10

7.7 Interrupção de loops em C#

7.7.1 O comando break em C#

Quando o programa encontra o comando break dentro de um laço, ele imediatamente encerra o laço, e o controle do programa segue para o próximo comando após o laço.

Programa exemplo: O programa imprime na tela a tecla digitada pelo usuário até que ele digite <F> ou <f>.

// ---------------------------------------------- Fonte: Break.cs

using System;

namespace Break{ class MainClass { public static void Main (string[] args) { char tecla;

do { Console.Write ("Tecla ou [F]im: "); String s = Console.ReadLine (); tecla = s [0]; if (tecla == 'F' || tecla == 'f') { // encerra o laço quando o usuário teclar 'F' ou 'f' break; } Console.WriteLine ("Tecla: " + (char)tecla + " - Código: " + (int)tecla); } while (true); // laço eterno } }}


Tecla ou [F]im: aTecla: a - Código: 97Tecla ou [F]im: bTecla: b - Código: 98Tecla ou [F]im: ATecla: A - Código: 65Tecla ou [F]im: BTecla: B - Código: 66Tecla ou [F]im: f

7.7.2 O comando continue no C#

O comando continue em vez de forçar o encerramento, força a próxima interação do laço e "pula", ou seja, não executa o código que estiver depois do comando continue.

Programa exemplo (27): O programa imprime na tela somente os números pares de 0 até 100.

// ------------------------------------------ Fonte: Continue.cs

53

using System;

namespace Continue{ class MainClass { public static void Main (string[] args) { for (int i = 0; i < 20; i++) { if (i % 2 == 1) { // 0 é par, 1 é impar continue; } // imprime somente números pares Console.WriteLine("Par: {0}", i); } } }}


Par: 0Par: 2Par: 4Par: 6Par: 8Par: 10Par: 12Par: 14Par: 16Par: 18Par: 20

Nos laços while e do {} while um comando continue faz com que o controle do programa execute diretamente o teste da condição e depois continue o processo do laço.

No caso do comando for, o programa primeiro executa o incremento (ou decremento) do laço e, depois, executa o teste da condição antes de finalmente fazer o laço continuar.

7.8 O método Environment.Exit ()

O método Environment.exit aborta o programa em qualquer situação, pode-se ainda utilizar o comando return.

Modo de usar: Environment.Exit(0); ou Environment.Exit(1);

8. Saída formatada com String.Format

Em C# é possível formatar a saída através do método String.Format e depois imprimir na tela.

Sintaxe: String String.Format("string de controle", lista de variáveis);

String de controle: Formada por especificadores que permitem formatar a string resultante.

// ------------------------------------------ Fonte: Cpf.cs

using System;

namespace Cpf{ class MainClass { public static void Main (string[] args)

54

{ long cpf = 12345678909;

string cpfFormat = String.Format("{0:000\\.000\\.000-00}", cpf); Console.WriteLine ("cpf: " + cpfFormat); } }}


cpf: 123.456.789-09

Alguns especificadores utilizados no String.Format

Tabela 8: Especificadores utilizados no String.Format

Especificador Tipo Formato Saídac moeda {0:c} R$ 12,345.00d decimal {0:d} -12345e notação científica {0:e} -1.234500e+004f ponto flutuante {0:f} -12345.00g genérico {0:g} -12345n numérico {0:n} -12,345.00r arredonda {0:r} System.FormatExceptionx hexadecimal {0:x4} 07b

Tabela 9: Especificadores utilizados no String.Format

Especificador Tipo Formato Saída0 completa com zeros {0:00.000} 1234.560# máscara para um número {0:#.##} 1234.56. posiciona o separador de decimal {0:0.0} 1234.6, posiciona o separador de milhar {0:0,0} 1,235% Porcentagem {0:0%} 123456%

Tabela 10: Especificadores utilizados no String.Format (data)

Especificador Tipo Formatot tempo curto hh:mmd data curta dd/mm/aaaaT tempo longo hh:mm:ssD data longa dddd, mmm dd, aaaaf combinação entre D and t dddd, mmm dd, aaaa hh:mmF data completa dddd, mmm dd, aaaa hh:mm:ssg combinação entre d and t mm/dd/aaaa hh:mmG combinação of d and T mm/dd/aaaa hh:mm:ss

m, M dia e mês mmm ddy, Y mês e ano mmm, aaaa

r, R data e hora completos ddd, dd mmm aaaa hh':'mm':'ss 'GMT'

s data e hora completos ‘aaaa'-'mm'-'dd'T'hh':'mm':'ss’u data universal ‘aaaa'-'mm'-'dd hh':'mm':'ss'Z'


Especificador Tipo Formato Saídad data curta dd/mm/aaaa 21/11/2013D data longa dd mmmm aaaa 21 Novembro 2013

55

t hora curta hh/mm 22:13T hora longa hh/mm/ss 22:13:34f data e hora dd mmmm aaaa hh/mm 21 Novembro 2013 22:13F data e hora completo dd mmmm aaaa hh/mm/ss 21 Novembro 2013 22:13:34g data de hora padrão dd/mm/aaaa hh/mm 21/11/2013 22:13

G data de hora padrão longo

dd/mm/aaaa hh/mm/ss 21/11/2013 22:13:34

M dia/nome do mês dd mmmm 21 Novembro

r date string ???, dd mmm aaaa hh/mm/ss GMT Qui, 21 Nov 2013 22:13:34 GMT

s data/hora aaaa-mm-ddThh/mm/ss 2013-11-21T22:13:34u hora universal aaaa-mm-ddThh/mm/ss 2013-11-21 22:13:34ZY nome do mês ano mmm aaaa Novembro 2013


Especificador Tipo SaídaDd dia 21Ddd nome do dia curto QuiDddd nome do dia Quinta-feirahh hora com 2 dígitos 02hh hora em 24 horas 14mm minuto com 2 dígitos 30mm mês com 2 dígitos 11mmm nome do mês curto Nov

mmmmmm nome do mês Novembross Segundos com 2 dígitos 34tt AM/PM PMaa Ano com 2 dígitos 13

aaaa Ano com 4 dígitos 2013: separador {0:hh:mm:ss} 22:13:34/ separador {0:dd/mm/aaaa} 21/11/2013

// ------------------------------------------ Fonte: Formato.cs

using System;

namespace Formato{ class MainClass { public static void Main (string[] args) { DateTime data = DateTime.Now; // lê a data do sistema String Format = String.Format("{0:yy yyyy}", data); Console.WriteLine ("Data: " + Format); String Format1 = String.Format("{0:M MM MMM MMMM}", data); Console.WriteLine ("Data: " + Format1); String Format2 = String.Format("{0:d dd ddd dddd}", data); Console.WriteLine ("Data: " + Format2); String Format3 = String.Format("{0:h hh H HH}", data); Console.WriteLine ("Data: " + Format3); String Format4 = String.Format("{0:m mm}", data); Console.WriteLine ("Data: " + Format4); String Format5 = String.Format("{0:s ss}", data); Console.WriteLine ("Data: " + Format5); String Format6 = String.Format("{0:f ff fff ffff}", data); Console.WriteLine ("Data: " + Format6); String Format7 = String.Format("{0:F FF FFF FFFF}", data); Console.WriteLine ("Data: " + Format7); String Format8 = String.Format("{0:t tt}", data); Console.WriteLine ("Data: " + Format8); String Format9 = String.Format("{0:z zz zzz}", data); Console.WriteLine ("Data: " + Format9);

int numero = 123;

56

http://www.faqs.org/rfcs/rfc1123.html

Format1 = String.Format ("{0:C}", numero); // moeda Console.WriteLine ("Valor: " + Format1); Format2 = String.Format ("{0:C6}", numero); // moeda com 6 casas decimais Console.WriteLine ("Valor: " + Format2); Format3 = String.Format ("{0:D}", numero); // decimal Console.WriteLine ("Valor: " + Format3); Format4 = String.Format ("{0:D12}", numero); // decimal com 12 posições Console.WriteLine ("Valor: " + Format4); Format5 = String.Format ("{0:E}", numero); // exponencial XXX.XXXe+xxx Console.WriteLine ("Valor: " + Format5); Format6 = String.Format ("{0:F}", numero); // ponto Fixo Console.WriteLine ("Valor: " + Format6); Format7 = String.Format ("{0:G}", numero); // formato Geral ou Científico Console.WriteLine ("Valor: " + Format7); Format8 = String.Format ("{0:N}", numero); // numérico Console.WriteLine ("Valor: " + Format8); Format9 = String.Format ("{0:N4}", numero); // numérico com 4 casas decimais Console.WriteLine ("Valor: " + Format9); String Format10 = String.Format ("{0:X}", numero); // hexadecimal Console.WriteLine ("Valor: " + Format10); String Format11 = String.Format ("{0:x3}", numero); // hexadecimal Console.WriteLine ("Valor: " + Format11); } }}


Data: 13 2013Data: 11 11 nov novembroData: 21 21 qui quinta-feiraData: 11 11 23 23Data: 10 10Data: 15 15Data: 1 10 100 1009Data: 1 1 1 1009Data: P PMData: -2 -02 -02:00Valor: R$ 123,00Valor: R$ 123,000000Valor: 123Valor: 000000000123Valor: 1,230000E+002Valor: 123,00Valor: 123Valor: 123,00Valor: 123,0000Valor: 7BValor: 07b

9. Lista de exercícios (comandos)

9.1 Escreva um programa em C# que recebe dois valores via teclado: cateto adjacente (b) e cateto oposto (a) e calcula o valor da hipotenusa dado pela seguinte fórmula:

Fórmula: h2 = a2 + b2

Exemplo (Tela):

Cateto adjacente (b): 3 <enter>Cateto oposto (a): 4 <enter>Hipotenusa: 5

57

9.2 Escreva um programa em C# que lê 4 notas via teclado: n1, n2, n3 e n4 obtidas por um aluno em 4 avaliações. Calcule a média utilizando a seguinte fórmula:

n1 + n2 * 2 + n3 * 3 + n4Média = ---------------------------

7

A seguir imprima na tela a média e o conceito do aluno baseado na seguinte tabela:

Média Conceito9,0 ou acima de 9,0 Aentre 7,5 (inclusive) e 9,0 Bentre 6,0 (inclusive) e 7,5 Cabaixo de 6,0 D

9.3 Escreva um programa em C# que recebe via teclado: comprimento da circunferência. O programa deve calcular e imprimir na tela o diâmetro e o raio da circunferência (veja exemplo abaixo).

Exemplo: Comprimento da circunferência: 36 <enter>Diâmetro: 11.46Raio: 5.73Continua [S/N]? N <enter>

comprimento da circunferência = 2 . PI . raiodiâmetro = 2 . raio

Observação: Programa termina se usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?

9.4 Desenvolva um programa em C# que recebe via teclado: peso da carne que será vendida (em quilos) e preço por quilo. O programa deve calcular e imprimir na tela o total a pagar, o valor pago ao ICMS (17%) e o lucro líquido do açougue.

Exemplo (Tela):

Peso: 3.5 <enter>Preço por Kg (R$): 4.90 <enter>Total a pagar: 17.15ICMS (17%): 2.91Lucro líquido do açougue (R$): 14.24Sair [S/N]? n <enter>Peso: 1.5 <enter>Preço por Kg (R$): 9.00 <enter>Total a pagar: 13.5ICMS (17%): 2.29Lucro líquido do açougue (R$): 11.21Sair [S/N]? S <enter>

9.5 Escreva um programa em C# que recebe via teclado: tipo de animal [1] Gado, [2] Eqüinos ou [3] Ovinos, preço unitário do animal e quantidade de animais comprados. O programa deve calcular e imprimir na tela: preço total pago e a comissão do escritório de remate (gado - 5%, eqüinos - 7% e ovinos - 3%), conforme exemplo abaixo:

Exemplo (Tela):

Tipo de animal [1] Gado, [2] Eqüinos ou [3] Ovinos: 1 <enter>Preço unitário do animal (R$): 200 <enter>Quantidade de animais: 10 <enter>Preço total pago (R$): 2100.00Comissão a pagar (R$): 100.00Continua [S/N]? s <enter>Tipo de animal [1] Gado, [2] Eqüinos ou [3] Ovinos: 2 <enter>Preço unitário do animal (R$): 1000 <enter>Quantidade de animais: 1 <enter>Preço total pago (R$): 1070.00

58

Comissão a pagar (R$): 70.00Continua [S/N]? N <enter>

9.6 Reescreva o programa anterior recebendo via teclado uma letra para o tipo de animal [G]ado, [E]qüinos ou [O]vinos, preço unitário do animal e quantidade de animais comprado. O programa deve calcular e imprimir na tela: preço total pago e a comissão do escritório de remate (gado: 5%, eqüinos: 7% e ovinos: 3%), conforme exemplo abaixo:

Exemplo (Tela):

Tipo de animal [G]ado, [E]qüinos ou [O]vinos: g <enter>Preço unitário do animal (R$): 200 <enter>Quantidade de animais: 10 <enter>Preço total pago (R$): 2100.00Comissão a pagar (R$): 100.00Continua [S/N]? s <enter>

9.7 Escreva um programa em C# que recebe via teclado: a data de hoje da seguinte forma: dia, mês, ano e a sua idade, da seguinte forma: anos, meses e dias vividos. O programa deve calcular e imprimir a data de nascimento no seguinte formato: dd/mm/aaaa.

Exemplo (Tela):

Qual a data de hoje:Dia: 16 <enter>Mês: 6 <enter>Ano: 2003 <enter>Qual a sua idade:Anos: 41 <enter>Meses: 4 <enter>Dias: 6 <enter>Data de Nascimento: 10/02/1962Continuar [S/N]? s <enter>

9.8 Escreva um programa em C# que recebe via teclado um número inteiro de 0 à 99. O programa deve imprimir na tela este número por extenso (conforme exemplo abaixo). O programa termina quando o usuário digitar 0 (zero).

Exemplo: Número [0..99]: 23 <enter>Vinte e trêsNúmero [0..99]: 45 <enter>Quarenta e cincoNúmero [0..99]: 0 <enter>

9.9 Escreva um programa em C# que recebe via teclado: quantidade de litros vendidos, tipo de combustível ([A]lcool, [G]asolina ou [D]iesel) e o tipo de pagamento ([P]razo ou [V]ista). O programa deve calcular e imprimir na tela: total à prazo, desconto e o total à vista. O programa termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?".

Tela de execução: Valores:

Quantidade de litros? 50 <enter> Álcool - 1,23Tipo de combustível [A]lcool, [G]asolina ou [D]iesel ? G <enter> Gasolina - 2,19Tipo de pagamento [P]razo ou a [V]ista ? V <enter> Diesel - 1,46Total à prazo (R$) : 109.50Desconto (R$): 5.48 Desconto à vista: 5%Total à vista (R$): 104.02Continua [S/N]? N <enter>

9.10 Escreva um programa em C# que recebe via teclado duas notas: nota1 e nota2. O programa deve imprimir na tela a média, o conceito do aluno (dado pela tabela abaixo) e a situação (aprovado, exame ou reprovado):

Conceito Média Situação

59

A 9,0 à 10,0 AprovadoB 7,0 à 8,9 AprovadoC 6,0 à 6,9 ExameD 0,0 à 5,9 Reprovado

Nota1 + Nota2 Exemplo:Média = -----------------

2 Nota1: 7 <enter>Nota2: 8 <enter>Média: 7.5Conceito: BSituação: AprovadoSair [S/N]? s <enter>

Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

9.11 Escreva um programa em C# que recebe via teclado uma temperatura e o tipo de conversão (converter para: [C]elsius ou [F]ahrenheit). Calcule e imprima na tela a temperatura correspondente a solicitação do usuário, conforme exemplos abaixo:

Exemplo: Temperatura: 30 <enter>Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): F <enter>Temperatura em Fahrenheit: 86Continua [S/N]? S <enter>Temperatura: 86 <enter>Tipo de conversão (converte para: [C]elsius ou [F]ahrenheit): C <enter>Temperatura em Celsius: 30Continua [S/N]? n <enter>

Fórmula: C9 . --- = F - 32

5

9.12 Escreva um programa em C# que recebe via teclado: graus (0 à 360), minutos (0 à 59) e segundos (0 à 59). O programa deve calcular e imprimir na tela o ângulo em graus, dado pela seguinte fórmula:

minutos segundosângulos em graus = graus + ---------- + ---------- 60 3600

Exemplo:

Graus: 45 <enter>Minutos: 45 <enter>Segundos: 45 <enter>Ângulo em Graus: 45.76Continua [S]im ou [N]ão? S <enter>Graus: 45 <enter>Minutos: 10 <enter>Segundos: 15 <enter>Ângulo em Graus: 45.17Continua [S]im ou [N]ão? N <enter>

Observação: Imprimir mensagens de erro se os valores de entrada estiverem fora da faixa:ERRO: Graus fora da faixa, ERRO: Minutos fora da faixa ou ERRO: Segundos fora da faixa.

9.13 Escreva um programa em C# que recebe via teclado: sexo ([M]asculino ou [F]eminino), altura e peso da pessoa. O programa deve calcular e imprimir na tela: peso ideal, diferença de peso e situação (MAGRO, IDEAL ou GORDO) (conforme exemplo abaixo):

Exemplo: Sexo [M]asculino ou [F]eminino: M <enter>Altura: 1.65 <enter>Peso: 92 <enter> PIM = 72,7 x altura – 58Peso Ideal: 62.0 PIF = 62,1 x altura – 44,7Diferença de Peso: 30.0Situação: GORDOSair [S/N]? s <enter>

60

MAGRO IDEAL GORDO-------------------|-------------------|--------------------- -5% pi 5%

Observação: Programa termina se o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

10. Vetores, Matrizes e Strings em C#

Um vetor é uma coleção de variáveis de mesmo tipo (agregados homogêneos) que são referenciadas pelo mesmo nome, utilizando-se um índice para diferencia-los.

Um vetor consiste em locações contíguas de memória, ou seja, os elementos encontram-se em sequência (contiguidade física). O menor endereço corresponde ao primeiro elemento, e o maior corresponde ao último elemento.

Uma vantagem na utilização de um vetor é poder armazenar vários valores (elementos), na memória RAM, ao mesmo tempo, permitindo, por exemplo, compará-los e classificá-los.

Exemplo: Vetor unidimensional de inteiros (idades).

Tabela 13: Exemplo de um vetor unidimensionalÍndice Valor

0 241 122 363 41

10.1 Vetores em C#

Vetor (matriz de uma dimensão - 1D) é um tipo especial de matriz que possui apenas um índice, ou seja, permite armazenar variáveis unidimensionais (permite representar uma tabela).

tipo_dado [] nome_do_vetor = new tipo_dado [número_de_elementos];

Onde:

tipo_dado: tipo de dado de cada elemento (char, byte, int, short, long, float, double).nome_do_vetor: nome da variável que irá representar o vetornúmero_de_elementos: número total de elementos do vetor

primeiro elemento: 0último elemento: número_de_elementos – 1número de bytes ocupados na memória RAM:

número_de_elementos x quantidade_de_bytes_de_um_elemento

Exemplo: int [] x = new int[5]; // 5 elementos: x[0] à x[4]

primeiro elemento: x[0]último elemento: x[número_de_elementos – 1], ou seja, x[4]número de bytes: 5 x 4 = 20 bytes (um inteiro ocupa 4 bytes)

// ------------------------------------------ Fonte: Vetor1.cs

using System;

namespace Vetor1{

61

class MainClass { public static void Main (string[] args) { const int max = 5; int [] vetor = new int[max];

for (int i = 0;i < max;i++) { Console.Write("Valor: "); vetor[i] = Convert.ToInt32(Console.ReadLine()); } for (int i = 0;i < max;i++) { Console.WriteLine("vetor[" + i + "] = " + vetor[i]); } } }}


Valor: 1Valor: 2Valor: 3Valor: 4Valor: 5vetor[0] = 1vetor[1] = 2vetor[2] = 3vetor[3] = 4vetor[4] = 5

// ------------------------------------------ Fonte: Vetor2.cs

using System;

namespace Vetor2{ class MainClass { public static void Main (string[] args) { const int max = 5; int[] vetor = { 1, 2, 3, 4, 5 };

for (int i = 0; i < max; i++) { Console.WriteLine ("vetor[" + i + "] = " + vetor [i]); } } }}


vetor[0] = 1vetor[1] = 2vetor[2] = 3vetor[3] = 4vetor[4] = 5

10.2 Strings em C#

Um objeto do tipo String (cadeia de caracteres) pode ser copiado para um vetor de caracteres. Veja o exemplo a seguir:

ASCII: Americam Standard Code for Information Interchange.url: http://www.asciitable.com

// ------------------------------------------ Fonte: Vetor3.cs

using System;

namespace Vetor3{

62

http://www.asciitable.com/

class MainClass { public static void Main (string[] args) { String [] vetor = { "Paulo", "Roberto", "Gomes", "Luzzardi" }; int max = vetor.Length;

for (int i = 0; i < max; i++) { Console.WriteLine ("vetor[" + i + "] = " + vetor [i]); } } }}


vetor[0] = Paulovetor[1] = Robertovetor[2] = Gomesvetor[3] = Luzzardi

Programa Exemplo: Programa cópia todos os caracteres de uma String para um vetor de caracteres.

// ----------------------------------------- Fonte: Vetor3.cs

using System;

namespace Vetor4{ class MainClass { public static void Main (string[] args) { Console.Write ("String: "); String s = Console.ReadLine (); int n = s.Length; char[] vetorCaracter = new char[n];

for (int i = 0; i < s.Length; i++) { vetorCaracter [i] = s [i]; }

Console.Write ("Vetor: "); for (int i = n - 1; i >= 0; i--) { Console.Write (vetorCaracter [i]); } Console.WriteLine (); } }}


String: pelotasVetor: satolep

10.3 Matrizes (Multidimensional) em C#

tipo_dado [,] nome_matriz = new tipo_dado [tamanho, tamanho];

Exemplo: float [,] y = new float [5, 5]; // matriz 2D

Para acessar o elemento 3, 4 da matriz y, deve-se escrever y[3,4]. Note que o primeiro elemento é y[0,0] e o último elemento é y[4,4]. O total de elementos é 25.

Programa Exemplo: O programa possui uma matriz bidimensional para gerar e exibir na tela “n” palpites para a MegaSena (atenção: gera palpites repetidos e números repetidos).

63

// ------------------------------------------- Fonte: vetor5.cs

using System;

namespace Vetor5{ class MainClass { // --------------------------- entradaDados static int entradaDados () { Console.Write ("Número de Palpites: "); String s = Console.ReadLine (); int n = Convert.ToInt32 (s); return(n); } // --------------------------- verificaRepetido static bool verificaRepetido (int j, int n, int num, int[,]sena) { bool repetido = false;

for (int i = 0; i < n; i++) { if (num == sena [j, i]) { return(true); } } return(repetido); } // --------------------------- geraPalpites static void geraPalpites (int n, int[,] sena) { Random random = new Random ();

for (int i = 0; i < n; i++) { for (int j = 0; j < 6; j++) { int num = 1 + random.Next (60); bool repetido = verificaRepetido (i, j, num, sena); if (!repetido) { sena [i, j] = num; } } } } // --------------------------- sort static void sort (int n, int[,] sena) { for (int k = 0; k < n; k++) { for (int i = 0; i < 5; i++) { for (int j = i + 1; j < 6; j++) { if (sena [k, i] > sena [k, j]) { int temp = sena [k, i]; sena [k, i] = sena [k, j]; sena [k, j] = temp; } } } } } // --------------------------- exibePalpites static void exibePalpites (int n, int[,] sena) { for (int i = 0; i < n; i++) { String extenso = ""; for (int j = 0; j < 6; j++) { extenso = extenso + String.Format ("{0:00} ", sena [i, j]); } Console.WriteLine ("Palpite: " + extenso); } } // ------------------------------------------- Main public static void Main (string[] args) { int n = entradaDados (); int[,] sena = new int [n, 6]; geraPalpites (n, sena);

64

sort (n, sena); exibePalpites (n, sena);

} }}


Número de Palpites: 5Palpite: 06 09 11 25 36 37 Palpite: 07 17 31 45 54 58 Palpite: 12 17 20 24 38 55 Palpite: 26 28 43 47 54 58 Palpite: 16 33 45 47 48 55

10.4 Vetor de Strings em C#

Para criar um vetor de Strings, deve-se utilizar um vetor de Strings.

Exemplo: String [] nome = new String[3];

nome[0] = “Senac”;nome[1] = “UCS”;nome[2] = “UFPel”;

String [] s = {“Pelotas”, “Rio Grande“, “Bagé}”;

Tabela 14: Exemplo de um vetor de strings0 1 2 3 4 5

0 ‘S’ ‘e’ ‘n’ ‘a’ ‘c’ null1 ‘U’ ‘C’ ‘S’ null2 ‘U’ ‘F’ ‘P’ ‘e’ ‘l’ null

Cria um vetor com três Strings. Para acessar uma String em particular deve-se especificar o índice entre colchetes, ou seja, nome[0], nome[1] ou nome[2].

10.5 Inicialização de matrizes e vetores em C#

tipo_dado [,] nome_matriz = {lista_valores};

lista_valores: lista de constantes separadas por vírgulas que são compatíveis em tipo com o tipo base da matriz.

Exemplo com vetor: int[] i = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // 10 elementos

Observação: Quando um vetor é declarado e inicializado (ao mesmo tempo) o número de elementos (neste caso 10) pode ser suprimido, ou seja, neste caso é opcional (veja exemplo anterior).

Exemplo com matriz: int[,] x = { { 1, 2 }, { 3, 4 }, { 5, 6 } };

10.6 Inicialização de um vetor de caracteres em C#

char [] nome_vetor = {lista_de_caracteres};

Exemplo com vetor de caracteres: char[] str = { 's', 'i', 'm' };

65

0 1 2‘s’ ‘i’ ‘m’

10.7 Inicialização de matrizes multidimensionais em C#

int[,] y = { { 1, 1 }, { 2, 4 }, { 3, 9 }, { 4, 16 } };

y[0][0] = 1 y[2][0] = 3y[0][1] = 1 y[2][1] = 9y[1][0] = 2 y[3][0] = 4y[1][1] = 4 y[3][1] = 16

10.8 Inicialização de vetores e matrizes sem tamanho em C#

Na inicialização de uma matriz (ou vetor), se não for especificado seu tamanho, então o compilador C# cria uma matriz (ou vetor) grande o suficiente para conter todos os inicializadores presentes.

Exemplo: char [] s = {’p’,’a’,’u’,’l’,’o’}; // s ocupa 5 bytes

Programa exemplo: O programa permite armazenar n nomes e idades em dois vetores.

// ---------------------------------------------- Fonte: String3.cs

using System;

namespace String3{ class MainClass { public static void Main (string[] args) { Console.Write ("Numero de Elementos: "); String s = Console.ReadLine (); int numElementos = Convert.ToInt32 (s); String[] nome = new String[numElementos]; int[] idade = new int[numElementos]; for (int i = 0; i < numElementos; i++) { Console.Write ("Nome: "); nome [i] = Console.ReadLine (); Console.Write ("Idade: "); s = Console.ReadLine (); idade [i] = Convert.ToInt32 (s); } for (int i = 0; i < numElementos; i++) { String extenso = String.Format("{0,-20:C}", nome[i]) + String.Format("{0:00}", idade [i]); Console.WriteLine (extenso); }

} }}


Número de Elementos: 3Nome: pauloIdade: 51Nome: renatoIdade: 49Nome: franciscoIdade: 53paulo 51renato 49francisco 53

66

Programa exemplo: O programa realiza a soma de duas matrizes (A e B) bidimensionais, gerando uma matriz resultante C.

// ---------------------------------------------- Fonte: Matriz.cs

using System;

namespace Matriz{ class MainClass { public static void Main (string[] args) { const int max = 10; int[,] a = new int [max,max]; int[,] b = new int [max,max]; int[,] c = new int [max,max]; int col, lin, m, n;

Console.Write ("Informe a ORDEM da MATRIZ: (mxn)\n"); do { Console.Write ("Número de linhas (m): "); String s = Console.ReadLine (); m = Convert.ToInt32 (s); } while (m < 1 || m > max); // m de 1 à 10 do { Console.Write ("Número de colunas (n): "); String s = Console.ReadLine (); n = Convert.ToInt32 (s); } while (n < 1 || n > max); // n de 1 à 10 for (lin = 1; lin <= m; lin++) { for (col = 1; col <= n; col++) { Console.Write ("A[" + lin + "," + col + "] = "); String s = Console.ReadLine (); a [lin,col] = Convert.ToInt32 (s); Console.Write ("B[" + lin + "," + col + "] = "); s = Console.ReadLine (); b [lin,col] = Convert.ToInt32 (s); } } Console.WriteLine (); for (lin = 1; lin <= m; lin++) { for (col = 1; col <= n; col++) { c [lin,col] = a [lin,col] + b [lin,col]; Console.WriteLine ("C[" + lin + "," + col + "] = " + c [lin,col]); } } } }}


Informe a ORDEM da MATRIZ: (mxn)Número de linhas (m): 2Número de colunas (n): 2A[1,1] = 1B[1,1] = 2A[1,2] = 3B[1,2] = 4A[2,1] = 5B[2,1] = 6A[2,2] = 7B[2,2] = 8

C[1,1] = 3C[1,2] = 7C[2,1] = 11C[2,2] = 15

10.9 Classificação de dados ou ordenação (sort) em C#

67

Para exemplificar melhor as variáveis do tipo vetor, abaixo são mostrados dois tipos de ordenação, também chamado sort (classificação de dados):

Programa exemplo: O programa classifica os nomes digitados pelo usuário.

// -------------------------------------------- Fonte: ForcaBruta.cs

using System;

namespace ForcaBruta{ class MainClass { public static void Main (string[] args) { Console.Write("Número de Elementos: "); String s = Console.ReadLine(); int numElementos = Convert.ToInt32(s); String [] nome = new String[numElementos]; for (int i = 0;i < numElementos;i++) { Console.Write("Nome: "); nome[i] = Console.ReadLine(); }

for (int i = 0; i < numElementos - 1; i++) { for (int j = i+1; j < numElementos; j++) { if (nome[i].CompareTo(nome[j]) > 0) { String temp = nome[i]; nome[i] = nome[j]; nome[j] = temp; } } }

Console.WriteLine("\nNomes ORDENADOS\n"); for (int i = 0; i < numElementos; i++) { Console.WriteLine("Nome: {0}", nome[i]); } } }}


Número de Elementos: 5Nome: BeatrizNome: DeboraNome: Ana Nome: EvaNome: Carla

Nomes ORDENADOS

Nome: AnaNome: BeatrizNome: CarlaNome: DeboraNome: Eva

Programa exemplo: O programa utiliza um método de sort chamado bubble sort (método da bolha) para classificar nomes.

// ------------------------------------------- Fonte: Bubble.cs

using System;

namespace Bubble{ class MainClass {

68

public static void Main (string[] args) { bool sort;

Console.Write("Número de Elementos: "); String s = Console.ReadLine(); int numElementos = Convert.ToInt32(s); String []nome = new String[numElementos]; for (int i = 0;i < numElementos;i++) { Console.Write("Nome: "); nome[i] = Console.ReadLine(); }

int k = numElementos - 1; do { sort = false; for (int i = 0; i < k; i++) { if (nome[i].CompareTo(nome[i+1]) > 0) { String temp = nome[i]; nome[i] = nome[i+1]; nome[i+1] = temp; sort = true; } } k--; } while (sort);

Console.WriteLine("\nNomes ORDENADOS\n"); for (int i = 0; i < numElementos; i++) { Console.WriteLine("Nome: {0}", nome[i]); } } }}


Número de Elementos: 5Nome: EvaNome: CarlaNome: DeboraNome: AnaNome: Beatriz

Nomes ORDENADOS

Nome: AnaNome: BeatrizNome: CarlaNome: DeboraNome: Eva

10.10 Lista de exercícios (vetores)

10.10.1 Escreva um programa em C# que recebe via teclado um conjunto de letras (máximo 20). Armazene todas as letras em um vetor (letras) até que o usuário digite um F ou f. Logo após copie todas as letras (em ordem inversa) para outro vetor (inverso). Ao final imprima os dois vetores.

Exemplo: Letra: L <enter>Letra: I <enter>Letra: M <enter>Letra: A <enter>Letra: f <enter>LIMAAMIL

10.10.2 Escreva um programa em C# que recebe via teclado: número de idades e as respectivas idades. Armazene todas as idades em um vetor (idade). Logo após a entrada de todas as idades, o programa deve receber via teclado: idade para consulta. O programa deve imprimir na

69

tela, o número de idades antes da idade de consulta e o número de idades depois da idade de consulta.

Exemplo: Número de idades: 6 <enter>Idade: 30 <enter>Idade: 60 <enter>Idade: 10 <enter>Idade: 50 <enter>Idade: 20 <enter>Idade: 40 <enter>Idade para consulta: 50 <enter>Antes: 3Depois: 2Continua [S/N]? n <enter>

10.10.3 Escreva um programa em C# que recebe via teclado um conjunto de números inteiros (máximo 50). Armazene todos os números inteiros em um vetor até que o usuário digite 0 (zero). Logo após permita ao usuário consultar um número informando o seu valor. O programa deve imprimir na tela a posição do número no vetor ou ERRO: Número não encontrado (veja exemplos abaixo):

Exemplo: Número: 50 <enter>Número: 30 <enter>Número: 20 <enter>Número: 10 <enter>Número: 40 <enter>Número: 0 <enter>Valor: 20 <enter>Posição no vetor: 2Valor: 40 <enter>Posição no vetor: 4Valor: 60 <enter>ERRO: Número não encontradoValor: 0 <enter>

Observação: O programa termina quando o usuário digitar 0 (zero).

10.10.4 Escreva um programa em C# que recebe via teclado "n" conceitos (A, B, C, D e E) (máximo 25) até que o usuário digite F ou f. Armazene todos os conceitos em um vetor (conceito). Imprima na tela o número de alunos: aprovados (A, B e C), reprovados (D) e os infreqüentes (E).

Exemplo: Conceito: B <enter>Conceito: A <enter>Conceito: E <enter>Conceito: B <enter>Conceito: D <enter>Conceito: C <enter>Conceito: A <enter>Conceito: E <enter>Conceito: f <enter>5 Aprovado(s)1 Reprovado(s)2 Infreqüente (s)

10.10.5 Escreva um programa em C# que recebe via teclado “n” (máximo 50) nomes. A entrada dos nomes termina quando o usuário digitar apenas <enter>. Logo após a entrada de todos os nomes o programa deve permitir a entrada via teclado de uma letra. O programa deve imprimir na tela todos os nomes que começam com a letra especificada pelo usuário. O programa termina quanto o usuário digitar “” (nada) na entrada da letra (conforme exemplos abaixo):

Exemplo: Nome: Paulo <enter>Nome: Roberto <enter>Nome: Renato <enter>Nome: Pedro <enter>Nome: Fabio <enter>Nome: <enter>Letra: R <enter>

70

Nome: RobertoNome: RenatoLetra: P <enter>Nome: PauloNome: PedroLetra: T <enter>Letra: <enter>

10.10.6 Escreva um programa em C# que recebe via teclado “n” (máximo 30) nomes e idades. A entrada dos dados termina quando o usuário digitar 'N' ou 'n' na pergunta "Continua [S/N]?". Logo após a entrada de todos os dados o programa deve imprimir na tela todos os nomes e idades desde o mais velho até o mais novo.

Exemplo: Nome: Ana <enter>Idade: 12 <enter>Continua [S/N]? s <enter>Nome: Beatriz <enter>Idade: 13 <enter>Continua [S/N]? s <enter>Nome: Carla <enter>Idade: 14 <enter>Continua [S/N]? N <enter>Carla 14Beatriz 13Ana 12

71

11. Manipulação de Strings em C#

A linguagem C# possui uma classe especifica para manipular strings, ou seja, permite manipular uma cadeia de caracteres.

11.1 Métodos para manipular Strings em C#

Considere que: String s = “Pelotas”;

Tabela 15: Construtores da classe string

Construtor TipoString (Char *) Ponteiro de caracteresString(Char[])) Vetor de caracteres.String(SByte*) Ponteiro de bytesString(Char, Int32) Caracter repetido n vezesString(Char*, Int32, Int32) Ponteiro de caracteres com uma posição e um comprimentoString(Char[], Int32, Int32) Vetor de caracteres com uma posição e um comprimentoString(SByte*, Int32, Int32) Ponteiro de caracteres com uma posição e um comprimento

A seguir são descritos os principais métodos que permitem manipular objetos do tipo String.

Método FuncionamentoCompare(String, String)

Compara duas Strings e retorna um número inteiro que indica sua posição relativa na ordem de classificação

Concat(String[]) Concatena os elementos de um vetor de Strings

Contains Retorna um valor indicando se o objeto String ocorre dentro desta instância

Copy Cria uma nova instância de String com o mesmo valor de um objeto String especificado

CopyToCopia um número especificado de caracteres de uma posição especificada nesta instância para uma posição especificada em um vetor de caracteres

Equals(String) Determina se esta instância e outro objeto String especificado têm o mesmo valor.

Equals(String, String) Determina se dois objetos String especificados têm o mesmo valor

IndexOf(Char) Retorna o índice da primeira ocorrência nesta String do caractere especificado

IndexOf(String) Retorna o índice da primeira ocorrência da String especificada nesta instância

Insert Insere uma String especificada em uma posição especificada nesta instância

Remove(Int32) Exclui todos os caracteres desta String, começando em uma posição especificada e continuando até a última posição

Remove(Int32, Int32) Exclui um número especificado de caracteres desta instância, começando em uma posição especificada

Replace(Char, Char)Retorna uma nova seqüência na qual todas as ocorrências de um caracter especificado são substituídos por um outro caractere especificado

Replace(String, String)

Retorna uma nova seqüência na qual todas as ocorrências de uma String especificada são substituídas por outra String especificada

Split(Char[])Retorna um vetor de Strings que contém os substrings nesta instância que são delimitados por elementos de um vetorde caracteres especificado

Split(Char[], Int32)Retorna um vetor de Strings que contém os substrings nesta instância que são delimitados por elementos de um vetorde caracteres especificado

Substring(Int32) Recupera uma substring desta instânciaSubstring(Int32, Int32) Recupera uma substring desta instância

ToCharArray() Copia os caracteres nesta instância para um vetor de caracteres

72

ToCharArray(Int32, Int32)

Copia os caracteres em uma substring especificada nesta instância para um vetor de caracteres

ToLower() Retorna uma cópia da string convertida para caracteres minúsculosToString() Retorna a instância da String

ToUpper() Retorna uma cópia desta String convertida para caracteres maiúsculos

Exemplos:

a) Exemplo do uso de toUpperCase e toLowerCase:

// ----------------------------------------------------- Fonte: Converter.cs

using System;

namespace Converter{ class MainClass { public static void Main (string[] args) { String s = "Paulo Roberto Gomes Luzzardi";

Console.WriteLine("Nome: " + s); Console.WriteLine("Nome: " + s.ToUpper()); Console.WriteLine("Nome: " + s.ToLower()); } }}


Nome: Paulo Roberto Gomes LuzzardiNome: PAULO ROBERTO GOMES LUZZARDINome: paulo roberto gomes luzzardi

b) Exemplo do uso de Length e IndexOf:

// ------------------------------------------------------ Fonte: Inverte.cs

using System;

namespace Inverte{ class MainClass { public static void Main (string[] args) { char op; do { Console.Write("Nome: "); String s = Console.ReadLine(); Console.Write("Invertido: "); int n = s.Length; // número de caracteres da String s for (int i = n-1;i >= 0;i--) { Console.Write(s[i]); // acesso a cada caracter de s } Console.WriteLine(); do { Console.Write("Continua [S/N]? "); s = Console.ReadLine(); op = s[0]; } while ("SsNn".IndexOf(op) == -1); // verifica se op é “SsNn” } while ("Ss".IndexOf(op) != -1); } }}


Nome: pelotas

73

Invertido: satolepContinua [S/N]? sNome: satolepInvertido: pelotasContinua [S/N]? N

c) Exemplo do uso de String.format:

// -------------------------------------------- Fonte: StringFormat.cs

using System;

namespace StringFormat{ class MainClass { public static void Main (string[] args) { float numero = 123.4567f;

String formato = String.Format("{0:0.000}", numero); Console.WriteLine("Peso Ideal: " + formato); } }}


Peso Ideal: 123,457

11.2 Lista de exercícios (Strings)

11.2.1 Escreva um programa em C# que recebe via teclado um nome. Logo após a entrada do nome imprima: número de letras maiúsculas, número de letras minúsculas, número de vogais e o número de consoantes, conforme exemplo abaixo:

Exemplo: Nome: Faculdade de Tecnologia Senac <enter>(3) maiúscula(s)(23) minúscula(s)(12) vogais(s)(14) consoante(s)

11.2.2 Escreva um programa em C# que recebe via teclado uma palavra e uma letra. Logo após a entrada do nome e da letra imprima o número de letras que existe no nome ou ERRO: Não existe a letra (?) na palavra (?), conforme exemplo abaixo:

Exemplo: Palavra: Luzzardi <enter>Letra: z <enter>2 letra(s)Continua [S]im ou [N]ão? S <enter>Palavra: Luzzardi <enter>Letra: w <enter>ERRO: Não existe a letra (w) na palavra (Luzzardi)Continua [S]im ou [N]ão? N <enter>

Observação: O programa deve ser encerrado quando o usuário digitar “N” ou “n” na pergunta: Continua [S]im ou [N]ão?.

11.2.3 Escreva um programa em C# que recebe via teclado uma palavra e uma posição. O programa deve imprimir na tela, a letra antecessora, a letra (da referida posição) e a letra sucessora, conforme exemplo abaixo:

Exemplo: Palavra: Universidade <enter>Posição: 7 <enter>Antecessora: sLetra: iSucessora: d

74

Observação: O programa deve imprimir na tela as seguintes mensagens de erro, se for o caso: Letra antecessora não existe, Letra sucessora não existe ou Posição inválida.

11.2.4 Escreva um programa em C# que recebe via teclado um nome. O programa deve imprimir, na tela, as palavras do nome em ordem inversa, uma por linha, conforme exemplo abaixo:

Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter>LuzzardiGomesRobertoPaulo

11.2.5 Escreva um programa em C# que recebe via teclado um nome. Logo após a entrada do nome o programa deve imprimir (EM LETRA MAIÚSCULA) o sobrenome da pessoa, conforme exemplos abaixo:

Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter>Sobrenome: LUZZARDISair [S/N]? N <enter>Nome: Renato Souza <enter>Sobrenome: SOUZASair [S/N]? s <enter>

Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

11.2.6 Escreva um programa em C# que recebe via teclado um nome. Logo após a entrada do nome o programa deve imprimir na tela: sobrenome, primeiro nome e demais nomes abreviados, conforme exemplos abaixo:

Exemplo: Nome: Paulo Roberto Gomes Luzzardi <enter>Autor: Luzzardi, Paulo R. G.Sair [S/N]? N <enter>Nome: Renato Lima Souza <enter>Autor: Souza, Renato L.Sair [S/N]? s <enter>

Observação: O programa termina quando o usuário digitar ‘S’ ou ‘s’ na pergunta: Sair [S/N]?

11.2.7 Escreva um programa em C# que recebe via teclado o nome de um estado. Logo após a entrada do nome do estado imprima: a sigla do estado (2 letras maiúsculas), conforme exemplos abaixo:

Exemplo: Estado: Rio Grande do Sul <enter>Sigla: RSEstado: são paulo <enter>Sigla: SPEstado: rio de janeiro <enter>Sigla: RJEstado: <enter>

Observação: O programa encerra quando o usuário digitar apenas <enter> na entrada do nome do estado.

11.2.8 Escreva um programa em C# que recebe via teclado uma palavra, início e fim. Logo após a entrada de todos os dados imprima a string resultante ou ERRO: Fim inválido ou Início inválido, conforme exemplos abaixo:

Exemplo: Palavra: universidade <enter>Início: 7 <enter>Fim: 11 <enter>String resultante: idadeContinua [S/N]? s <enter>Palavra: eletricidade <enter>Início: 7 <enter>Fim: 15 <enter>ERRO: Fim Inválido

75

Continua [S/N]? N <enter>

Observação: O programa termina quando o usuário digitar ‘N’ ou ‘n’ na pergunta: Continua [S/N]?.

12. Métodos estáticos definidos pelo programador em C#

A linguagem de programação C# permite que o programador crie e utilize seus próprios métodos estáticos.

Forma Geral:

static tipo_do_retorno nome_do_método (tipo_dado_base parâmetros ou argumentos) { tipo_dado_base variáveis;

corpo do método;

return(x);}

tipo_do_retorno: Especifica o tipo de dado que será retornado pelo método. O retorno do método é feito pelo comando return (valor).

Parâmetros ou argumentos: É uma lista, separada por vírgulas, com os nomes das variáveis (e seus tipos) que receberão os argumentos quando o método for chamado ou executado.

Método procedural: É um tipo especial de método que não possui retorno, ou seja, é simplesmente um procedimento. Um método deste tipo é void.

Exemplo: Programa que gera 10 números aleatórios, usando um método estático escrito pelo programador.

// ----------------------------------------------- Fonte: rand.cs

using System;

namespace Rand{ class MainClass { static Random rnd = new Random (); // variável global, não é uma boa prática de programação // ----------------------------------------------- random static int random (int n) { int numero = rnd.Next (n); return(numero); } // ------------------------------------------------ main public static void Main (string[] args) { for (int i = 1; i <= 10; i++) { Console.WriteLine ("Valor: " + random (100)); } } }}


Valor: 13Valor: 45Valor: 96Valor: 29Valor: 58Valor: 10

76

Valor: 37Valor: 54Valor: 33Valor: 95

Chamada do método: n = random(100); // retorna um número aleatório entre 0 e 99

Programa exemplo: O programa possui um método estático que calcula o inverso 1/x.

// ---------------------------------------------- Fonte: Inverso.cs

using System;

namespace Inverso{ class MainClass { // ----------------------------- Método definido pelo programador static double inverso (double x) { double i;

i = (double)1 / x; return(i); } // -----------------------------------------Main public static void Main (string[] args) { Console.Write ("x: "); String s = Console.ReadLine (); double x = Convert.ToDouble (s); double inv = inverso (x); // chamada do método inverso Console.WriteLine ("Inverso = {0}", inv); } }}


x: 4Inverso = 0,25

12.1 Valores de retorno em C#

Todas os métodos, exceto aqueles que são declaradas como sendo do tipo void, devolvem um valor. O valor é devolvido (retornado) pelo método através do comando return.

Normalmente são escritas três tipos de métodos:

a) Métodos que efetuam operações com os parâmetros e retornam um valor com base nas operações.

Programa exemplo: O programa calcula e imprime na tela o valor da potência xy através de um método estático chamado: potencia.

// --------------------------------------------- Fonte: Metodo1.cs

using System;

namespace Metodo1{ class MainClass { // ------------------------------------------------- Método definido pelo programador static double potencia (double x, int y) { double valor;

valor = Math.Exp (Math.Log (x) * y);

77

return(valor); } // ---------------------------------------------------- Main public static void Main (string[] args) { Console.Write ("Base: "); String s = Console.ReadLine (); double _base = Convert.ToDouble (s); Console.Write ("Expoente: "); s = Console.ReadLine (); int _expoente = Convert.ToInt32 (s); double resp = potencia (_base, _expoente); // chamada do método potencia Console.WriteLine ("Potencia = {0}", resp); } }}


Base: 3Expoente: 4Potencia = 81

b) Métodos que manipulam informações e retornam um valor que simplesmente indica o sucesso ou o fracasso da manipulação.

Programa exemplo: O programa calcula e verifica o determinante de uma equação de segundo grau através de um método estático chamado: verificaDeterminante.

// ------------------------------------------ Fonte: Metodo2.cs

using System;

namespace Metodo2{ class MainClass { // ---------------------------------------------------------------------------- método definido pelo programador

static int verificaDeterminante (float a, float b, float c) { float det;

det = b * b - 4 * a * c; if (det == 0) { return(0); } else { if (det > 0) { return(1); } else { return(-1); } } } // ------------------------------------------------------------- Main public static void Main (string[] args) { Console.Write("a = "); String s = Console.ReadLine(); float a = float.Parse(s); Console.Write("b = "); s = Console.ReadLine(); float b = float.Parse(s); Console.Write("c = "); s = Console.ReadLine(); float c = float.Parse(s); int retorno = verificaDeterminante(a,b,c); if (retorno == 0) { Console.WriteLine("Determinante ZERO"); }

78

else { if (retorno > 0) { Console.WriteLine("Determinante POSITIVO"); } else { Console.WriteLine("Determinante NEGATIVO"); } } }

}}


a = 1b = 2c = -4Determinante POSITIVO

c) Métodos que não retornam nenhum valor, ou seja, são puramente procedimentos.

Programa exemplo: O programa abaixo possui um método estático sobrecarregado que imprime um número (int ou float) na tela através do método chamado: imprimeNumero.

// -------------------------------------- Fonte: Metodo3.cs

using System;

namespace Metodo3{ class MainClass { // --------------------------------------------- ImprimeNumero static void imprimeNumero (int n) { Console.WriteLine ("Número digitado foi {0}", n); } // -------------------------------------------- ImprimeNumero static void imprimeNumero (float n) { Console.WriteLine ("Número digitado foi {0}", n); } // --------------------------------------------- Main public static void Main (string[] args) { Console.Write ("Digite um número inteiro: "); String s = Console.ReadLine (); int x = int.Parse (s); imprimeNumero (x); Console.Write ("Digite outro número real: "); s = Console.ReadLine (); float y = float.Parse (s); imprimeNumero (y); } }}


Digite um número inteiro: 123Número digitado foi 123Digite outro número real: 123,45Número digitado foi 123,45

Observação: Note que o método imprimeNumero foi sobrecarregado, ou seja, ele funciona quando o argumento é int ou float.

12.2 Passagem de parâmetros por valor em C#

79

Forma de chamada de um método, onde o valor do argumento é apenas copiado para o parâmetro formal do método. Portanto, alterações feitas nos parâmetros não terão efeito nas variáveis utilizadas para chamá-la.

Programa exemplo: O programa possui um método que desenha um retângulo na tela.

// ------------------------------------------- Fonte: Metodo4.cs

using System;

namespace Metodo4{ class MainClass { // ------------------------ desenhaRetangulo static void desenhaRetangulo (int ci, int li, int cf, int lf) { int c, l;

for (l = li; l <= lf; l++) { for (c = ci; c <= cf; c++) { Console.Write ("#"); } Console.WriteLine (); } } // ----------------------------------------- Main public static void Main (string[] args) { desenhaRetangulo (1, 1, 20, 10); } }}


########################################################################################################################################################################################################

Onde: ci -> coluna inicialli -> linha inicial cf -> coluna finallf -> linha final

Atenção: Os argumentos do método recebem, respectivamente: ci=1, li=1, cf=20 e lf=10.

12.3 Passagem de parâmetros por referênciaem C#

A passagem de parâmetros ou argumentos por referência em C# acontece com qualquer tipo de dado desde que o identificador ref seja utilizado na declaração do método e na chamada do método. Veja o exemplo troca abaixo.

Programa exemplo: O programa tem um método que troca o valor de duas variáveis.

// ------------------------------------------------- Fonte: Troca.cs

80

using System;

namespace Troca{ class MainClass { static void troca(ref int x, ref int y) // ref - referência { int temp = x; x = y; y = temp; } public static void Main (string[] args) { int x = 3, y = 4; Console.WriteLine ("x = {0} - y = {1}", x, y);

troca (ref x, ref y); // ref – referência

Console.WriteLine ("x = {0} - y = {1}", x, y); } }}


x = 3 - y = 4x = 4 - y = 3

A seguir é visto uma forma exatamente semelhante a linguagem de programação C e C++:

// ------------------------------------------------- Fonte: Troca2.cs

using System;

namespace Troca2{ class MainClass { unsafe static void troca(int *x, int *y) // unsafe – código inseguro { int temp = *x; *x = *y; *y = temp; } public static void Main (string[] args) { unsafe { int x = 3, y = 4; Console.WriteLine ("x = {0} - y = {1}", x, y);

troca (&x, &y); // unsafe – código inseguro

Console.WriteLine ("x = {0} - y = {1}", x, y); } } }}


x = 3 - y = 4x = 4 - y = 3

Observação: É necessário configurar o código fonte para que ele seja compilado e executado (No MacOs X: botão direito no fonte Options ... Compilar ... Permitir código “inseguro”).

12.4 Métodos que devolvem valores não-inteiros em C#

81

Todas os métodos que devolvem valores não-inteiros devem ter seu tipo de retorno declarado.

tipo_do_retorno nome_do_metodo (tipo_dado_base parâmetros);

Programa exemplo: O programa calcula e imprime na tela a divisão de dois valores usando um método estático chamado divisão.

// ------------------------------------------ Fonte: Divisao.cs

using System;

namespace Divisao{ class MainClass { // -------------------------------------------- método definido pelo programador static float divisao (int x, int y) { return((float)x / y); } // -------------------------------------------- Main public static void Main (string[] args) { Console.Write ("x = "); String s = Console.ReadLine (); int x = int.Parse (s); Console.Write ("y = "); s = Console.ReadLine (); int y = int.Parse (s); float resposta = divisao (x, y); Console.WriteLine ("Divisão = {0}", resposta); } }}


x = 3y = 4Divisão = 0,75

12.5 Argumentos do Main (String [] args) em C#

O método estático Main possui um argumento args intrínsecos utilizados para receber parâmetros da linha de comando do Sistema Operacional.

args – Vetor de Strings

Programa exemplo: O programa recebe parâmetros do Sistema Operacional (uma palavra qualquer) e imprime a palavra em sentido inverso. O programa deve ser executado via terminal do Sistema Operacional da seguinte forma:

Execução pela linha de comandos (terminal):

$ mono Program.exe pelotas <enter>

Resultado na tela: satolep

Programa recebe:

argv[0] = “pelotas”

// --------------------------------------- Fonte: Inverter.cs

82

using System;

namespace Inverter{ class MainClass { public static void Main (string[] args) { int n, argc = args.Length;

if (argc != 1) { Console.WriteLine("Sintaxe: Inverter <palavra>\n"); } else { Console.Write("Palavra: "); n = args[0].Length; for (int i = n-1; i >= 0; i--) { Console.Write("{0}", args[0][i]); } Console.WriteLine(); } } }}


MacBook-Air-de-Paulo:Inverter pluzzardi$ ls -ltotal 24-rw-r--r-- 1 pluzzardi staff 1663 22 Nov 23:55 Inverter.csproj-rw-r--r-- 1 pluzzardi staff 401 22 Nov 23:57 Program.cs-rwxr-xr-x 1 pluzzardi staff 3584 22 Nov 23:58 Program.exedrwxr-xr-x 3 pluzzardi staff 102 22 Nov 23:55 Propertiesdrwxr-xr-x 3 pluzzardi staff 102 22 Nov 23:55 bindrwxr-xr-x 3 pluzzardi staff 102 22 Nov 23:55 objMacBook-Air-de-Paulo:Inverter pluzzardi$ mono Program.exe pelotasPalavra: satolepMacBook-Air-de-Paulo:Inverter pluzzardi$

Programa exemplo: O programa deve receber parâmetros pelo Sistema Operacional (conjunto de caracteres) e deve ordenar (coloca em ordem alfabética), imprimindo-os a seguir.

Execução pela linha de comandos: $ mono Program.exe dbeacgf <enter>

Resultado na tela: abcdefg

Programa recebe:

agv[0] = “dbeacgf”

// ------------------------------------- Fonte: Ordem.cs

using System;namespace Ordem{ class MainClass { public static void Main (string[] args) { int argc = args.Length; int numCar;

if (argc != 1) { Console.WriteLine("Sintaxe: Ordem <palavra> \n"); } else { numCar = args[0].Length; char [] ch = new char[numCar];

83

for (int i = 0;i < numCar;i++) { ch[i] = args[0][i]; } for (int i = 0; i < numCar-1; i++) { for (int j = i+1; j < numCar; j++) { if (ch[i] > ch[j]) { char temp = ch[i]; ch[i] = ch[j]; ch[j] = temp; } } } for (int i =0;i < numCar;i++) { Console.Write("{0}", ch[i]); } Console.WriteLine(); } } }}


MacBook-Air-de-Paulo:Ordem pluzzardi$ cd OrdemMacBook-Air-de-Paulo:Ordem pluzzardi$ ls -ltotal 16-rw-r--r-- 1 pluzzardi staff 1657 23 Nov 00:02 Ordem.csproj-rw-r--r-- 1 pluzzardi staff 678 23 Nov 00:06 Program.csdrwxr-xr-x 3 pluzzardi staff 102 23 Nov 00:02 Propertiesdrwxr-xr-x 3 pluzzardi staff 102 23 Nov 00:02 bindrwxr-xr-x 3 pluzzardi staff 102 23 Nov 00:02 objMacBook-Air-de-Paulo:Ordem pluzzardi$ gmcs Program.csMacBook-Air-de-Paulo:Ordem pluzzardi$ mono Program.exe dbeacgfabcdefgMacBook-Air-de-Paulo:Ordem pluzzardi$

12.6 Recursividade em C#

Um método é recursivo se este fizer uma chamada a si própria.

Programa exemplo: O programa calcula o fatorial de um número recursivamente.

// ------------------------------------------ Fonte: Fatorial.cs

using System;

namespace Fatorial{ class MainClass { // ----------------------------------------- fatorial

static long fatorial(int num) { if (num == 0) { return 1; } return(num * fatorial(num - 1)); // recursividade } // -------------------------------------------- Main public static void Main (string[] args) { int n;

do { do { Console.Write("n = "); String s = Console.ReadLine(); n = int.Parse(s); } while (n < 0 || n > 100); long fat = fatorial(n); Console.WriteLine("Fatorial: {0}", fat); } while (n != 0);

84

} }}


n = 5Fatorial: 120n = 10Fatorial: 3628800n = 15Fatorial: 1307674368000n = 20Fatorial: 2432902008176640000n = 30Fatorial: -8764578968847253504 // erron = 0Fatorial: 1

Programa exemplo: O programa calcula a soma de um número recursivamente.

// ------------------------------------------- Fonte: Soma.cs

using System;

namespace Soma{ class MainClass { // ----------------------------------- soma static long soma (int n) { long s;

if (n == 1) { return(1); } s = n + soma (n - 1); // recursividade return(s); } // ---------------------------------------------------- Main public static void Main (string[] args) { int n; long sum;

do { do { Console.Write ("n = "); String s = Console.ReadLine (); n = int.Parse (s); } while (n < 0 || n > 19); if (n > 0) { sum = soma (n); Console.WriteLine ("Soma: {0}", sum); } } while (n != 0); } }}


n = 1Soma: 1n = 2Soma: 3n = 3Soma: 6n = 4Soma: 10n = 5Soma: 15n = 6

85

Soma: 21n = 7Soma: 28n = 8Soma: 36n = 0

12.7 Lista de Exercícios (métodos)

12.7.1 Escreva em C# o método númeroPalavras. O método recebe uma String (nome) e retorna o número de palavras do nome (veja exemplo abaixo):

// ------------------------------------------------------ Fonte: Palavras.cs

using System;

namespace Palavras{ class MainClass { public static void Main (string[] args) { Console.Write("Nome: "); String nome = Console.ReadLine(); int n = numeroPalavras(nome); Console.WriteLine("Seu nome tem {0} palavra(s)", n); }

// ---------------------------- numeroPalavras

}}


Nome: Paulo Roberto Gomes Luzzardi <enter>Seu nome tem 4 palavra(s)

12.7.2 Escreva em C# o método verificaQuadrante. O método recebe um valor para x e um valor para y e retorna o número do quadrante (1, 2, 3 ou 4).

// --------------------------------------------------------- Fonte: Quadrante.cs

using System;

namespace Quadrante{ class MainClass { public static void Main (string[] args) { Console.Write ("x: "); String s = Console.ReadLine (); int x = int.Parse (s); Console.WriteLine ("y: "); s = Console.ReadLine (); int y = int.Parse (s); int n = verificaQuadrante (x, y); Console.WriteLine ("Quadrante: {0}", n); } // ---------------------------- verificaQuadrante }}

Resultado do Programa:2 | 1

x: 1 <enter> ________________________y: 2 <enter> |Quadrante: 1 3 | 4

86

12.7.3 Escreva o método: final_da_placa. O método recebe uma placa de automóvel no formato: xxx9999 e retorna o último dígito da placa.

// ------------------------------------------------------------ Fonte: Placa.cs

using System;

namespace Placa{ class MainClass { public static void Main (string[] args) { Console.Write ("Qual a placa de seu carro [xxx9999]: "); String placa = Console.ReadLine (); char fim = finalPlaca (placa); Console.WriteLine ("Final da Placa é: {0}", fim); } // ---------------------------- finalPlaca }}


Qual a Placa de seu carro [xxx9999]: IDJ7345 <enter>Final da Placa é: 5

12.7.4 Escreva o método numVogais. O método recebe uma String (nome) e retorna a quantidade de vogais da String.

// ------------------------------------------------------------ Fonte: Vogais.cs

using System;

namespace Vogais{ class MainClass { public static void Main (string[] args) { Console.Write("Nome: "); String nome = Console.ReadLine(); int vogais = numVogais(nome); Console.WriteLine("Vogais: {0}", vogais); }

// -------------------------- numVogais

}}


Nome: Paulo <enter>Vogais: 3

12.7.5 Escreva o método calculaHipotenusa. O método recebe o cateto adjacente (b) e o cateto oposto (a) e retorna o valor da hipotenusa dado pela seguinte fórmula:

Fórmula: h2 = a2 + b2

// ------------------------------------------------------------ Fonte: Hipotenusa.cs

using System;

namespace Hipotenusa{ class MainClass { public static void Main (string[] args) { Console.Write ("Cateto Adjacente: ");

87

String s = Console.ReadLine (); float a = float.Parse (s); Console.Write ("Cateto Oposto: "); s = Console.ReadLine (); float b = float.Parse (s); float h = calculaHipotenusa (a, b); Console.WriteLine ("Hipotenusa: {0}", h); } // ---------------------------- calculaHipotenusa }}


Cateto Adjacente: 3 <enter>Cateto Oposto: 3 <enter>Hipotenusa: 4.242640

12.7.6 Escreva em C# o método calculaReajuste. O método recebe o valor do salário e o índice de reajuste e retorna o salário atualizado.

// ------------------------------------------------------------ Fonte: Reajuste.cs

using System;

namespace Reajuste{ class MainClass { public static void Main (string[] args) { Console.Write ("Salário (R$): "); String s = Console.ReadLine (); float salario = float.Parse (s); Console.Write ("Índice de Reajuste: "); s = Console.ReadLine (); float indice = float.Parse (s); float reajuste = calculaReajuste (salario, indice); Console.WriteLine ("Salário Atualizado (R$): {0}", reajuste); } // ---------------------------- calculaReajuste }}


Salário (R$): 1000 <enter>Índice de Reajuste: 10 <enter>Salário Atualizado (R$): 1100

13. Classes existentes em C#

C# possui diversas classes pré-existentes chamadas de coleções. A seguir são descritas algumas delas.

Tabela 16: Classes em C#

Classes DescriçãoObject Classe base de objetosList <T> Lista fortemente tipada de objetosArrayList Representa uma matriz de objetos dinâmicaIList Representa uma coleção de objetos não-genéricos

que podem ser acessados individualmente pelo índice

SortedList Representa uma coleção de pares chave/valor que são ordenados pelas chaves e são acessíveis por chave e por índice

HashTable Representa uma coleção de pares de chave / valor que são organizados com base no código de hash da chave

Queue FilaStack Pilha

88

Collections (Coleções)

Pacote: using System.Collections;

Em CSharp uma coleção é uma classe.

13.1 Object (classe base de objetos) em C#

A classe Object dá suporte a todas as outras classe do C#, ela fornece os serviços de baixo nível para as classes derivadas. Ela é a classe base de todas as outras classes.

Pacote: using System;

Tabela 17: Principais métodos da classe ObjectMétodo DescriçãoEquals(Object) Verifica se o objeto especificado é igual ao objeto atualEquals(Object, Object) Verifica se as instâncias dos objetos especificados são iguais

Finalize Permite que um objeto libere recursos e execute outras operações de limpeza antes do coletor de lixo

GetHashCode Serve como a função hash padrãoGetType Obtém o tipo da instância atualMemberwiseClone Cria uma cópia do objeto atualReferenceEquals Determina se as instâncias dos objetos são iguaisToString Retorna uma string que representa o objeto atual

// ------------------------------------------------------------ Fonte: Objeto.cs

using System;

namespace Objeto{ class MainClass { public static void Main (string[] args) { Object[] objeto = new Object[3];

objeto[0] = new { primeiroNome = "Paulo", ultimoNome = "Luzzardi" }; objeto[1] = new { marca = "Mercedes" }; objeto[2] = new { cidade = "Pelotas", estado = "RS" }; Console.WriteLine (objeto[0]); Console.WriteLine (objeto[1]); Console.WriteLine (objeto[2]); } }}


{ primeiroNome = Paulo, ultimoNome = Luzzardi }{ marca = Mercedes }{ cidade = Pelotas, estado = RS }

13.2 List (lista tipada de objetos) em C#

A classe List permite criar uma lista tipada com qualquer tipo, ou seja, o programador escolhe que tipo vai poder utilizar, isto pode ser chamado de lista genérica.

Pacote: using System.Collections.Generic;

Tabela 18: Construtores da classe List <T>

89

Construtor DescriçãoList<T>() Inicializa com uma nova instância da classe List<T> vazia

List<T>(IEnumerable<T>) Inicializa com uma nova instância da classe List<T> com elementos copiados de uma coleção especificada

List<T>(Int32) Inicializa com uma nova instância da classe List<T> vazia com uma quantidade especificada

A seguir são descritos os principais métodos da classe List <T>.

Tabela 19: Principais métodos da classe List <T>

Método FuncionamentoAdd Adiciona um objeto para o fim da List<T>

BinarySearch(T) Pesquisa o List<T> para um elemento utilizando o comparador padrão e retorna o índiceClear Remove todos os elementos da List<T>Contains Determina se um elemento está presente na List<T>CopyTo(T[]) Copia todo o List<T> para um vetorEquals(Object) Verifica se o objeto especificado é igual ao objeto atualExists Determina se o List<T> contém os elementos

Find Pesquisa um elemento e retorna a primeira ocorrência dentro de toda a List<T>

FindAll Recupera os elementos

FindLast Pesquisa um elemento e retorna a última ocorrência dentro de toda a List<T>.

ForEach Percorre todos os elemento da List<T>GetType Obtém o tipo do objetoIndexOf(T) Procura o objeto e retorna o índiceInsert Insere um elemento para o List<T>Remove Remove a primeira ocorrência de um objeto no List<T>RemoveAll Remove todos os elementos especificadosSort() Ordena os elementos do List<T>ToArray Copia os elementos do List<T> para um vetorToString Retorna em forma de string

// ------------------------------------------------------------ Fonte: TestList.cs

using System;using System.Collections.Generic;

namespace TestList{ class MainClass { public static void Main (string[] args) { var pessoas = new List<string> { "Paulo Roberto", "Renato Luis", "Francisco", "Ana Maria", "Julia Helena" };

for (var index = 0; index < pessoas.Count; index++) { Console.WriteLine(pessoas[index] + " "); } } }}


Paulo RobertoRenato LuisFrancisco Ana Maria Julia Helena

13.3 ArrayList (lista de arrays) em C#

90

A classe ArrayList permite criar um vetor dinâmico, ou seja, o número de elementos cresce enquanto houver memória livre para a inserção dos elementos.


Tabela 20: Construtores da classe ArrayList

Construtor() Descrição

ArrayList() Inicializa uma nova instância da classe ArrayList que está vazia e tem a capacidade de padrão inicial

ArrayList(ICollection)Inicializa uma nova instância da classe ArrayList que contêm os elementos copiados de coleção especificada e que possui a mesma capacidade inicial que o número de elementos copiou

ArrayList(Int32) Inicializa uma nova instância da classe ArrayList que está vazia e tem a capacidade inicial especificada

A seguir são descritos os principais métodos da classe ArrayList.

Tabela 21: Principais métodos da classe ArrayList Método DescriçãoAdd Adiciona um objeto no final do ArrayListBinarySearch(Object) Procura um objeto em um ArrayList ordenadoClear Remove todos os elementos de ArrayListClone Cria uma cópia de ArrayListContains Verifica se um elemento está no ArrayListCopyTo(Array) Copia o ArrayList a um vetor 1DCopyTo(Array, Int32) Copia o ArrayList a um vetor 1D, a partir do índice especificadoEquals(Object) Verifica se o objeto especificado é igual ao objeto atual

GetRange Retorna o ArrayList que representa um subconjunto dos elementos do ArrayList.

GetType Obtém o tipo do ArrayList

IndexOf(Object) Pesquisa por objetos e retorna o índice da primeira ocorrência dentro de ArrayList

Insert Insere um elemento em ArrayList no índice Remove Remove a primeira ocorrência de um objeto do ArrayListRemoveAt Remove o elemento no índice de ArrayListRemoveRange Remove um intervalo de elementos de ArrayListRepeat Retorna ArrayList cujos elementos são cópias do valorReverse() Inverte a ordem dos elementos do ArrayList

SetRange Copia elementos da coleção de um intervalo de elementos do ArrayList

Sort() Ordena os elementos em ArrayListToArray() Copia elementos de ArrayList para um novo vetorToString Retorna uma string que representa o objeto

Programa Exemplo: Programa mostra um exemplo de dois arrays que armazenam respectivamente: nomes e idades.

// ------------------------------------------- Fonte: TestaArrayList.cs

using System;using System.Collections;

namespace TestaArrayList{ class MainClass { public static void Main (string[] args) { ArrayList nome = new ArrayList (); nome.Add("Paulo Roberto"); nome.Add (51); nome.Add("Renato Luis");

91

nome.Add (49); nome.Add("Francisco Carlos"); nome.Add (53); nome.Add("Ana Maria"); nome.Add (55); nome.Add("Julia Helena"); nome.Add (54);

foreach (Object obj in nome) { Console.WriteLine("{0}", obj); } } }}


Paulo Roberto51Renato Luis49Francisco Carlos53Ana Maria55Julia Helena54

13.4 IList (lista de objetos indexados) em C#

A classe IList representa uma coleção de objetos não-genéricos que podem ser acessados individualmente pelo índice.


Tabela 22: Principais métodos da classe IList

Método DescriçãoAdd Adiciona um item a IList.Clear Remove todos os itens de IList.Contains Determina se IList contém um valor específico.

CopyTo Copia os elementos da ICollection para um Array, inicial de um determinado Array índice. (Herdado de ICollection)

GetEnumerator Retorna um enumerador que executa iterações através de uma coleção. (Herdado de IEnumerable)IndexOf Determina o índice de um item específico em IList.Insert Insere um item a IList no índice especificado.Remove Remove a primeira ocorrência de um determinado objeto de IList.RemoveAt Remove o item de IList no índice especificado.

// ------------------------------------------- Fonte: IListTeste.cs

using System;using System.Collections.Generic;

class IListTeste{ static void exibeLista (IList<int> lista) { foreach (int value in lista) { Console.WriteLine ("Elemento: " + value); } Console.WriteLine ("Total de Elementos: {0}", lista.Count); }

public static void Main (string[] args) { int[] vetor = new int[3]; vetor [0] = 10; vetor [1] = 20;

92

vetor [2] = 30; exibeLista (vetor);

List<int> lista = new List<int> (); lista.Add (40); lista.Add (50); lista.Add (60); lista.Add (70); exibeLista (lista); }}


Elemento: 10Elemento: 20Elemento: 30Total de Elementos: 3Elemento: 40Elemento: 50Elemento: 60Elemento: 70Total de Elementos: 4

13.5 Stack (Pilha) em C#

A classe Stack é utilizada para armazenar elementos em uma Pilha.


A seguir são descritos os principais métodos da classe Stack.

Tabela 23: Principais métodos da classe Stack

Método DescriçãoCount Retorna o número de elementos da pilhaClear Remove todos os objetos da pilhaClone Create uma copia da pilhaContains Verifica se um elemento está na pilhaCopyTo Copia a pilha para um array 1DEquals(Object) Determina se o objeto especificado é igual ao objetoGetType Obtém o tipoPeek Retorna o objeto no topo da pilha sem removê-loPop Remove e retorna o objeto no topo da pilhaPush Insere um objeto no topo da pilhaToArray Copia a pilha para um novo vetorToString Retorna uma string que representa o objeto atual

Programa Exemplo: Exemplo de uma pilha usando a classe Stack.

// --------------------------------------------- Fonte: Pilha.cs


namespace Pilha{ class MainClass { public static void Main (string[] args) { Stack pilha = new Stack(); int nodo;

do { Console.Write("Nodo: "); String s = Console.ReadLine(); nodo = int.Parse(s);

93

if (nodo != 0) { pilha.Push(nodo); } } while (nodo != 0); String extenso = ""; int n = pilha.Count; Console.WriteLine ("Número de Elementos: " + n); for (int i = 0;i < n;i++ ) { extenso = extenso + pilha.Pop () + " "; } Console.WriteLine("Pilha: " + extenso); } }}


Nodo: 10Nodo: 20Nodo: 30Nodo: 40Nodo: 50Nodo: 0Número de Elementos: 5Pilha: 50 40 30 20 10

13.6 Queue (Fila) em C#

A classe Queue é utilizada para armazenar elementos em uma Fila.


A seguir são descritos os principais métodos da interface queue.

Tabela 24: Principais métodos da classe Queue

Método DescriçãoClear Remove todos os objetos da filaClone Create uma cópia da filaContains Verifica se um elemento está na filaCopyTo Copia os elementos da fila para um vetor 1DDequeue Remove e retorna o objeto do início da filaEnqueue Adiciona um objeto no fim da filaEquals(Object) Determine se um objeto específico é igual a um objeto da filaGetType Obtém o tipo do elemento da filaPeek Retorna o objeto no início do fila sem removê-loToArray Copia os elementos da fila para um vetor 1DToString Retura uma string que representa os objetos da fila

Programa Exemplo: Exemplo de uma fila usando a classe Queue.

// -------------------------------------- Fonte: Fila.cs


namespace Fila{ class MainClass { public static void Main (string[] args) { Queue fila = new Queue(); int nodo;

do { Console.Write("Nodo: "); String s = Console.ReadLine();

94

nodo = int.Parse(s); if (nodo != 0) { fila.Enqueue(nodo); } } while (nodo != 0); String extenso = ""; int n = fila.Count; for (int i = 0;i < n;i++) { extenso = extenso + fila.Dequeue() + " "; } Console.WriteLine("Fila: " + extenso); } }}


Nodo: 10Nodo: 20Nodo: 30Nodo: 40Nodo: 50Nodo: 0Número de Elementos: 5Fila: 10 20 30 40 50

14. Entrada e saída em disco (Arquivos) em C#

Em C# é possível manipular arquivos através da classe File (Arquivo).

14.1 Métodos para manipular arquivos em C#

A seguir são descritos os principais métodos da classe StreamReader para manipular arquivos em C#:

Tabela 25: Principais métodos da classe StreamReader

Método DescriçãoClose Fecha o arquivoEquals(Object) Verifica se o arquivo é igual ao arquivo especificado Peek Retorna o próximo caracter disponível

Read() Lê o próximo caracter de fluxo de entrada e avança a posição do por um caracter, ou seja, acesso sequencial

Read(Char[], Int32, Int32)

Lê o máximo especificado de caracteres de fluxo atual em um buffer, começando no índice especificado

ReadBlock Lê o número máximo especificado de caracteres de fluxo atual e grava os dados de um buffer, começando no índice especificado

ReadLine Lê uma linha de caracteres e retorna os dados como uma cadeia de caracteres

ToString Retorna uma string que representa o objeto atual

14.2 Abertura de um arquivo texto em C#

A seguir serão vistos alguns programas exemplos mostrando a manipulação de arquivos em C#.

Programa exemplo: O programa abre um arquivo texto e exibe o número de bytes do referido arquivo.

// ----------------------------------------- Fonte: File1.cs

using System;using System.IO;

namespace File1

95

{ class MainClass { public static void Main (string[] args) { String path = "/Users/pluzzardi/"; Console.Write ("Nome do Arquivo Texto: "); String nomeArquivo = Console.ReadLine (); nomeArquivo = path + nomeArquivo; try { long bytes = 0; using (StreamReader file = new StreamReader (nomeArquivo)) { string line; while ((line = file.ReadLine ()) != null) { bytes = bytes + line.Length; } Console.WriteLine ("Arquivo: " + nomeArquivo); Console.WriteLine ("Bytes: " + bytes);

} } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); } } }}


Nome do Arquivo Texto: luzzardi.txtArquivo: /Users/pluzzardi/luzzardi.txtBytes: 125

ou

Nome do Arquivo Texto: banana.txtErro: Arquivo não existeCould not find file "/Users/pluzzardi/banana.txt".

A seguir são descritos os principais métodos da classe StreamWriter para manipular arquivos em C#:

Tabela 26: Principais métodos da classe StreamWriter

Método DescriçãoClose Fecha o arquivoDispose() Libera qualquer recurso utilizado pelo arquivoEquals(Object) Verifica se o arquivo especificado é igual ao arquivo atual

Flush Limpa todos os buffers para o gravador atual e força gravação em disco

ToString Retorna uma string que representa o arquivo atualWrite(tipo_base) Grava o tipo_base no arquivo

WriteLine() Grava um terminador de linha para a cadeia de caracteres de texto ou para o fluxo

WriteLine(tipo_base) Grava o tipo_base no arquivo com newLine

14.3 Listar um diretório em C#

Programa exemplo: O programa exibe na tela (lista) os arquivos e diretórios do “pathname” especificado.

// ------------------------------------------- Fonte: FileDir.cs


namespace FileDir{ public class MainClass

96

{ public static void Main () { DirectoryInfo diretorio = new DirectoryInfo ("/Users/pluzzardi"); // --------------------------------------------------------------------- listar diretório DirectoryInfo[] fileDir = diretorio.GetDirectories (); Console.WriteLine ("Lista de Diretórios: "); foreach (DirectoryInfo dirinfo in fileDir) { Console.WriteLine (dirinfo.Name); } // ---------------------------------------------------------------------- listar arquivos Console.WriteLine ("Lista de Arquivos: "); FileInfo[] files = diretorio.GetFiles ("*.*"); foreach (FileInfo fileinfo in files) { Console.WriteLine (fileinfo.Name); } } }}


Lista de Diretórios: .Trash.config.cups.dropbox.local.netbeans-derby.sshDesktopDocumentsDownloadsDropboxLibraryMoviesMusicNetBeansProjectsPicturesProjectsPublicLista de Arquivos: .CFUserTextEncoding.DS_Store.bash_history.gbas.viminfoFrutas.txtLeitura.zipLuzzardi.txtfrutas.luznomes.txt

Programa exemplo: O programa exibe (lista) na tela os arquivos e diretórios do pathname especificado pelo usuário.

// -------------------------------------------- Fonte: FileDir2.cs


namespace FileDir2{ public class MainClass { public static void Main () { Console.Write ("Pathname: "); String pathName = Console.ReadLine (); DirectoryInfo diretorio = new DirectoryInfo (pathName); // --------------------------------------------------------------------- listar diretório DirectoryInfo[] fileDir = diretorio.GetDirectories (); Console.WriteLine ("Lista de Diretórios: "); foreach (DirectoryInfo dirinfo in fileDir) { Console.WriteLine (dirinfo.Name);

97

} // ---------------------------------------------------------------------- listar arquivos Console.WriteLine ("Lista de Arquivos: "); FileInfo[] files = diretorio.GetFiles ("*.*"); foreach (FileInfo fileinfo in files) { Console.WriteLine (fileinfo.Name); } } }}


Pathname: /Users/pluzzardiLista de Diretórios: .Trash.config.cups.dropbox.local.netbeans-derby.sshDesktopDocumentsDownloadsDropboxLibraryMoviesMusicNetBeansProjectsPicturesProjectsPublicLista de Arquivos: .CFUserTextEncoding.DS_Store.bash_history.gbas.viminfoFrutas.txtLeitura.zipLuzzardi.txtfrutas.luznomes.txt

14.4 Manipulação de um arquivo texto de palavras em C#

A seguir são mostrados alguns programas exemplos que manipulam um arquivo texto contendo palavras. Veja o formato no exemplo abaixo:

5 <enter>carambolaberingelaabacateervilhadamasco

Programa exemplo: O programa permite criar um arquivo de palavras (palavras.dat) permitindo a gravação destas palavras.

// --------------------------------------------- Fonte: FileWrite.cs


namespace FileWrite{ class MainClass { public static void Main (string[] args) { String line;

98

String path = "/Users/pluzzardi/"; String nomeArquivo = "palavras.dat"; nomeArquivo = path + nomeArquivo; if (!File.Exists (nomeArquivo)) { try { using (StreamWriter file = new StreamWriter (nomeArquivo)) { Console.Write ("Número de palavras: "); String s = Console.ReadLine (); int numeroPalavras = int.Parse (s); file.WriteLine(s); for (int i = 1; i <= numeroPalavras; i++) { Console.Write ("Palavra: "); line = Console.ReadLine (); file.WriteLine (line); } file.Close(); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); } } else { Console.WriteLine ("Erro: Arquivo já existe"); } } }}


Número de palavras: 5 <enter>Palavra: carambola <enter>Palavra: beringela <enter>Palavra: abacate <enter>Palavra: ervilha <enter>Palavra: damasco <enter>

Arquivo gerado:

5carambolaberingelaabacateervilhadamasco

Programa exemplo: O programa permite abrir o arquivo de palavras (palavras.dat) e exibe-os na tela.

// ------------------------------------------ Fonte: FileRead.cs


namespace FileRead{ class MainClass { public static void Main (string[] args) { String path = "/Users/pluzzardi/"; String nomeArquivo = "palavras.dat"; nomeArquivo = path + nomeArquivo; try { using (StreamReader file = new StreamReader (nomeArquivo)) { string line; while ((line = file.ReadLine ()) != null) { Console.WriteLine(line); } file.Close(); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message);

99

} } }}


5carambolaberingelaabacateervilhadamasco

Programa exemplo: O programa permite consultar o arquivo de palavras (palavras.dat). Para tanto é solicitado, ao usuário, o número do registro para ser calculado a posição deste registro no arquivo. Logo após o registro é exibido na tela.

// ----------------------------------------- Fonte: FileConsulta.cs


namespace FileConsulta{ class MainClass { public static void Main (string[] args) { int numeroLinhas; String path = "/Users/pluzzardi/"; String nomeArquivo = "palavras.dat"; nomeArquivo = path + nomeArquivo; try { using (StreamReader file = new StreamReader (nomeArquivo)) { numeroLinhas = System.IO.File.ReadAllLines(nomeArquivo).Length; Console.WriteLine("Número de Linhas: " + numeroLinhas); String [] linhas = new String[numeroLinhas]; string line; int n = 0; while ((line = file.ReadLine ()) != null) { linhas[n] = line; n++; } file.Close(); int posicao; do { Console.Write("Posição da Linha [1.." + numeroLinhas + "]: "); String s = Console.ReadLine(); posicao = int.Parse(s); if (posicao >= 1 && posicao <= numeroLinhas) { Console.WriteLine("Linha: " + linhas[posicao - 1]); } else { Console.WriteLine("Erro: Posição Inválida"); } } while (posicao != 0); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); } } }}


Número de Linhas: 6Posição da Linha [1..6]: 1Linha: 5Posição da Linha [1..6]: 2Linha: carambolaPosição da Linha [1..6]: 3

100

Linha: beringelaPosição da Linha [1..6]: 4Linha: abacatePosição da Linha [1..6]: 5Linha: ervilhaPosição da Linha [1..6]: 6Linha: damascoPosição da Linha [1..6]: 7Erro: Posição InválidaPosição da Linha [1..6]: 0Erro: Posição Inválida

14.5 Arquivo Texto em C#

A seguir é mostrado um programa que lê um arquivo texto contendo: (a) Total de Palavras e (b) Lista de Palavras (nome de frutas) e sorteia e exibe na tela uma destas palavras

Arquito Texto: Frutas.txt

15abacaxiabacatebananapitangagoiabamorangocarambolakiwilaranjabergamotatomateuvacaquilimajaca

// ---------------------------------------------- Fonte: Leitura.cs


namespace Leitura{ class MainClass { public static void Main (string[] args) { int numeroLinhas; String path = "/Users/pluzzardi/"; String nomeArquivo = "frutas.txt"; nomeArquivo = path + nomeArquivo; try { using (StreamReader file = new StreamReader (nomeArquivo)) { numeroLinhas = System.IO.File.ReadAllLines(nomeArquivo).Length; Console.WriteLine("Número de Linhas: " + numeroLinhas); String [] linhas = new String[numeroLinhas]; string line; int n = 0; while ((line = file.ReadLine ()) != null) { linhas[n] = line; Console.WriteLine(line); n++; } file.Close(); Random rnd = new Random (); int numeroSorteado = rnd.Next (numeroLinhas); Console.WriteLine("Palavra Sorteada: " + linhas[numeroSorteado]); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); }

101

} }}


Total de palavras: 15Palavra: abacaxiPalavra: abacatePalavra: bananaPalavra: pitangaPalavra: goiabaPalavra: morangoPalavra: carambolaPalavra: kiwiPalavra: laranjaPalavra: bergamotaPalavra: tomatePalavra: uvaPalavra: caquiPalavra: limaPalavra: jacaPalavra Sorteada: bergamota

A seguir é mostrado um programa que lê um arquivo texto contendo: (a) Total de Palavras e (b) Lista de Palavras (nome de frutas) lendo as linhas do arquivo texto com Read.

// ---------------------------------------------- Fonte: Acesso.cs

using System;using System.IO;using System.Text;

namespace Acesso{ class MainClass { public static void Main (string[] args) { Console.Write ("Nome do arquivo texto: "); string path = Console.ReadLine (); if (File.Exists (path)) { using (FileStream arq = File.OpenRead (path)) { byte[] line = new byte[1024]; while (arq.Read (line, 0, line.Length) > 0) {

int i = 0; while (line [i] != 10) { Console.Write ((char)line [i]); i++; if (line [i] == 13) { Console.WriteLine (); } } } arq.Close (); } } else { Console.WriteLine ("Erro: Problema no Arquivo"); } } }}


Nome do arquivo texto: /Users/pluzzardi/frutas.txt15abacaxiabacatebananapitangagoiabamorango

102

carambolakiwilaranjabergamotatomateuvacaquilimajaca

A seguir é mostrado um outro programa que lê um arquivo texto exibindo: (a) Número de Linhas e (b) Número de Bytes.

// --------------------------------------------------- Fonte: Bytes.cs


namespace Bytes{ class MainClass { public static void Main (string[] args) { Console.Write ("Nome do Arquivo Texto: "); String nomeArquivo = Console.ReadLine (); try { using (StreamReader file = new StreamReader (nomeArquivo)) { long linhas = System.IO.File.ReadAllLines(nomeArquivo).Length; long bytes = 0; string line; while ((line = file.ReadLine ()) != null) { bytes += line.Length; } file.Close(); Console.WriteLine(linhas + " Linhas(s)"); Console.WriteLine(bytes + " Byte(s)"); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); } } }}


Nome do Arquivo Texto: /Users/pluzzardi/Frutas.txt16 Linha(s)93 Byte(s)

A seguir é mostrado um outro programa que lê um arquivo texto exibindo:

a) Todas as linhas do arquivo texto com seu respectivo númerob) Número de Linhasc) Número de Bytes

// --------------------------------------------------- Fonte: Listar.cs


namespace Listar{ class MainClass { public static void Main (string[] args) { Console.Write ("Nome do Arquivo Texto: "); String nomeArquivo = Console.ReadLine (); try {

103

using (StreamReader file = new StreamReader (nomeArquivo)) { long linhas = System.IO.File.ReadAllLines(nomeArquivo).Length; long bytes = 0; string line; while ((line = file.ReadLine ()) != null) { bytes += line.Length; Console.WriteLine(line); } file.Close(); Console.WriteLine(linhas + " Linhas(s)"); Console.WriteLine(bytes + " Byte(s)"); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message); } } }}


Nome do Arquivo: /Users/luzzardi/Frutas.txt 1: 15 2: abacaxi 3: abacate 4: banana 5: pitanga 6: goiaba 7: morango 8: carambola 9: kiwi10: laranja11: bergamota12: tomate13: uva14: caqui15: lima16: jaca16 Linha(s)93 Byte(s)

A seguir é mostrado um outro programa que lê um arquivo texto e o número de uma linha e exibe: (a) A linha especificada

// ------------------------------------------------------------ Fonte: Linha.cs


namespace Linha{ class MainClass { public static void Main (string[] args) { Console.Write ("Nome do Arquivo Texto: "); String nomeArquivo = Console.ReadLine (); Console.Write ("Número da Linha: "); int numeroLinha = int.Parse (Console.ReadLine()); int linha = 1; try { using (StreamReader file = new StreamReader (nomeArquivo)) { string line; while ((line = file.ReadLine ()) != null) { if (numeroLinha == linha) { Console.WriteLine(linha + ": " + line); } linha++; } file.Close(); } } catch (Exception e) { Console.WriteLine ("Erro: Arquivo não existe"); Console.WriteLine (e.Message);

104

} } }}


Nome do Arquivo Texto: /Users/pluzzardi/Frutas.txtNúmero da Linha: 5 5: pitanga

14.6 Lista de exercícios (arquivos)

14.6.1 Escreva um programa em C# que recebe via teclado o nome de um arquivo texto. O programa deve imprimir na tela o número de bytes (caracteres) e o número de linhas do arquivo ou ERRO: Arquivo não existe.

Exemplo:

Nome do arquivo texto: LISTA.CS <enter>(12345) Bytes(44) Linhas

ou

ERRO: Arquivo não existe

14.6.2 Escreva um programa em C# que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número da linha. O programa deve imprimir a linha especificada ou ERRO: Linha não existe (zero para abandonar).

Exemplo:

Nome do arquivo texto: LISTA.CS <enter>Número de linha: 7 <enter>7: int i, j, k;Número de linha: 70 <enter>ERRO: Linha não existeNúmero de linha: 0 <enter> // saída do programaERRO: Arquivo não existe

14.6.3 Escreva um programa em C# que recebe via teclado o nome de dois arquivos texto (origem e destino). O programa deve copiar o conteúdo do arquivo origem para o arquivo destino.

Exemplo:

Arquivo origem: LISTA.CS <enter>Arquivo destino: LISTA.tmp <enter>(20345) Bytes copiados

14.6.4 Escreva um programa em C# que recebe via teclado o nome do arquivo texto fonte e o nome do arquivo texto destino. O programa deve converter o arquivo para maiúsculo ou minúsculo (conforme escolha do usuário) gerando o arquivo texto destino.

Exemplo:

Arquivo fonte: LISTA.CS <enter>

105

Arquivo destino: LISTA.TMP <enter>[+] Maiúsculo ou [-] Minúsculo: + <enter>(1234) Bytes convertidos

14.6.5 Escreva um programa em C# que recebe via teclado o nome de um arquivo texto e uma palavra. O programa deve imprimir todas as linhas que possuem esta palavra.

Exemplo:

Nome do arquivo texto: PALAVRA.DAT <enter>Palavra: if <enter>23: if (a == b) {33: if (ch == '\n') {37: if (compara(linha,palavra)) {41: if (ch != '\n') {59: if (linha[i] == palavra[0]) {65: if (linha[k] != palavra[j]) {69: if (achei) {

14.6.6 Escreva um programa em C# que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário consultar o arquivo através da entrada via teclado do número inicial e número final. O programa deve imprimir desde a linha inicial até a linha final ou ERRO: Linhas não existem.

Exemplo:

Nome do arquivo texto: LISTA.CS <enter>Número inicial: 7 <enter>Número final: 9 <enter>7: int i, j, k;8: char tecla;9: long bytes = 0;

ou

Número inicial: 70 <enter>Número final: 90 <enter>ERRO: Linhas não existem

14.6.7 Escreva um programa em C# (grava.cs) que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nomes (máximo 30 caracteres) neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome.

Exemplo:

Nome do arquivo texto: NOMES.DAT <enter>Nome: Beatriz <enter>Nome: Eva <enter>Nome: Debora <enter>Nome: Carla <enter>Nome: Fatima <enter>Nome: Ana <enter>Nome: <enter>

14.6.8 Escreva um programa em C# (ler.cs) que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os nomes armazenados no arquivo pelo programa "grava.cs".

106

Exemplo:

Nome do arquivo texto: NOMES.DAT <enter>Nome: BeatrizNome: EvaNome: DeboraNome: CarlaNome: FatimaNome: Ana

14.6.9 Escreva um programa em C# (sort.cs) que recebe via teclado o nome de um arquivo texto. O programa deve ler, ordenar e gravar novamente os nomes no mesmo arquivo.

Exemplo:

Nome do arquivo texto: NOMES.DAT <enter>Ok, arquivo ordenado

Observação: Utilize o programa anterior (ler.cs) para ver os nomes ordenados.

14.6.10 Escreva um programa em C# (salva.cs) que recebe via teclado o nome de um arquivo texto. O programa deve permitir ao usuário inserir nome, idade e sexo ([M]asculino ou [F]eminino) neste arquivo via teclado. O programa termina quando o usuário digitar <enter> na entrada do nome.

Exemplo:

Nome do arquivo texto: DADOS.DAT <enter>Nome: Paulo Roberto <enter>Idade: 41 <enter>Sexo [M/F]: m <enter>Nome: Renato Luis <enter>Idade: 38 <enter>Sexo [M/F]: m <enter>Nome: Ana Maria <enter>Idade: 44 <enter>Sexo [M/F]: f <enter>Nome: <enter>

14.6.11 Escreva um programa em C# (list.cs) que recebe via teclado o nome de um arquivo texto. O programa deve ler e imprimir na tela todos os dados (nome, idade e sexo) armazenados no arquivo pelo programa "salva.cs" (veja exemplo abaixo).

Exemplo:

Nome do arquivo texto: DADOS.DAT <enter>Nome: Paulo RobertoIdade: 41Sexo: MASCULINONome: Renato LuisIdade: 38Sexo: MASCULINONome: Ana MariaIdade: 44Sexo: FEMININO

107

14.6.12 Escreva um programa em C# (conta.cs) que recebe via teclado o nome de um arquivo texto. O programa deve verificar a quantidade de homens e a quantidade de mulheres no aquivo criado pelo programa "salva.cs".

Exemplo:

Nome do arquivo texto: DADOS.DAT <enter>(2) Homens(1) Mulheres

Solução do problema 14.6.2:

// ------------------------------------------------------------ Fonte: FileSeek.cs

using System.IO;using System.Text;

namespace FileSeek{ class MainClass { public static void Main (string[] args) { int nl, linha = 1; Console.Write ("Nome do arquivo texto: "); string path = Console.ReadLine (); if (File.Exists (path)) { using (FileStream arq = File.OpenRead (path)) { byte[] line = new byte[1024]; while (arq.Read (line, 0, line.Length) > 0) { do { bool existe = false; Console.Write ("Número da Linha: "); String s = Console.ReadLine (); nl = int.Parse (s); Console.Write (linha + ": "); int i = 0; while (line [i] != 10) { if (nl == linha) { Console.Write ((char)line [i]); existe = true; } i++; if (line [i] == 13) { linha++; } } if (!existe) { Console.Write("Erro: Linha não existe"); } linha = 1; Console.WriteLine (); } while (nl != 0); } // arq.Seek (0, SeekOrigin.Begin); arq.Close (); } } else { Console.WriteLine ("Erro: Problema no Arquivo"); } } }}


Nome do arquivo texto: /Users/pluzzardi/frutas.txtNúmero da Linha: 6goiabaNúmero da Linha: 8carambola

108

Número da Linha: 4bananaNúmero da Linha: 901: Erro: Linha não existeNúmero da Linha: 01: Erro: Linha não existe

14.7 Arquivos binários em C#

Arquivos em disco são organizados como uma fila de bytes, enquanto um arquivo texto é organizado com linhas que contém caracteres finalizados com um “\n”, normalmente código 10 (LF - LineFeed) mais código 13 (CR – Carriage Return) e um end of file (EOF) marcando o final do arquivo, um arquivo binário grava e recupera as informações em blocos de dados, ou seja, um número inteiro qualquer é salvo, normalmente com 4 bytes, isto é, um número tipo cpf 12345678909, que seria armazenado num arquivo texto com 11 bytes, é gravado num arquivo binário com apenas 4 bytes.

A seguir é mostrado um resumo das classes que operam com arquivos texto e binários.

Arquivos Textoo StreamReader - escrever em arquivos textoo StreamWriter - ler de arquivos texto

Arquivos Binárioso BinaryWriter – escrever em arquivos binárioso BinaryReader – ler de arquivos binários

Abaixo, note que as declarações para criar e carregar o arquivo binário utilizado nos programas a seguir utilizam os métodos: FileMode.Create e FileMode.Open. Veja na lista abaixo o porque disto.

FileStream file = new FileStream (nomeArquivo, FileMode.Create); FileStream file = new FileStream (nomeArquivo, FileMode.Open);

FileMode.Create: Cria um novo arquivo. Se o arquivo existir, os dados serão adicionados no final

FileMode.CreateNew: Cria um novo arquivo. Se o arquivo já existir, uma exceção será lançada

FileMode.Append: Abre um arquivo e adiciona dados ao final. Se o arquivo não existir, ele é criado

FileMode.Open: Abre um arquivo existente. Se o arquivo não existir, uma exceção será lançada

O programa a seguir mostra a gravação e leitura dos seguintes dados: nome (string), idade (int) e sexo (char) em um arquivo binário.

// ------------------------------------------------------- Fonte: BinaryWrite.cs

using System;using System.Runtime.Serialization.Formatters.Binary;using System.IO;

namespace BinaryWrite{ class MainClass { public static void Main (string[] args) { String nome; Console.Write ("Nome do arquivo binário: "); String nomeArquivo = Console.ReadLine (); FileStream file = new FileStream (nomeArquivo, FileMode.Create); BinaryWriter binario = new BinaryWriter (file); do {

109

Console.Write ("Nome: "); nome = Console.ReadLine (); if ("".CompareTo (nome) != 0) { Console.Write ("Idade: "); String s = Console.ReadLine (); int idade = int.Parse (s); Console.Write ("Sexo [M/F]: "); s = Console.ReadLine (); char sexo = s [0]; binario.Write (nome); binario.Write (idade); binario.Write (sexo); } } while ("".CompareTo (nome) != 0); binario.Close (); file.Close (); } }}


Nome do arquivo binário: /Users/pluzzardi/Pessoas.luzNome: Paulo RobertoIdade: 51Sexo [M/F]: mNome: Renato LuisIdade: 49Sexo [M/F]: mNome: Francisco CarlosIdade: 53Sexo [M/F]: mNome:

// ------------------------------------------------------- Fonte: BinaryRead.cs

using System;using System.Runtime.Serialization.Formatters.Binary;using System.IO;

namespace BinaryRead{ class MainClass { public static void Main (string[] args) { String nome; long bytesLidos = 0; Console.Write ("Nome do arquivo binário: "); String nomeArquivo = Console.ReadLine (); if (File.Exists (nomeArquivo)) { FileStream file = new FileStream (nomeArquivo, FileMode.Open); BinaryReader binario = new BinaryReader (file); long bytes = file.Length; Console.WriteLine ("Bytes: " + bytes); while (bytes > 0) { nome = binario.ReadString (); Console.WriteLine ("Nome: " + nome); int idade = binario.ReadInt32 (); Console.WriteLine ("Idade: " + idade); char sexo = binario.ReadChar (); Console.WriteLine ("Sexo: " + sexo); bytesLidos = nome.Length + sizeof(Int32) + sizeof(char) + 1; // cálculo do número de bytes lidos Console.WriteLine ("Bytes Lidos: " + bytesLidos); bytes = bytes - bytesLidos; Console.WriteLine ("Bytes: " + bytes); } binario.Close (); file.Close (); } else { Console.WriteLine ("Erro: Arquivo não existe"); } }

110

}}


Nome do arquivo binário: /Users/pluzzardi/Pessoas.luzBytes: 58Nome: Paulo RobertoIdade: 51Sexo: mBytes Lidos: 20Bytes: 38Nome: Renato LuisIdade: 49Sexo: mBytes Lidos: 18Bytes: 20Nome: Francisco CarlosIdade: 53Sexo: mBytes Lidos: 23Bytes: -3

15. Conceitos diversos em C#

15.1 Operadores bit a bit em C#

Se referem ao teste, ajuste ou troca de bits reais por um byte ou palavra (podem ser dos tipos char, int, byte, short ou long).

Tabela 27: Operadores bit a bit

Operador Ação& And| Or^ Or exclusivo (XOr)~ Complemento de um (Not)>> Deslocar para a direita (shift)<< Deslocar para a esquerda (shift)

Deslocamento (shift): variável >> número de deslocamentos;

Exemplo:

// ---------------------------------------------- Fonte: bit.cs

using System;

namespace Bit{ class MainClass { public static void Main (string[] args) { int a = 128, b, c; // a = 128 - binário -> 10000000

b = a >> 1; // b = 64 - binário -> 0100000 c = b << 1; // c = 128 -binário -> 1000000 Console.WriteLine("a = {0}",a); Console.WriteLine("b = {0}",b); Console.WriteLine("c = {0}",c); } }}


A = 128b = 64

111

c = 128

15.2 Formas abreviadas de C#

C# tem abreviações especiais que simplificam a codificação de um certo tipo de comando de atribuição.

Exemplo:

x = x + 10; ... pode ser escrito como ... x += 10;

Esta forma abreviada funcionará com todos os operadores aritméticos do C#.

Forma normal: variável = variável operador constante;x = x + 7;

Forma abreviada: variável operador= constante;x += 7;

16. Listas Lineares: Pilha, Fila e Fila Circular em C#

A seguir é visto a implementação de uma Pilha, uma Fila e uma Fila Circular implementada em um vetor de inteiros.

Pilha: Estrutura linear organizada de forma que a entrada e a saída dos dados é feita na mesma extremidade.

Forma de acesso: LIFO (Last Input First Output), ou seja, o último elemento a entrar na pilha é o primeiro a sair dela.

Fila: Estrutura linear organizada em forma que a entrada dos dados é feita por uma extremidade da lista linear e, a saída, é feita na outra extremidade.

Forma de acesso: FIFO (First Input First Output), ou seja, o primeiro elemento a entrar na fila é o primeiro a sair da fila.

E - Entrada de DadosS - Saída de Dados

112

Figura 4: Representação de uma fila e uma pilha

Funcionamento desta pilha: Funcionamento desta fila:

Entrada: 1, 2 e 3 Entrada: 1, 2 e 3 Saída: 3, 2 e 1 Saída: 1, 2 e 3

16.1 Implementação de um lista em vetor em C#

A seguir é visto um programa em C# que simula uma lista linear armazenada em um vetor. Note que o número de elementos da lista é armazenado no primeiro nodo do vetor, ou seja, v[0].

Programa exemplo: O programa permite inserir números inteiros em uma Lista Linear implementada em um vetor. Quando o número digitado for igual à zero (0), todos os números da lista são listados.

// ----------------------------------------------- Fonte: Linear.cs

using System;

namespace Linear{ class MainClass { const int SUCESSO = 0; const int LISTA_CHEIA = 1; const int LISTA_VAZIA = 2; // -------------------------------------------------- criaLista static void criaLista (int[] v) { v [0] = 0; // armazena o número de elementos da lista } // -------------------------------------------------- incluiFim static int incluiFim (int m, int[] v, int valor) { int n = v [0];

if (n < m - 1) { v [0]++; v [v [0]] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- exibeLista static void exibeLista (int[] v) { String s = ""; int n = v [0];

if (n == 0) Console.WriteLine ("Erro: Lista Vazia"); else { for (int i = 1; i <= n; i++) s = s + v [i] + " "; Console.WriteLine ("Lista: " + s); } }

public static void Main (string[] args) { const int m = 7; int[] v = new int [m]; int valor; int erro = 0;

criaLista (v); do { Console.Write ("Elemento: "); String s = Console.ReadLine();

113

valor = int.Parse (s); if (valor != 0) erro = incluiFim (m, v, valor); if (erro == LISTA_CHEIA) { Console.WriteLine("Erro: Lista Cheia"); exibeLista (v); return; } } while (valor != 0); exibeLista (v); } }}


Elemento: 10Elemento: 20Elemento: 30Elemento: 40Elemento: 50Elemento: 0Lista: 10 20 30 40 50

Programa exemplo: O programa permite inserir ([I]nício, [P]osição ou [F]im) números inteiros em uma Lista Linear implementada em um vetor. Quando o número digitado for igual à zero (0), todos os números da lista são exibidos na tela.

// --------------------------------------------------------- Fonte: Linear2.cs

using System;

namespace Linear2{ class MainClass { const int SUCESSO = 0; const int LISTA_CHEIA = 1; const int LISTA_VAZIA = 2; // -------------------------------------------------- criaLista static void criaLista (int[] v) { v [0] = 0; // armazena o número de elementos } // -------------------------------------------------- incluiFim static int incluiFim (int m, int[] v, int valor) { int n = v [0];

if (n < m - 1) { v [0]++; v [v [0]] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- incluiInic static int incluiInic (int m, int[] v, int valor) { int n = v [0];

if (n < m - 1) { v [0]++; for (int i = n + 1; i >= 2; i--) v [i] = v [i - 1]; v [1] = valor; return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- incluiPos static int incluiPos (int m, int[] v, int valor, int pos) {

114

int n = v [0];

if (n < m - 1) { v [0]++; if (pos == v [0] - 1) { v [v [0]] = v [n]; v [n] = valor; } else { for (int i = n + 1; i >= pos; i--) { v [i] = v [i - 1]; Console.WriteLine ("Valor: " + v [i]); } v [pos] = valor; } return(SUCESSO); } else return(LISTA_CHEIA); } // -------------------------------------------------- tamanhoLista static int tamanhoLista (int[] v) { return(v [0]); } // -------------------------------------------------- exibeLista static void exibeLista (int[] v) { String s = ""; int n = v [0];

if (n == 0) { Console.WriteLine ("Erro: Lista Vazia"); } else { for (int i = 1; i <= n; i++) s = s + v [i] + " "; Console.WriteLine ("Lista: " + s); } }

public static void Main (string[] args) { const int m = 7; int[] v = new int [m]; int valor, pos, n; int erro = 0;

criaLista (v); do { Console.Write ("Elemento [0 - sair]: "); String s = Console.ReadLine (); valor = int.Parse (s); if (valor != 0) { Console.Write ("[I]inicio, [P]osição ou [F]im: "); s = Console.ReadLine(); char op = s [0]; switch (op) { case 'I': case 'i': erro = incluiInic (m, v, valor); break; case 'P': case 'p': n = tamanhoLista (v); do { Console.Write ("Posição [1.." + n + "]: "); s = Console.ReadLine (); pos = int.Parse (s); } while (pos < 1 && pos > n); erro = incluiPos (m, v, valor, pos); break; case 'F': case 'f': erro = incluiFim (m, v, valor); break; } if (erro == LISTA_CHEIA) {

115

Console.WriteLine ("Erro: Lista Cheia"); exibeLista (v); return; } } } while (valor != 0); exibeLista (v); } }}


Elemento [0 - sair]: 10[I]inicio, [P]osição ou [F]im: iElemento [0 - sair]: 20[I]inicio, [P]osição ou [F]im: fElemento [0 - sair]: 40[I]inicio, [P]osição ou [F]im: fElemento [0 - sair]: 30[I]inicio, [P]osição ou [F]im: pPosição [1..3]: 3Elemento [0 - sair]: 0Lista: 10 20 30 40

16.2 Implementação de uma Pilha em C#

A seguir é mostrado uma implementação de Pilha usando a classe Pilha.

Programa exemplo: O programa permite inserir números inteiros em uma Pilha usando uma classe Pilha implementada pelo programador. Quando o número digitado for igual à zero (0), todos os números da pilha são listados.

// -------------------------------------------------------- Fonte: TestaPilha.cs

using System;

namespace TestaPilha{ class MainClass { public static void Main (string[] args) { Pilha pilha = new Pilha(5); int nodo;

do { Console.Write("Elemento: "); String s = Console.ReadLine(); nodo = int.Parse(s); if (nodo != 0) pilha.push(nodo); } while (nodo != 0); pilha.exibe(); } }}

// ---------------------------------------------------------- Fonte: Pilha.cs

using System;

namespace TestaPilha{ public class Pilha { private int topo; private int [] dados;

// ----------------------------------------------- construtor

116

public Pilha(int numElementos) { // construtor dados = new int[numElementos]; topo = -1; }

// ------------------------------------------------ push

public void push(int i) { int n = dados.Length;

if (topo < n-1) { topo++; dados[topo] = i; } else Console.WriteLine("Erro: Pilha Cheia"); }

// ------------------------------------------------ pop

public int pop() { if (topo != 0) { int valor = dados[topo]; topo--; return(valor); } else return(0); }

// ------------------------------------------------ exibe

public void exibe() { Console.Write("Pilha: "); for (int i = topo;i >= 0;i--) { Console.Write(dados[i] + " "); } Console.WriteLine(); } }}


Elemento: 10Elemento: 20Elemento: 30Elemento: 40Elemento: 50Elemento: 60Erro: Pilha CheiaElemento: 0Pilha: 50 40 30 20 10

16.3 Implementação de uma Fila em C#

A seguir é visto uma implementação de uma Fila usando a classe Fila escrita pelo programador.

Programa exemplo: O programa permite inserir números inteiros em uma Fila usando uma classe Fila implementada pelo programador. Quando o número digitado for igual à zero (0), todos os números da fila são listados.

// ------------------------------------------------- Fonte: TestaFila.cs

using System;

namespace TestaFila{ class MainClass {

117

public static void Main (string[] args) { Fila fila = new Fila (5); int nodo;

do { Console.Write ("Elemento: "); String s = Console.ReadLine (); nodo = int.Parse (s); if (nodo != 0) fila.insereFila (nodo); } while (nodo != 0); nodo = fila.retiraFila (); if (nodo == 0) { Console.WriteLine ("Fila: Vazia"); } else { String nodos = ""; while (nodo != 0) { nodos = nodos + nodo + " "; nodo = fila.retiraFila (); } Console.WriteLine ("Fila: " + nodos); } } }}

// --------------------------------------------------- Fonte: Fila.cs

using System;

namespace TestaFila{ public class Fila { private int inic, fim, n; private int [] dados;

// ---------------------------------------- construtor

public Fila(int numElementos) { // construtor inic = -1; fim = 0; n = 0; dados = new int[numElementos]; }

// ------------------------------------------------ insereFila

public void insereFila(int i) { int max = dados.Length;

if (n < max) { dados[fim] = i; fim++; n++; } else Console.WriteLine("Erro: Fila Cheia"); }

// ------------------------------------------------ retiraFila

public int retiraFila() { if (n != 0) { inic++; n--; return(dados[inic]); } else return(0); } }}

118


Elemento: 10Elemento: 20Elemento: 30Elemento: 40Elemento: 50Elemento: 60Erro: Fila CheiaElemento: 0Fila: 10 20 30 40 50

16.4 Implementação de uma Fila Circular em C#

Um problema que ocorre em estruturas de dados do tipo Fila é que após algumas operações de inserção e remoção de elementos, pode existir nodos vagos que não podem ser reaproveitados, pois normalmente uma fila possui três informações que a controlam: primeiro, último e número de elementos, não permitindo que os nodos excluídos sejam ocupados novamente.

Uma forma de resolver este problema, é a utilização de uma Fila Circular, onde todo nodo inserido ou removido tem sua posição calculada por uma equação, fazendo com que, desta forma, sempre todos os nodos sejam reocupados com uma informação.

Programa exemplo: O programa permite inserir números inteiros em uma Fila Circular, ou seja, existe reaproveitamento da fila. Quando o número digitado for igual à zero (0), todos os números da fila são listados.

// ------------------------------------------------------------ Fonte: Circular.cs

using System;

namespace Circular{ class MainClass { public static void Main (string[] args) { FilaCircular fila = new FilaCircular(5); int valor; char ch;

do { Console.Write("[I]ncluir, [E]xcluir ou [F]im? "); do { String s = Console.ReadLine(); ch = s[0]; } while (ch != 'I' && ch != 'i' && ch != 'E' && ch != 'e' && ch != 'F' && ch != 'f'); switch (ch) { case 'I': case 'i': Console.Write("Valor: "); String s = Console.ReadLine(); valor = int.Parse(s); fila.insereFilaCircular(valor); break; case 'E': case 'e': valor = fila.excluiFilaCircular(); Console.WriteLine("Elemento Retirado da Fila: " + valor); break; } } while (ch != 'F' && ch != 'f'); fila.exibeFilaCircular(); } }}

// --------------------------------------------------- Fonte: FilaCircular.cs

119

using System;

namespace Circular{ public class FilaCircular { private int primeiro, ultimo, tamanho; private int [] elem;

public FilaCircular(int numElementos) { primeiro = 0; ultimo = -1; tamanho = 0; elem = new int[numElementos]; }

// ------------------------------------ insereFilaCircular

public void insereFilaCircular(int dado) { int n = elem.Length;

if (tamanho == n) { Console.WriteLine("ERRO: Fila Cheia"); } else { tamanho++; ultimo = (ultimo + 1) % n; elem[ultimo] = dado; } }

// ----------------------------------- excluiFilaCircular

public int excluiFilaCircular() { int n = elem.Length;

if (tamanho == 0) { Console.WriteLine("ERRO: Fila Vazia"); return(-1); } else { tamanho--; int temp = primeiro; primeiro = (primeiro + 1) % n; return(elem[temp]); } }

// -------------------------------- exibeFilaCircular

public void exibeFilaCircular() { int n = elem.Length;

if (tamanho == 0) { Console.WriteLine("Fila Circular: Fila Vazia"); } else { int temp = primeiro; Console.Write("Fila Circular: "); for (int i = 1;i <= tamanho;i++) { Console.Write(elem[temp] + " "); temp = (temp + 1) % n; } Console.WriteLine(); } } }}


[I]ncluir, [E]xcluir ou [F]im? iValor: 10[I]ncluir, [E]xcluir ou [F]im? i

120

Valor: 20[I]ncluir, [E]xcluir ou [F]im? iValor: 30[I]ncluir, [E]xcluir ou [F]im? iValor: 40ERRO: Fila Cheia[I]ncluir, [E]xcluir ou [F]im? eElemento Retirado da Fila: 10[I]ncluir, [E]xcluir ou [F]im? eElemento Retirado da Fila: 20[I]ncluir, [E]xcluir ou [F]im? iValor: 50[I]ncluir, [E]xcluir ou [F]im? iValor: 60[I]ncluir, [E]xcluir ou [F]im? iValor: 70ERRO: Fila Cheia[I]ncluir, [E]xcluir ou [F]im?

17. Tratamento de erros em C#

Na execução de um programa em C#, podem ocorrer erros não previstos que podem interromper a execução normal do programa. Tais erros podem ser:

Conversão numérica inválida; Limite de um vetor (acessor a índice inválido); Problemas com arquivos: abertura, criação ou caminho; Overflow; Erro de entrada e saída (input/output); Divizão por zero; Validação de dados.

Em C#, o programa tem condições de assumir o controle da execução em caso que ocorra uma situação de erro não prevista.

Isso é feito através do mecanismo de tratamento de exceções que ao detectar uma situação de erro, o programa em C# gera uma exceção. Se o programa que estiver sendo executado possuir um tratamento de exceções, ele assume o controle da execução. Mas se a exceção não tiver um tratamento associado, o programa é interrompido o programa em C# gera uma mensagem de erro.

Uma exceção é um evento que indica uma condição anormal que interrompe a execução normal de um programa.

O tratamento de erros no C# cria objetos da classe erro, o tratamento destes erros é feita pela manipulação destes objetos.

O tratamento de erros em C# basea-se em:

try {} catch {} finally {}.

A execução de um bloco de código, protegido por um tratamento de erros, é feito colocando o bloco no try, e para cada erro que se deseja tratar, deve-se colocar uma cláusula catch (tipo_de_erro variável_erro) {} e/ou uma cláusula finally (opcional) que é executada após a execução do bloco try se não houver erro.

Sintaxe:

try { // código fonte normal return;

121

} catch (Exception error) { // código que trata um tipo de erro ou mostra o erro

} catch (Exception error) { // código que trata outro tipo de erro ou exibe o erro

} finally { // opcional // código executado, mesmo tendo excessão }

17.1 Tratamento de exceções em C#

Exceções são instâncias de classes geradas quando houver erro. Estas exceções podem ser captadas e tratadas para que não ocorra erros em tempo de execução.

Os métodos utilizados por classes de exceções são:

getMessage(): Retorna uma string com o erro.

printStackTrace(): Imprime na tela um histórico do erro e as linhas aonde os erros ocorreram.

toString(): Converte a exceção numa String.

getCause(): Retorna a causa da exceção ou “null” se a causa for desconhecida ou não existir.

17.2 Tratamento de erros na entrada de número inteiro em C#

O programa exemplo abaixo verifica e trata a exceção: formato inválido do número (FormatException).

// ------------------------------------------------------- Fonte: inteiro.cs

using System;

namespace Inteiro{ class MainClass { public static void Main (string[] args) { int inteiro = -999;

try { Console.Write ("Inteiro: "); // código protegido contra erro String s = Console.ReadLine (); inteiro = int.Parse (s); return; } catch (FormatException error) { // error.printStackTrace(); // mostra as linhas do erro Console.WriteLine ("ERRO: " + error); // exibe o erro } finally { // OPCIONAL Console.WriteLine ("INTEIRO: " + inteiro); // executa depois do catch } } }}

Resultado do Programa (sem erro): [usuário digitou “120”]

Inteiro: 120INTEIRO: 120

122

Resultado do Programa (sem erro): [usuário digitou “abc”]

Inteiro: abcERRO: System.FormatException: Input string was not in the correct format at System.Int32.Parse (System.String s) [0x00000] in <filename unknown>:0 at Inteiro.MainClass.Main (System.String[] args) [0x00019] in /Users/pluzzardi/Projects/Inteiro/Inteiro/Program.cs:14 INTEIRO: -999

17.3 Tratamento de erros: Divisão por zero em C#

O programa exemplo abaixo verifica e trata os seguintes erros: (a) divisão por zero; (b) usuário apenas digitou <enter> sem nenhum número e (c) digitou letras (NumberFormatException e ArithmeticException).

// ------------------------------------------------------ Fonte: Divisao.cs

using System;

namespace DivideZero{ class MainClass { public static void Main (string[] args) { float x, y, div = -999;

try { Console.Write ("Dividendo: "); String s = Console.ReadLine (); x = float.Parse (s); Console.Write ("Divisor: "); s = Console.ReadLine (); y = float.Parse (s); div = x / y; Console.WriteLine ("Divisão: " + div); } catch (FormatException error) { Console.WriteLine ("Status: " + error); Console.WriteLine ("Divisão: " + div); } catch (ArithmeticException error) { // não funcionou Console.WriteLine ("Status: " + error); Console.WriteLine ("Divisão: " + div); } } }}

Resultado do Programa (sem erro): [usuário digitou “3” + “2”]

Dividendo: 3Divisor: 2Divisao: 1.5

Resultado do Programa (sem erro): [usuário digitou “3” + “0”]

Dividendo: 3Divisor: 0Divisao: +Infinity

Resultado do Programa (com erro): [usuário digitou “abc”]

Dividendo: abcStatus: System.FormatException: Unknown char: a at System.Double.Parse (System.String s, NumberStyles style, IFormatProvider provider) [0x00000] in <filename unknown>:0 at System.Single.Parse (System.String s) [0x00000] in <filename unknown>:0 at DivideZero.MainClass.Main (System.String[] args) [0x00013] in /Users/pluzzardi/Projects/DivideZero/DivideZero/Program.cs:14Divisão: -999

18. Herança em C#

123

18.1 Herança simples em C#

A herança simples permite que uma classe incorpore os atributos e métodos de outra classe, ou seja, permite a construção de hierarquias de classes.

O primeiro passo envolve a definição de uma classe base (superclasse) que define as características comuns a todos os objetos derivados desta classe. As classes oriundas da classe base são chamadas classes derivadas ou extensão da classe (subclasse)

Uma classe derivada herda todas as características da classe base e pode ter novas características adicionadas a ela. Uma classe derivada segue a seguinte diretriz em relação a classe base:

classe_derivada é um(a) classe_base

Exemplo: um cardial é um pássaro // classe base: pássaro// classe derivada: cardial

Especificadores de acesso:

public (público)

Quem tem acesso à classe tem acesso também a qualquer membro público.

É raro ter atributos públicos, mas é comum ter métodos públicos.

Qualquer método tem acesso.

private (privado)

Um membro privado não é acessível fora da classe, somente pelos membros da classe.

A intenção é permitir que apenas quem escreve a classe possa usar esse membro.

protected (protegido)

O membro protegido é acessível à classe e a suas sub-classes (classes derivadas).

A intenção é dar acesso aos programadores que estenderão sua classe.

18.2 Controle de acesso na definição de uma classe derivada em C#

Quando uma classe derivada é definida, ou seja, na definição de herança simples, seus membros (atributos e métodos) são declarados internamente e o acesso a estes pode ser público (public), privativo (private) ou protegido (protected). O acesso a membros protegidos é igual ao acesso a membros privativos, exceto para o acesso das classes derivadas da classe.

A forma geral de especificar herança simples é:

Especificador_de_acess class nome_classe_derivada extends nomeclasse_base {// atributos

124

// métodos}

Quando uma classe herda as características de outra classe, todos os membros da classe base tornam-se membros da classe derivada. O tipo de acesso da classe base dentro da classe derivada é determinado pelo especificador de acesso. Qualquer que seja o especificador de acesso, membros privativos da classe base continuam sendo propriedade privada da classe base, e não podem ser acessados por classes derivadas.

Quando o especificador de acesso é public, todos os membros públicos da classe base tornam-se membros públicos da classe derivada, e os membros protegidos da classe base tornam-se membros protegidos da classe derivada. Esta é a diferença que existe entre membros privativos e membros protegidos.

Quando o especificador de acesso é private, todos os membros públicos e protegidos da classe base tornam-se membros privativos da classe derivada, ou seja, a classe derivada não pode transferir seus privilégios de acesso a outras classes.

Quando o especificador de acesso é protected, todos os membros públicos e protegidos da classe base tornam-se membros protegidos da classe derivada.

Programa exemplo: O objetivo do programa a seguir é demonstrar a utilização de herança simples (atributos da classe base são privados).

// ------------------------------------------------------- Fonte: Heranca.cs

using System;

namespace Heranca{ class MainClass { public static void Main (string[] args) { Derivada objeto = new Derivada(3); int resp;

objeto.Seta(1, 2); resp = objeto.Soma(); Console.WriteLine("Somador (x + y + z): " + objeto.Somador(resp)); } }}

// -------------------------------------------------------- Fonte: base.cs

using System;

namespace Heranca{ public class Base { private int x, y; // atributos privados

public Base () { } public void Seta(int a, int b) { x = a; y = b; Console.WriteLine("x = " + x); Console.WriteLine("y = " + y); }

public int Soma()

125

{ Console.WriteLine("Soma (x + y): " + (x + y)); return(x + y); } }}

// ---------------------------------------------------------- Fonte: Derivada.cs

using System;

namespace Heranca{ public class Derivada : Base { private int z;

public Derivada (int x) { z = x; Console.WriteLine ("z = " + z); }

public int Somador (int soma) { // não é possível acessar x e y pois são privados da classe base return(soma + z); } }}


z = 3x = 1y = 2Soma (x + y): 3Somador (x + y + z): 6

Responda: Porque o atributo z é mostrado primeiro?

18.3 Tipos de acessos (especificadores de acesso) em C#

public (público): Todos os atributos da classe base são públicos na classe derivada.

private (privado): Os atributos só podem ser acessados pelos métodos que fazem parte da classe.

protected (protegido): Os atributos podem ser acessados pelos métodos de classes derivadas.

Programa exemplo: O objetivo do programa é demonstrar a utilização de herança simples (atributos da classe base são protegidos).

// ---------------------------------------------------------- Fonte: Heranca2.cs

using System;

namespace Heranca1{ class MainClass { public static void Main (string[] args) { Derivada objeto = new Derivada(3); int resp;

objeto.Seta(1, 2); resp = objeto.Soma(); Console.WriteLine("Somador (x + y + z): " + objeto.Somador(resp)); }

126

}}

// ----------------------------------------------------------- Fonte: base.cs

using System;

namespace Heranca1{ public class Base { protected int x, y; // atributos protegidos

public Base() { }

public void Seta(int a, int b) { x = a; y = b; Console.WriteLine("x = " + x); Console.WriteLine("y = " + y); }

public int Soma() { Console.WriteLine("Soma (x + y): " + (x + y)); return(x + y); } }}

// ------------------------------------------------------------ Fonte: Derivada.cs

using System;

namespace Heranca1{ public class Derivada : Base { private int z;


public int Somador (int soma) { return(x + y + z); // é possível acessar x e y pois são protegidos na classe base } }}



18.4 Lista de exercícios sobre Herança em C#

18.4.1 Herança (primeiro) em C#

Dado os seguintes códigos em C#:

// ------------------------------------------------------------------ TestaHeranca.cs

using System;

namespace TestaHeranca

127

{ class MainClass { public static void Main (string[] args) { Cliente cliente = new Cliente("Paulo Roberto", "123.456-78", 1234.56);

cliente.imprimePessoa(); cliente.imprimeCliente(); } }}

// ----------------------------------------------------------------------- Pessoa.cs

using System;

namespace TestaHeranca{ public class Pessoa { protected String nome; protected String cpf;

public Pessoa() { this.nome = "xxxx"; this.cpf = "xxx.xxx.xxx-xx"; }

public Pessoa(String nome, String cpf) { this.nome = nome; this.cpf = cpf; }

public void imprimePessoa() { Console.WriteLine("Nome: " + nome); Console.WriteLine("CPF: " + cpf); } }}

// ----------------------------------------------------------------------- Cliente.cs

using System;

namespace TestaHeranca{ public class Cliente : Pessoa { private double conta;

public Cliente (String nome, String cpf, double conta) { this.conta = conta; }

public void imprimeCliente () { Console.WriteLine ("Conta: " + conta); } }}

Resultado correto do programa:

Nome: Paulo RobertoCPF: 123.456-78Conta: 1234.56

Resultado do código do programa acima:

Nome: xxxxCPF: xxx.xxx.xxx-xxConta: 1234.56

128

Que modificações devem ser feitas no código fonte para que o resultado do programa seja o esperado?

18.4.2 Herança (segundo) em C#

Dado a classe base Pessoa e o programa principal TestaHomem, construa as classes derivadas Homem e Mulher que contenha os atributos e métodos abaixo descritos:

// -------------------------------------------------------------- Pessoa.cs

using System;

namespace TestaSexo{ public class Pessoa { protected double altura; protected char sexo;

public Pessoa() { this.altura = 0.0; this.sexo = 'g'; }

public Pessoa(double altura, char sexo) { this.altura = altura; this.sexo = sexo; }

public void imprimePessoa() { Console.WriteLine("Altura: " + altura); Console.WriteLine("Sexo: " + sexo); } }}

Pessoaalturasexo

imprimePessoa

HomempesoIdeal

calculaPesoIdealHomemimprimePesoIdealHomem

MulherpesoIdeal

calculaPesoIdealMulherimprimePesoIdealMulher

// ------------------------------------------------------------- TestaSexo.cs

using System;

namespace TestaSexo{ class MainClass { public static void Main (string[] args) { Homem homem = new Homem(1.64, 'm'); Mulher mulher = new Mulher(1.59, 'f');

homem.calculaPesoIdealHomem();

129

homem.imprimePessoa(); homem.imprimePesoIdealHomem(); mulher.calculaPesoIdealMulher(); mulher.imprimePessoa(); mulher.imprimePesoIdealMulher(); } }}


Altura: 1,64Sexo: mPeso Ideal (Homem): : 61,228Altura: 1,59Sexo: fPeso Ideal (Mulher): : 54,039

18.4.3 Herança (terceiro) em C#

Dados os seguintes códigos em C#:

// ----------------------------------------------------------- TestaObjetos.cs

using System;

namespace TestaObjetos{ class MainClass { public static void Main (string[] args) { Linha linha = new Linha(1, 2, 3, 4); Retangulo retangulo = new Retangulo(1, 2, 3, 4);

Console.WriteLine("Linha: "); linha.imprimeLinha(); Console.WriteLine("Retângulo: "); retangulo.imprimeRetangulo(); } }}

// ------------------------------------------------------------- Objeto.cs

using System;

namespace TestaObjetos{ public class Objeto { protected int x; protected int y;

public Objeto() { x = 0; y = 0; }

public Objeto(int x, int y) { this.x = x; this.y = y; }

public void imprimeObjeto() { Console.WriteLine("x = " + x + " - y = " + y); } }}

// ----------------------------------------------------------------- Linha.cs

130

using System;

namespace TestaObjetos{ public class Linha { private Objeto p1; private Objeto p2;

public Linha (int xi, int yi, int xf, int yf) { p1 = new Objeto(xi, yi); p2 = new Objeto(xf, yf); }

public void imprimeLinha() { p1.imprimeObjeto(); p2.imprimeObjeto(); } }}

Implemente a classe derivada Retangulo para que o programa funcione conforme o resultado do programa abaixo:

R esultado do Programa:

Linha: x = 1 - y = 2x = 3 - y = 4Retângulo: x = 1 - y = 2x = 3 - y = 2x = 3 - y = 4x = 1 - y = 4

19. Coletor de Lixo (Garbage Collector) em C#

O C# possui um coletor de lixo automático, mas pode-se chamá-lo implicitamente através do método: GC.Collect. Veja no exemplo abaixo:

// ------------------------------------------------ Fonte: HerancaColetor.cs

using System;

namespace HerancaColetor{ class MainClass

131

{ public static void Main (string[] args) { Derivada objeto = new Derivada(3); int resp;

objeto.Seta(1, 2); resp = objeto.Soma(); Console.WriteLine("Somador (x + y + z): " + objeto.Somador(resp)); objeto = null; // marca para coletor de lixo GC.Collect(); // chamada do coletor de lixo Console.WriteLine("Somador (x + y + z): " + objeto.Somador(resp)); } }}

// ------------------------------------------------ Fonte: base.cs

using System;

namespace HerancaColetor{ public class Base { protected int x, y; // atributos protegidos

public Base () { }

public void Seta(int a, int b) { x = a; y = b; Console.WriteLine("x = " + x); Console.WriteLine("y = " + y); }

public int Soma() { Console.WriteLine("Soma (x + y): " + (x + y)); return(x + y); }

}}

// --------------------------------------------------- Fonte: Derivada.cs

using System;

namespace HerancaColetor{ public class Derivada : Base { private int z;

public Derivada(int x) { z = x; Console.WriteLine("z = " + z); }

public int Somador(int soma) { return(x + y + z); // é possível acessar x e y pois são privados a classe base } }}



Unhandled Exception:

132

System.NullReferenceException: Object reference not set to an instance of an object at HerancaColetor.MainClass.Main (System.String[] args) [0x00040] in /Users/pluzzardi/Projects/HerancaColetor/HerancaColetor/Program.cs:17 [ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object at HerancaColetor.MainClass.Main (System.String[] args) [0x00040] in /Users/pluzzardi/Projects/HerancaColetor/HerancaColetor/Program.cs:17

Observação: O erro acontece na linha tracejada porque o objeto foi desalocado pela chamada explícita do coletor de lixo.

20. Construtor e finalizador em C#

Em C#, uma classe além de poder ter um construtor, pode ter um finalizador - destrutor (~construtor) que é executado automaticamente no término do programa.

Sintaxe: ~nome_construtor {}

A seguir o programa exemplo mostra o uso do destrutor:

// -------------------------------------------------------- Fonte: base.cs

using System;

namespace Finalizador{ public class Base { // atributos protegidos protected int x, y;

public Base () { }

public void Seta (int a, int b) { x = a; y = b; Console.WriteLine ("x = " + x); Console.WriteLine ("y = " + y); }

public int Soma () { Console.WriteLine ("Soma (x + y): " + (x + y)); return(x + y); } }}

// ---------------------------------------------------- Fonte: Derivada.cs

using System;

namespace Finalizador{ public class Derivada : Base { private int z;


public int Somador (int soma) {

133

return(x + y + z); // é possível acessar x e y pois são privados a classe base }

~ Derivada () // destrutor { Console.WriteLine ("Finalizador: Final do programa"); } }}

// ------------------------------------------------------ Fonte: Finalizador.cs

using System;

namespace Finalizador{ class MainClass { public static void Main (string[] args) { Derivada objeto = new Derivada (3); int resp;

objeto.Seta (1, 2); resp = objeto.Soma (); Console.WriteLine ("Somador (x + y + z): " + objeto.Somador (resp)); objeto = null; // marca para coletor de lixo GC.Collect (); // chamada do coletor de lixo } }}


z = 3x = 1y = 2Soma (x + y): 3Somador (x + y + z): 6Finalizador: Final do programa

21. Data e Hora em C#

Em C# é possível verificar a data e hora da máquina. Abaixo é visto várias formas de imprimir na tela a data e horário.

// ------------------------------------------ Fonte: Data.cs

using System;

namespace Data{ class MainClass { public static void Main (string[] args) { DateTime data = DateTime.Now; // ---------------------------------------------------------------- data Console.WriteLine (data.ToShortDateString ()); Console.WriteLine(data.ToLongDateString()); // ---------------------------------------------------------------- tempo Console.WriteLine (data.ToShortTimeString ()); Console.WriteLine(data.ToLongTimeString()); } }}


27/11/2013quarta-feira, 27 de novembro de 201322:3222:32:27

134

22. Eliminar problemas na conversão na entrada de dados

Como em qualquer outra linguagem de programação, um grave problema que ocorre em C# na entrada de dados, via teclado, é quando o usuário digita letras (caracteres) numa entrada de números (inteiros ou reais), pois mesmo que os dados lidos e armazenados no buffer de entrada sejam armazenados em uma String, no momento da conversão para inteiro ou real, os métodos utilizados não permitem a conversão e retornam erro em tempo de execução. Já foi visto anteriormente, que este problema pode ser resolvido com tratamento de excessão, mas ainda pode-se resolver este problema com a implementação de um método estático que retira todos os caracteres que não sejam números.

// ------------------------------------------ Fonte: EntradaDados.cs

using System;

namespace EntradaDados{ class MainClass { static String retiraLetras (String s) { string t; if (s [0] == '-') { t = "-"; } else { t = ""; } int n = s.Length; for (int i = 0; i < n; i++) { if (s [i] >= '0' && s [i] <= '9') { t = t + s [i]; } } return(t); }

public static void Main (string[] args) { // entrada do usuário lida e armazenada em uma String Console.Write ("Digite um número: "); String s = Console.ReadLine (); // método replace elimina todos os caracteres que não são números ou “-“ s = retiraLetras (s); Console.WriteLine ("s = " + s); if ("".CompareTo (s) == 0) { Console.WriteLine ("ERRO: Problema na Conversão para Inteiro"); } else { // conversão pode ser feita sem problemas, pois a String s não possui letras int numero = int.Parse (s); Console.WriteLine ("Número: " + numero); } } }}

135