Docsity
Docsity

Prepare-se para as provas
Prepare-se para as provas

Estude fácil! Tem muito documento disponível na Docsity


Ganhe pontos para baixar
Ganhe pontos para baixar

Ganhe pontos ajudando outros esrudantes ou compre um plano Premium


Guias e Dicas
Guias e Dicas

Técnicas de Programação - Apostilas - Engenharia Elétrica Part1, Notas de estudo de Eletrotécnica

Apostilas de Engenharia Elétrica sobre o estudo das Técnicas de Programação, declaração de variáveis, tipos de variáveis, identificadores de variáveis, constantes, estrutura do algoritmo em portugol.

Tipologia: Notas de estudo

2013

Compartilhado em 10/06/2013

Salome_di_Bahia
Salome_di_Bahia 🇧🇷

4.5

(389)

318 documentos

1 / 95

Documentos relacionados


Pré-visualização parcial do texto

Baixe Técnicas de Programação - Apostilas - Engenharia Elétrica Part1 e outras Notas de estudo em PDF para Eletrotécnica, somente na Docsity! PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA DEPARTAMENTO DE ENGENHARIA MECATRÔNICA TÉCNICAS DE PROGRAMAÇÃO TPI e TPII Versão: julho/2003 1 PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA DEPARTAMENTO DE ENGENHARIA MECATRÔNICA APOSTILA DE TÉCNICAS DE PROGRAMAÇÃO ELABORAÇÃO: PROF. MARCELO RUDEK REVISÃO: PROF. MAURÍCIO C. MELLO PROFa. MARIA A. ROVEREDO COLABORAÇÃO: GELSON LUIZ CARNEIRO ADRIANO ZELAZOWSKI PEREIRA Versão: julho/2003 III 2.12.1. SINTAXE DO COMANDO .................................................................................................59 2.12.2. EXEMPLO.......................................................................................................................59 2.13 COMANDO SWITCH/CASE..................................................................................................60 2.13.1. SINTAXE DO COMANDO..................................................................................................60 2.13.2. EXEMPLO.......................................................................................................................60 2.14. TIMER ..............................................................................................................................61 2.14.1. O COMPONENTE TIMER NO C++ BUILDER .....................................................................61 2.14.2. AS PROPRIEDADES DO TIMER .........................................................................................62 2.14.3. EXEMPLO.......................................................................................................................62 2.14.4. EXERCÍCIO .....................................................................................................................62 3. ESTRUTUAS HOMOGÊNEAS DE DADOS ..................................................................63 3.1. MATRIZES UNIDIMENSIONAIS (VETORES) .........................................................63 3.1.1. EXEMPLOS .......................................................................................................................63 3.1.2. INDEXAÇÃO .....................................................................................................................63 3.1.3. EXEMPLO.........................................................................................................................64 3.1.4. EXERCÍCIO .......................................................................................................................65 3.2. ORDENAÇÃO DE VETORES.................................................................................................65 3.2.1. ALGORITMO DE ORDENAÇÃO (BOLHA).............................................................................65 3.2.2. EXERCÍCIO .......................................................................................................................66 3.3. STRINGS..........................................................................................................................67 3.3.1.EXEMPLO 1.......................................................................................................................67 3.3.2.EXEMPLO 2.......................................................................................................................68 3.3.3. COPIANDO STRINGS .........................................................................................................68 3.3.4. COMPARAÇÃO DE STRINGS ..............................................................................................69 3.3.5. TAMANHO DE STRINGS.....................................................................................................69 3.3.6. COMPARAÇÃO DE ELEMENTOS DA STRING ......................................................................70 3.3.7. CONVERSÃO DE TIPOS......................................................................................................70 3.3.7.1. convertendo valores numéricos para caracter..............................................................71 3.3.7.2. convertendo string para valores numéricos .................................................................71 3.3.8 EXERCÍCIOS ......................................................................................................................72 3.4. MATRIZES ......................................................................................................................73 3.4.1. MATRIZES BIDIMENSIONAIS ............................................................................................73 3.4.2. MATRIZES MULTIDIMENSIONAIS ......................................................................................74 3.4.3. MATRIZES DE STRINGS.....................................................................................................74 3.4.4. EXERCÍCIOS .....................................................................................................................76 4. PONTEIROS EM C ...........................................................................................................78 4.1. DEFINIÇÃO ....................................................................................................................78 4.2. DECLARAÇÃO DE UM PONTEIRO .......................................................................................79 4.3. EXERCÍCIOS.......................................................................................................................80 4.4. PONTEIROS PARA MATRIZ.................................................................................................82 4.5. VETORES DE PONTEIROS ..................................................................................................85 4.5.1. EXEMPLO 1 ......................................................................................................................85 4.5.2. EXERCÍCIO .......................................................................................................................87 IV 4.5.3. EXEMPLO 2 ......................................................................................................................87 4.5.4. EXERCÍCIOS .....................................................................................................................88 5. ALOCAÇÃO DINÂMICA DE MEMÓRIA ....................................................................89 5.1. INTRODUÇÃO .....................................................................................................................89 5.2. COMANDO DE ALOCAÇÃO .................................................................................................89 5.2.1. EXEMPLO DE ALOCAÇÃO USANDO O COMANDO MALLOC().............................................89 5.2.2. MELHORANDO O USO DE PONTEIROS...............................................................................92 5.3. EXERCÍCIOS.......................................................................................................................93 5.4. PORTABILIDADE ................................................................................................................93 5.4.1. EXEMPLO DO USO DE SIZEOF............................................................................................94 5.5. EXERCÍCIOS ..................................................................................................................94 6. ARQUIVOS EM C ............................................................................................................99 6.1. PONTEIRO DE ARQUIVO.....................................................................................................99 6.2. ABRINDO ARQUIVOS ..........................................................................................................99 6.2.1. ARQUIVOS TIPO TEXTO .................................................................................................100 6.2.2. ARQUIVOS BINÁRIOS .....................................................................................................101 6.3. ABRINDO UM ARQUIVO PARA ESCRITA ...........................................................................101 6.3.1. OBSERVAÇÕES...............................................................................................................102 6.4. ABRINDO UM ARQUIVO PARA LEITURA...........................................................................103 6.5. FECHANDO UM ARQUIVO.................................................................................................103 6.6. COMANDOS DE ESCRITA E LEITURA................................................................................104 6.6.1. FPUTC()..........................................................................................................................104 6.6.2. FGETC()..........................................................................................................................107 6.6.3. EXERCÍCIO COM FPUTC() E FGETC() ...............................................................................109 6.7. GRAVAÇÃO DE STRINGS COM FPUTS() ............................................................................110 6.8. LEITURA DE STRINGS COM FGETS() ................................................................................111 6.9. EXERCÍCIOS COM FPUTS() E FGETS() ..............................................................................112 6.10. LEITURA COM FREAD() .................................................................................................112 6.11. GRAVAÇÃO COM FWRITE() ...........................................................................................113 6.12. GRAVAÇÃO COM FPRINTF() ..........................................................................................113 6.13. LEITURA COM FSCANF() ................................................................................................114 6.14. EXERCÍCIOS...................................................................................................................115 7. REGISTROS.....................................................................................................................116 7.1. DEFINIÇÃO.......................................................................................................................116 7.2. INICIALIZAÇÃO................................................................................................................116 7.2.1. EXEMPLO 1 ....................................................................................................................117 7.2.2. EXEMPLO 2 ....................................................................................................................117 7.3. ACESSO AOS ELEMENTOS DA ESTRUTURA ......................................................................117 7.4. EXERCÍCIO.......................................................................................................................118 7.5. MATRIZES DE ESTRUTURAS ............................................................................................118 V 7.5.1.EXEMPLO........................................................................................................................118 7.5.2. EXERCÍCIO .....................................................................................................................119 7.6. USO DE TYPEDEF..........................................................................................................121 7.6.1. EXEMPLO.......................................................................................................................121 7.6.2. EXEMPLO 2 ....................................................................................................................121 7.7. GRAVAÇÃO E LEITURA DE REGISTROS ..........................................................................122 7.7.1 EXEMPLO........................................................................................................................122 7.7.2.EXERCÍCIO......................................................................................................................122 7.8. PONTEIROS PARA REGISTROS .........................................................................................123 7.8.1.EXEMPLO........................................................................................................................123 8. GRÁFICOS EM C............................................................................................................126 8.1. INTRODUÇÃO..............................................................................................................126 8.2. DESENHANDO LINHAS.....................................................................................................126 8.3. USANDO O PAINTBOX......................................................................................................128 8.4. COMPONENTE PANEL......................................................................................................129 8.5. DESENHANDO RETÂNGULOS...........................................................................................130 8.6. DESENHANDO ELIPSES ....................................................................................................131 8.7. DESENHANDO PONTOS (PIXELS).....................................................................................132 8.8. EXEMPLO.........................................................................................................................132 8.9 EXERCÍCIOS......................................................................................................................136 9. LISTAS LINEARES ........................................................................................................137 9.1. FILA .................................................................................................................................137 9.1.1. DEFINIÇÃO.....................................................................................................................137 9.1.2. OBJETIVO.......................................................................................................................137 9.1.3. EXEMPLO.......................................................................................................................137 9.2. FILA CIRCULAR...............................................................................................................140 9.3. PILHA...............................................................................................................................142 9.3.1. DEFINIÇÃO.....................................................................................................................142 9.3.2. EXEMPLO.......................................................................................................................142 9.4. EXERCÍCIOS.....................................................................................................................143 9.5. LISTAS ENCADEADAS ......................................................................................................144 9.6. EXEMPLO.........................................................................................................................145 9.7. EXERCÍCIO.......................................................................................................................146 9.8. EXEMPLO.........................................................................................................................146 9.9. OPERAÇÕES COM LISTA ENCADEADA ............................................................................147 9.10. EXEMPLO.......................................................................................................................148 9.11. LISTAS DUPLAMENTE ENCADEADAS ............................................................................150 9.12. EXEMPLO.......................................................................................................................150 9.13. EXEMPLO.......................................................................................................................151 10. RECURSIVIDADE ........................................................................................................154 1 TP I TP I - Capítulo 1 2 i. O PROGRAMA DE APRENDIZAGEM (P.A.) Este programa de aprendizagem explora o estudo de algoritmos e programação em linguagem C. Para aprovação neste semestre o aluno deverá estar apto a raciocinar e desenvolver a sua capacidade de abstração, para a criação de algoritmos e programas elementares. As técnicas de programação serão vistas através da utilização de uma pseudolinguagem em português, denominada "Portugol". Assim, o aluno poderá escrever algoritmos e aplicar as técnicas de desenvolvimento para serem usadas com qualquer linguagem de programação. Para este P.A., será utilizada a linguagem C padrão, em ambiente Windows. Na seção seguinte será apresentado o conteúdo programático de Técnicas de Programação I (TP I). 1. Identificação 1.1. Campus: Curitiba 1.2. Centro: CCET 1.3. Curso: Engenharia Mecatrônica. 1.4. Habilitação: Engenharia de Controle e Automação 1.5 Programa de aprendizagem (PA) : Técnicas de Programação I 1.6 Ano Letivo: 2001 Período:1º e 2° (D & N) Semestre: 1º e 2º (D & N) 1.7 Carga Horária Total: 54 Nº de créditos: 2 1.8 Carga Horária Semanal: 3 aulas Aulas Teóricas: 0 Aulas Práticas: 3 1.9 Disciplina ou grupo de disciplinas que originou o PA: Aspectos Formais da Computação e Algoritmos 1.10 Professor Responsável: Marcelo Rudek 2. Aptidões e competências / habilidades a serem desenvolvidas pelos alunos - Conhecer estruturas de dados, e suas representações através de algoritmos, para aplicar em ferramentas de programação. - Conhecer técnicas atuais de programação para aplicação em desenvolvimento de sistemas usados em controle e automação de processos; - Conhecer a linguagem de programação “C” para o desenvolvimento de programas elementares. - Desenvolver habilidades de trabalho em equipe. TP I - Capítulo 1 3 3. Ementa Introdução sobre algoritmos. Metodologia de desenvolvimento de programas. Modularidade e abstração. Introdução a linguagem de programação (C). Tipos de dados básicos e estruturados. 4. Temas de estudo - Conceitos de algoritmos e estruturas de dados: Conceituação sobre a construção de programas. Introdução sobre fundamentos da computação e descrição do funcionamento dos computadores. - Portugol: Introdução ao portugol para o desenvolvimento de algoritmos, declaração de variáveis, desvio condicional, laços de repetição. - Programas em C: Apresentação dos comandos básicos da linguagem C, variáveis, desvio condicional, laços de repetição, estruturas homogêneas de dados – vetores e matrizes. 5. Metodologia O objetivo é a aprendizagem através da prática. As aulas são em laboratório, onde pode ser apresentada a teoria, e imediatamente o tema pode ser comprovado pelos alunos. Isto torna a aula mais dinâmica e participativa. Esta metodologia permite atingir as aptidões técnicas e de trabalho em grupo, propostas neste programa de aprendizagem. a. Procedimentos do Professor As aulas serão práticas em laboratório. Todas as aulas estarão previamente disponíveis na página do curso na internet, de forma que o aluno possa consultar o tema da aula, dias antes da apresentação em sala, ou rever a aula posteriormente. b. Atividades dos alunos - Resolução de exercícios,trabalhos individuais e em equipes. - Pesquisa bibliográfica com utilização da INTERNET. - Apresentação de trabalhos. c. Recursos e Materiais Serão utilizados livros da área, compilador da linguagem C, internet e microcomputadores da Universidade. 6. Procedimetnos de Avaliação Avaliações somativas incluindo trabalhos, participação dos alunos nos questionamentos e exercícios de aula, provas escritas e no computador, e trabalho final do semestre. TP I - Capítulo 1 6 1.2. ALGORITMOS EM PORTUGOL Como no item 1 ".... um algoritmo é de forma geral, uma descrição passo a passo de como um problema pode ser solucionado. A descrição deve ser finita, e os passos devem ser bem definidos sem ambiguidades" [Terada] . A razão da existência do algoritmo vem da dissonância entre um estado desejado e aquele observado na realidade. Algoritmo não é a solução de um problema, mas é o meio de obtê-la. A resolução de um problema envolve vários parâmetros que devem ser organizados através de alguma técnica formal. As técnicas de desenvolvimento estruturado de algoritmos, tem o objetivo de: • Facilitar o desenvolvimento de algoritmos; • Facilitar o seu entendimento pelos operadores; • Antecipar a correção; • Facilitar manutenção e modificações; • Permitir que o desenvolvimento seja feita por uma equipe de pessoas. Uma técnica formal afasta a possibilidade de uma ambiguidade. Ou seja, a partir de dadas condições iniciais a execução do algoritmo será realizada por um mesmo "caminho" (sequência de ações), que deve resultar num mesmo estado final. Uma destas técnicas é o portugol. 1.3. PORTUGOL Portugol é uma pseudolinguagem que permite ao programador pensar no problema em si e não no equipamento que irá executar o algoritmo. Devem ser considerados a sintaxe (em relação à forma) e a semântica (em relação ao conteúdo ou seu significado). Em portugol a sintaxe é definida pela linguagem e a semântica depende do significado que quer se dar ao algoritmo. No portugol e nas linguagens de programação, basicamente têm-se comandos e variáveis que operacionalizam a execução de um algoritmo. Estes comandos são TP I - Capítulo 1 7 executados sequencialmente, de forma que um comando só será executado após a finalização do comando anterior. A estrutura de um algoritmo em portugol pode ser dada como: Exemplo: início <declarações de variáveis> <comandos> fim 1.4. Variáveis 1.4.1. Declaração de Variáveis Uma variável é um local (área na memória do computador) que armazena um tipo específico de conteúdo. Uma variável contém um valor que se modifica durante a execução do programa. A variável possui um identificador (nome), que pode ser representado da seguinte forma: TP I - Capítulo 1 8 1.4.1.1. Tipos de Variáveis Variáveis são componentes das linguagens de programação, que identificam os valores que estão sendo manipulados pelos programas. Uma variável, como o próprio nome sugere, contém valores que variam de acordo com a execução do programa. Uma variável deve possuir um tipo específico. As variáveis em portugol, são divididas em 4 tipos principais, (embora na linguagem C existam modificações para estes tipos principais). No portugol, os tipos básicos de variáveis são: • Inteiro: Qualquer número inteiro (negativo, nulo ou positivo). Exemplo: -100, 0, 1, 2, 1250. • Real: Qualquer número real, nulo ou positivo. Exemplo: -10, -1.5, 11.2, 0,1, 2, 50. • Caracter: Caracteres alfanuméricos. Exemplo: casa, Win31, 123, alfa#2, etc... • Lógico: valor lógico verdadeiro ou falso Exemplo: x > y ? Exemplos: inteiro: valor; // a variável valor é do tipo inteiro real: media; // a variável media é do tipo real caracter: nome_aluno; // a variável nome_aluno é do tipo caracter lógico: maior; // a variável maior é do tipo booleano 1.4.1.2. Identificadores de Variáveis O identificador de uma variável, se refere ao nome de como ela vai ser conhecida no programa. È importante não esquecer que: a) Não é possível definir variáveis de diferentes tipos com o mesmo identificador (nome); O exemplo: real A; inteiro A; causaria erro na programação, mas pode ser TP I - Capítulo 1 11 1.5.2. Operadores Aritméticos Os símbolos das operações básicas são: • A multiplicação é dada através do operador * (asterisco); Exemplo: z <- x * y; • A soma é realizada através do operador + ; Exemplo: z <- x + y; • A subtração é dada através do operador -; Exemplo: z <- x - y; • A divisão para real será dada por / ; Exemplo: z <- x / y; • A divisão para inteiro será dada por div ; Exemplo: z <- x div y; • O resto de uma divisão é dada pelo comando mod . Exemplo: z <- x mod y; • O cálculo de xy é dado pelo símbolo ^ . Exemplo: z <- x^y; • A raiz de uma valor é extraída através do comando raiz() . Exemplo: z <- raiz(x); Exemplos a) Desenvolva um algoritmo em portugol para somar dois valores inteiros (10 + 5) inicio inteiro x,y,z; x <- 10; y <- 5; z <- x + y; fim Reservar 3 espaços de memória do tipo inteiro, chamados x, y e z. Atribuição de valores iniciais às variáveis. O resultado da soma de x + y será armazenado no espaço de memória z TP I - Capítulo 1 12 Obs: - O incoveniente deste algoritmo é que sempre fornecerá o mesmo resultado, o que não é interessante. De maneira mais correta, os valores de x e y podem ser fornecidos pelo usuário, permitindo ao algoritmo que efetue a soma de dois números quaisquer. - Neste exemplo podemos observar que o resultado da soma de x + y será armazenado em z. Como o usuário ficará sabendo da resposta ? É necessário usar comandos de escrita, para apresentar os resultados. 1.5.3. Entrada e Saída de Dados Na construção de algoritmos, é conveniente que o usuário possa informar dados externos, para serem operados pelo programa. Assim, um programa pode receber um dado informado por um operador através de um comando de leitura. Da mesma forma, pode ser necessário conhecer o resultado de determinada operação executada pelo computador, então será necessária uma forma de exibir os dados. Cada linguagem tem uma forma específica para entrada e saída de dados. Em algoritmos usaremos os comandos genéricos leia() e escreva(), para realizar a interface com o usuário. Exemplo: início real A, B, C; leia(A); leia(B); c <- A + B; escreva(C); fim Lê os valores fonecidos pelo usuário e armazena em A e B. Apresenta a resposta (tela, impressora, arquivo, etc) TP I - Capítulo 1 13 1.5.4. Regras para escrever algoritmos em portugol • Incluir comentários pelo menos nas linhas mais importantes do programa; • Usar nomes significativos para as variáveis e constantes, que possam identificar o conteúdo; • Grifar as palavras chaves do portugol; • Alinhar os comandos facilita a legibilidade do algoritmo e reduz a possibilidade de erros. 1.5.5. Exercícios 1 – Desenvolva um algoritmo em portugol para calcular xy. Os valores de x e y serão fornecidos pelo usuário do programa; 2 – Desenvolva um programa que calcule o volume de uma esfera de raio R, fornecido pelo usuário. [ V = 4/3 π R3 ] 3 – Desenvolva um programa que transforme um valor de temperatura fornecido pelo usuário, de Farenheit ( F ) para Graus Celcius ( ºC ). [C = 5/9 (F – 32)] 4 – Desenvolva um algoritmo para calcular a média entre 4 valores fornecidos pelo usuário. 5 – Desenvolva um algoritmo para encontrar as raízes de uma equação do tipo Ax2 + Bx + C. 1.6. Comandos de Controle Os comandos de controle permitem alterar a direção tomada por um programa (desvio), ou fazer com que partes específicas de um algoritmo seja executada mais de uma vez (loop). 1.6.1. Desvio Condicional Muitas vezes será necessário desviar a execução do programa segundo uma condição. (Exemplo: ir a universidade de carro ou de ônibus ?). Para se testar condições é necessário utilizar operadores lógicos e relacionais. 1.6.1.1. Operadores Lógicos TP I - Capítulo 1 16 Desvio Condicional Composto ... se A > B então A <- B; B <- 0; senão B <- A; A <- 1; fim se ... Exercícios 1 – Desenvolva um algoritmo que apresente como resposta se um valor inteiro fornecido pelo usuário é par ou ímpar; 2 – Dado o gráfico abaixo, testar se um valor T qualquer fornecido pelo usuário, pertence ao intervalo T0 ≤ T ≤ T1. Dados T0 = 5, T1 = 10, V0 = 1, V1 = 2; 3 – Dado o gráfico do exercício 2, desenvolva um algoritmo que apresente o valor de V para um dado valor de T, fornecido pelo usuário. 4 – Modifique os exercícios 3 e 4 do item 1.6.1.3. para utilizar um desvio condicional composto, se for o caso. V0 V1 T0 T1 T V TP I - Capítulo 1 17 1.6.2. Laços de Repetição (loop) Uma sequência de ações é repetida por um número específico de vezes, até que uma condição seja satisfeita. Enquanto a condição for verdadeira, as instruções serão executadas. O laço de repetição também pode ser chamado de loop. Exemplo 1: Durante uma semana, um mês, etc, vc pode realizar a mesma seqüência de ações, como no exemplo: 1 º Dia Acordar → levantar → tomar café → pegar o ônibus Ou → chegar ao destino → pegar o carro 2 º Dia Acordar → levantar → tomar café → pegar o ônibus Ou → chegar ao destino → pegar o carro . . . N – ésimo Dia Acordar → levantar → tomar café → pegar o ônibus Ou → chegar ao destino → pegar o carro Como as ações se repetem durante um período ou até que um evento ocorra (chegar ao fim de semana) , pode-se melhorar escrita da sequência do exemplo acima, como: TP I - Capítulo 1 18 Exemplo 2: Enquanto ( não chegar ao fim de semana) faça Acordar → levantar → tomar café → pegar o ônibus Ou → chegar ao destino → pegar o carro Exemplo 3: Enquanto ( dia < N) faça Acordar → levantar → tomar café → pegar o ônibus Ou → chegar ao destino → pegar o carro Então, pode-se observar que as construções dos exemplos 2 e 3, representam as N repetições do exemplo 1. Em termos práticos da programação, a forma dos exemplos 2 e 3, de escrever ações que se repetem, são corretas. A forma de escrever as ações do exemplo 1 que se repetem é incorreta, apesar de levar o mesmo resultado, pois imagine reescrever as mesmas ações para 365 dias, ou mais... 1.6.2.1. Comando: enquanto/faça Em portugol, escreve-se o comando enquanto / faça, da forma apresentada abaixo. Note que se forma um bloco de comandos, delimitado ente o início e o fim do loop. Veja o exemplo: enquanto (condição) faça fim enquanto ... lista de comandos; ... A “condição “ se refere a um critério de parada do loop, ou seja, até quando o loop vai ser executado. Um ou mais comandos que serão executados enquanto a condição for verdadeira. TP I - Capítulo 1 21 b) Loop para/faça com passo diferente de 1 (incremento): inicio inteiro I; para I de 1 até 5 passo 2 faça escreva (I); fim para fim c) Loop para/faça com passo decrescente: inicio inteiro I; para I de 5 até 1 passo -2 faça escreva (I); fim para fim Exercícios: 1 – Escreva um algoritmo para gerar uma PA de razão qualquer, com uma série de 10 termos. 2 – Modifique o exercício 5.1 para uma PA de N termos. 3 – Escreva um algoritmo para gerar a sequência de Fibonacci da forma abaixo, até o vigésimo termo: 1,1,2,3,5,8,13, ... 4 – Sejam dados P(X1,Y1) e Q(X2,Y2) dois pontos quaisquer no plano. Escreva um algoritmo que leia os pares de coordenada x e y e calcule a distância entre estes dois pontos. 5 – Escreva um algoritmo que gere uma tabela com a conversão de graus para Fahrenheit para Celsius e vice versa, com valores variando de 1 em 1 grau, de 0 a 100 graus Celsius. Teste de Mesa inicio 1ª iteração I = 1 2ª iteração I = 3 3ª iteração I = 5 5 < 5 ? sai do loop Obs: No loop do tipo para/faça o valor da variável de controle do loop é incrementada automaticamente de 2 em 2 a cada loop. Teste de Mesa inicio 1ª iteração I = 5 2ª iteração I = 3 3ª iteração I = 1 1 < 1 ? sai do loop Obs: No loop do tipo para/faça o valor da variável de controle do loop é decrementada automaticamente de 2 em 2 a cada loop. Capítulo 2 22 2. PROGRAMAÇÃO EM LINGUAGEM C 2.1. INTRODUÇÃO A PROGRAMAÇÃO EM LINGUAGEM C 2.1.1. Declaração de Variáveis As diferenças entre os tipos de variáveis do portugol para o C são: inteiro = int real = float, double caracter = char lógico = bool (normalmente não é necessário tipos booleanos para testes lógicos) Para alterar a precisão dos valores podem ser utilizados modificadores: C ANSI Modificadores Exemplos: char int float double signed unsigned long short int x ; (x é um inteiro com sinal - signed) unsigned int y; (x é um inteiro sem sinal - unsigned) long z; (z é um inteiro com o dobro do tamanho de um int) short int v; (v tem o mesmo tamanho de um int) Exemplos: a) signed int (ou simplesmente int): Tipo de variável que se refere a um número inteiro com sinal. Ou seja, se um variável int ocupa dois bytes na memória, então, o maior valor decimal que pode ser armazenado neste tipo de variável deve estar entre –32.767 a 32.767. O primeiro bit (mais significativo) representa o sinal (0 positivo e 1 negativo). Então o maior valor decimal que pode ser armazenado em 15 bits é 32.767. 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 bit de sinal 15 bits de informação Capítulo 2 23 b) unsigned int; Tipo de variável que se refere a um número inteiro sem sinal. Ou seja, se um variável int ocupa dois bytes na memória, então, o maior valor decimal que pode ser armazenado neste tipo de variável deve estar entre 0 a 65.535. O primeiro bit (mais significativo) não representa mais o sinal. Então o maior valor decimal que pode ser armazenado em 16 bits é 65.535. O tamanho em bytes de cada tipo de variável no C, é apresentado na tabela abaixo. Tipo Tamanho em Bits Faixa de valores char 8 -127 a 127 unsigned char 8 0 a 255 signed char 8 -127 a 127 int 16 -32767 a 32767 unsigned int 16 0 a 65.535 signed int 16 mesmo que int short int 16 mesmo que int unsigned short int 16 mesmo que unsigned int signed short int 16 mesmo que short int long int 32 -2.147.483.647 a 2.147.483.647 signed long int 32 Mesmo que long int unsigned long int 32 0 a 4.294.967.295 float 32 seis dígitos de precisão double 64 dez dígitos de precisão long double 80 dez dígitos de precisão Fonte: C Completo e Total; Herbert Schildt. 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 16 bits de informação Capítulo 2 26 2.2.2. A interface de desenvolvimento Quando se inicia a criação de um programa (opção new aplicattion do menu), são apresentados ao usuário, a janela do formulário (form), a barra de componentes (component palette) e a barra de propriedades e eventos (object inspector). 3.2.2.1. Barra de Componentes A barra de componentes apresenta todos os elementos que podem ser adicionados a um formulário, para a criação de um programa. 2.2.2.2. Formulário (form) O formulário (form) é a janela que irá receber os componentes (botões, edits, etc) que irão operar sobre o programa. O formulário é a interface entre o programa e o usuário. É o meio pelo qual o usuário interage com o programa, seja inserindo dados através de uma caixa de texto, seja executando uma função ao clique de um botão, etc. caixa de texto botão form rótulo Capítulo 2 27 2.2.2.3. Barra de Propriedades Cada componente possui uma lista de propriedades (no object inspector) que pode ser alterada de acordo com a necessidade do programador. Da mesma forma os eventos podem ser utilizados para executarem ações durante o uso do programa. 2.2.3. A criação de programas Enunciado: Dado o algoritmo que calcula a soma de dois números, elabore um programa em C, que realize as operações representadas no algoritmo. Para resolver este problema, primeiramente é necessário conhecer as diferenças entre os comandos do portugol e da linguagem C, como apresentado a seguir: Esta janela apresenta as propriedades do componente com o "foco". As propriedades, ou eventos podem ser alterados nesta janela, quando da escrita do programa. Por exemplo: a) para alterar o título do formulário, alterar a propriedade “caption”; b) para alterar o nome do formulário alterar a propriedade “name”; c) para alterar as cores do formulário alterar a propriedade “color”. As propriedades podem ser alteradas também durante a execução do programa, bastando referenciar o componente e a respectiva propriedade através do conector "->". Assim, no programa, pode-se escrever: Form1->Caption = “programa1”; Capítulo 2 28 Portugol Linguagem C inicio inteiro a,b,c; leia(a); leia(b); c = a + b: escreva(c); fim { int a,b,c; a = atoi(Edit1->Text.c_str()); b = atoi(Edit2->Text.c_str()); c = a + b; Edit3->Text = c; } Algumas diferenças ocorrem na leitura, escrita e atribuição de valores, como também em relação aos operadores relacionais, lógicos e aritméticos, como apresentado a seguir: a) Entrada de Dados leia(n); é escrito como n = atoi(Edit1->Text.c_str()); Onde, Edit1 é o nome do componente EditBox; Edit1->Text é a propriedade texto de Edit1; Edit1->Text.c_str() é o formalismo do Builder para leitura de string; atoi() é a função do C para converter caracteres alfanuméricos (texto) em valor numérico do tipo inteiro. Para usar a função atoi() é necessário incluir uma biblioteca do C: #include <stdlib.h> Obs: - Note que Edit1 é o nome do componente e Text é uma das propriedades; esta especificamente diz respeito ao conteúdo da caixa de texto. - Note também que Edit1 é o nome do EditBox. Este nome será usado para todo o programa. Lembre que através da propriedade name, o nome pode ser alterado. Por exemplo, Texto1->Text = ...; Capítulo 2 31 Os nomes podem ser alterados através das propriedades do object inspector. Então o formulário pode ficar como: d) Codificação do Programa A janela de edição permite visualizar e alterar o código do programa de cada "Unit" como mostra a figura abaixo. Cada componente pode perceber a ocorrência de um evento, por exemplo, o clique em um botão. Então, pode-se associar ao componente Button, as linhas de código que executam as operações. Ou seja, para calcular a soma entre dois números, devemos fornecer um valor como parâmetro através de uma EditBox, e o cálculo do fatorial só será executado mediante o clique do botão. Normalmente associa-se: comandos, aos componentes do tipo Button; entrada e saída de dados na tela, aos componentes EditBox ou Label; parâmetros condicionais aos componentes RadioButton e CheckBox. Para modificar o texto do label ou botão, deve-se alterar o conteúdo da propriedade Caption. Para Edits, alterar a propriedade Text. Lembre que a propriedade Caption não altera o nome do componente, apenas altera o texto que aparece sobre o componente. Assim, no programa os nomes continuam sendo Edit1, Edit2, ... etc. Para mudar o nome usar a propriedade Name. Capítulo 2 32 e) Compilando um Programa O C++ Builder deve compilar o programa para verificar a sintaxe, e gerar o código executável. Para compilar selecione a opção correspondente no menu, ou use as teclas de atalho Ctrl F9 ou F9. f) Executando um Programa Para executar o programa, utilize o comando RUN ou a tecla F9. Local para declaração das bibliotecas Evento clique do botão Programa em C Capítulo 2 33 g) Salvando o Programa Para gravar o programa recomenda-se criar uma pasta, pois vários arquivos gerados pelo compilador devem ser armazenados. Se este local for conhecido, então facilitará a localização e manutenção dos programas. Use o comando "Save All" para que todos os arquivos sejam salvos. Uma janela, como abaixo, é apresentada. Forneça um nome para o arquivo Unit1.cpp. Em seguida deverá ser fornecido um nome para o arquivo de projeto Project1.cpp . Obs: - Como a unit e o projeto tem a mesma extensão (.cpp), não esqueça de dar nomes diferentes para os dois arquivos. - Grave sempre no HD, pois o C++ gera vários arquivos durante a compilação. 2.2.5. Exercícios 1. Escreva um programa em C para somar e subtrair dois números fornecidos por um usuário, e apresentar o resultado usando um Editbox. 2. Modifique o exercício 3.1, para apresentar o resultado através de um Label; 3. Escreva um programa em C que calcule as raízes de uma equação de 2.º grau. 4. Escreva um algoritmo e um programa em C que conte quantas vezes um botão foi pressionado, e apresente o resultado em um EditBox. Capítulo 2 36 2.4. Desvio condicional em C O comando if - else permite expressar decisões que alteram o fluxo de execução de um programa. A sintaxe é dada por: 2.4.1. Desvio Condicional Simples Portugol Bloco com N comandos Apenas um comando ... se (condição) então comando; fim se ... ... if (condição) { comando 1; comando 2; ... comando n; } ... ... if (condição) comando; ... 2.4.2. Desvio Condicional Composto Portugol Bloco com N comandos Apenas um comando se (condição) então comando 1; senão comando 2; fim se if (condição) { comando 1; comando 2; comando 3; } else { comando n-1; comando n; } if (condição) comando 1; else comando 2; Com apenas um comando não é necessário abrir um bloco com chaves { }. Com apenas um comando não é necessário abrir um bloco com chaves { }. Capítulo 2 37 2.4.3. If’s Aninhados se (condição) então se (condição) então comando 1; fim se se (condição) então comando 2; senão comando 3; fim se senão comando 4; fim se if (condição) { if (condição) comando 1; if (condição) comando 2; else comando 3; } else comando 4; if (condição) comando 1; else if (condição) comando 2; else if (condição) comando 4; 2.4.4. Exemplo Escreva um algoritmo em portugol e o respectivo programa em C, para calcular as raízes de uma equação do 2.o grau: Ax² + Bx + C. Solução sem o uso de “if”. - Algoritmo em Portugol: Inicio inteiro: A, B, C; real: x1, x2; leia(A, B, C); x1 <- (-B + raiz(B^2 - 4*A*C))/ 2*A; x2 <- (-B - raiz(B^2 - 4*A*C))/ 2*A; escreva(x1, x2); fim Capítulo 2 38 - Programa em Linguagem C++ Builder #include <stdlib.h> // contém atoi() #include <math.h> // contém pow() e sqrt() // no botão OK: { int A, B, C; float x1, x2; A = atoi(Edit1->Text.c_str()); B = atoi(Edit2->Text.c_str()); C = atoi(Edit3->Text.c_str()); x1 = (-B + sqrt(pow(B,2) - 4*A*C))/ 2*A; x2 = (-B - sqrt(pow(B,2) - 4*A*C))/ 2*A; Edit4->Text = x1; Edit5->Text = x2; } b) Solução com o uso de “if”. - Algoritmo em Portugol: inicio inteiro: A, B, C, D; real: x1, x2; leia(A, B, C); D <- (B^2 - 4*A*C); se (D >= 0) então x1 <- (-B + raiz(D)/ 2*A; x2 <- (-B - raiz(D)/ 2*A; escreva(x1, x2); senão escreva("Delta < 0"); fim se fim Capítulo 2 41 2.5.3. Loop Faça/Enquanto (do/while) Portugol Linguagem C++ Builder inicio inteiro x; real C, F; F <- 0; faça C <- (5 * (F-32)) / 9; F <- F + 1; enquanto F < 100; fim { int x; float C, F; F = 0; do { C = (5 * (F-32)) / 9; F++; // F = F + 1; } while (F < 100); } 2.5.4. Exemplo Escreva um programa em C para calcular o fatorial de um número inteiro e positivo fornecido pelo usuário do programa. void__fastcallTForm1::Button1Click(TObject *sender) { int n, f, x; n = atoi(Edit1->Text.c_str()); f = 1; for ( x = n ; x > 1 ; x-- ) { f = f * x; } Edit2->Text = f; } Capítulo 2 42 2.5.5 Exercícios 1. Altere o loop for do exemplo anterior, para os loops while e do/while. 2. Escreva o algoritmo e o respectivo programa em C para um programa que conte a quantidade de números pares e ímpares digitados por um usuário. O usuário pode digitar quantos números quiser, e pode encerrar o programa quando desejar. 3. Escreva o algoritmo e o respectivo programa em C, para um programa que conte a quantidade de números primos digitados por um usuário. O usuário pode digitar quantos números quiser, e pode encerrar o programa quando desejar. Capítulo 2 43 2.6. PROCEDIMENTOS EM C 2.6.1. Definição A utilização de procedimentos permite que um conjunto de comandos possa ser usado repetidas vezes dentro de um programa, sem a necessidade de reescrever o código várias vezes. Um bloco de comandos é associado a um nome (nome do procedimento); sempre que for necessário executar estes comandos, basta chamar o nome do procedimento. 2.6.2. Exemplo 1 Desenvolva um programa que calcule a soma de dois valores reais fornecidos pelo usuário. - Formulário: - Dentro do Botão [+]: void __fastcall TForm1::Button1Click(TObject *Sender) { float valor1,valor2,resp; valor1 = atof(Edit1->Text.c_str()); valor2 = atof(Edit2->Text.c_str()); resp = valor1 + valor2; Edit3->Text = resp; } Capítulo 2 46 Da listagem anterior pode-se observar que a observação número: 1 – identifica o local aonde são adicionadas as bibliotecas e diretivas do programa. Sempre no início da Unit, 2 –identifica o local para declaração de variáveis globais. As variáveis globais devem existir antes de serem usadas pelo programa, pos isto vem antes; note que a variável resp é usado dentro do procedimento, e também dentro de cada botão. 3 –identifica o local para escrever os procedimentos (ou protótipos). Da mesma forma que a variável global, o procedimento precisa primeiro existar para que possa ser usado pelo resto do programa. Pode ser escrito o procedimento inteiro ou apenas o protótipo; neste caso o bloco do procedimento pode ser escrito em qualquer parte do programa. (menos dentro de eventos do formulário). 4- identifica a chamada do procedimento. No momento em que precisa-se calcular a soma, chama-se o procedimento. Note que existe passagem de parâmetros. O conteúdo de valor1 é passado para a variável a do procedimneto e o conteúdo de valor2 é passado para a variável b do procedimento. Observe também que valor1 e valor2 são variáveis locais do botão, portanto não podem ser acessadas pelo procedimento; por isto é necessário realizar passagem de parâmetros. As variáveis a e b são locais do procedimento (só existem dentro do procedimento), mas a resposta é atribuída a resp, que é uma variável global, portanto pode ser acessada por todo o programa. 5- igual ao item 4, com o valor constante 10 em vez da variável valor2. 2.6.3. Protótipo Dado o exemplo anterior, formalmente pode-se criar o protótipo de um procedimento com apresentado a seguir: NomeDoProcedimento(lista de parâmetros); Sempre declarando o procedimento como global, ele pode ser acessado em qualquer parte do programa. Capítulo 2 47 2.6.4. Parâmetros Uma ou mais variáveis de tipos iguais ou diferentes que são utilizadas pelo procedimento para a realização de alguma operação específica. Durante a execução sequencial de um programa, um procedimento pode ser chamado e pode receber alguns valores para serem operados. 2.6.5. Exemplo 2 Dado o programa em C, que calcula as raízes de uma equação do segundo grau, modifique a estrutura para a utilização de um procedimento para limpar a tela (conteúdo das variáveis e caixas de texto). a) Sem Procedimento // declaração de variáveis globais int A, B, C, D; // parâmetros da equação float x1, x2; // raízes da equação . . . //----------------------------------------------------- // botão para o cálculo das raízes void __fastcall TForm1::Button1Click(TObject *Sender) { A = atoi(Edit1->Text.c_str()); // entrada dos valores B = atoi(Edit2->Text.c_str()); C = atoi(Edit3->Text.c_str()); Capítulo 2 48 D = pow(B,2) - 4*A*C; // calcula delta if ( D >= 0 ) // testa se existe raízes { x1 = (-B + sqrt(D))/ 2*A; x2 = (-B - sqrt(D))/ 2*A; Edit4->Text = x1; // apresenta resposta Edit5->Text = x2; } else { ShowMessage("Delta < 0"); Edit1->Text = ""; // limpa Caixas de Texto Edit2->Text = ""; Edit3->Text = ""; Edit4->Text = ""; Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado } } //----------------------------------------------------- // botão para limpar os valores da tela void __fastcall TForm1::Button2Click(TObject *Sender) { Edit1->Text = ""; // limpa Caixas de Texto Edit2->Text = ""; Edit3->Text = ""; Edit4->Text = ""; Edit5->Text = ""; A=0;B=0;C=0;D=0; // limpa valores da equação x1=0;x2=0; // limpa resultado } //----------------------------------------------------- No exemplo acima , note que os trechos de programa escritos em vermelho se repetem. Então podemos transformar o trecho repetido, em um procedimento. Capítulo 2 51 variável que vai retornar o valor deve ser do mesmo tipo da função. Observe que a função sempre tem um tipo, ou seja, uma função pode ser do tipo inteiro, real, etc. Quando a função não tem um tipo (void), então ela não pode retornar um valor, ou seja passa a ser um procedimento. 2.7.4. Exemplo 1 Desenvolva um programa que calcule a soma de dois valores reais fornecidos pelo usuário. - Formulário: No exemplo de procedimento os conteúdos das variáveis locais eram trocados via passagem de parâmetros, mas a variável de resposta resp, passou a ser global a fim de receber a soma dos conteúdos passados para a e b. Agora, se a variável resp não for mais declarada como global, ou seja, passar a ser local de cada botão, então pode-se reescrever o procedimento na forma de uma função, como apresentado a seguir: //----------------------------------------------------------------------- #include <vcl.h> #pragma hdrstop #include <stdlib.h> #include "Unit1.h" 1-Bibliotecas e diretivas de compilação. Capítulo 2 52 #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //------------------------------------------------------------------------ //------------------------------------------------------------------------- float Soma(float a, float b) { float r; r = a + b; return r; } //------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { } //------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { float valor1,valor2,resp;; valor1 = atof(Edit1->Text.c_str()); valor2 = atof(Edit2->Text.c_str()); resp = Soma(valor1,valor2); Edit3->Text = resp; } //------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) { float valor1, resp; valor1 = atof(Edit1->Text.c_str()); resp = Soma(valor1,10); Edit3->Text = resp; } Da listagem anterior pode-se observar que a observação número: 1 – identifica o local aonde são adicionadas as bibliotecas e diretivas do programa. Sempre no início da Unit, 2-Espaço para declaração de variáveis globais. 3-Espaço para declarar procedimentos e funções ou seus protótipos. 4-Trecho de programa do botão [+] e a chamada da função Soma. 5-Trecho de programa do botão [+ 10] e a chamada da função Soma. Capítulo 2 53 2 –identifica o local para declaração de variáveis globais. Note que neste exemplo, não utiliza-se mais variáveis globais; 3 –identifica o local para escrever os procedimentos (ou protótipos). Da mesma forma que a variável global, o procedimento precisa primeiro existar para que possa ser usado pelo resto do programa. Pode ser escrita toda a função ou apenas o protótipo; neste caso o bloco do procedimento pode ser escrito em qualquer parte do programa. (menos dentro de eventos do formulário). 4- identifica a chamada da função. No momento em que precisa-se calcular a soma, chama-se o procedimento. Note que existe passagem de parâmetros. O conteúdo de valor1 é passado para a variável a do procedimneto e o conteúdo de valor2 é passado para a variável b do procedimento. Observe também que valor1 e valor2 são variáveis locais do botão, portanto não podem ser acessadas pelo procedimento; por isto é necessário realizar passagem de parâmetros. As variáveis a e b são locais do procedimento como também agora, a variável r. para que o valor de r possa ser conhecido pelo restante do programa a função deve retornar o conteúdo de r, através do comando return. A variável local resp recebe o valor retornado por r. 5- igual ao item 4, com o valor constante 10 em vez da variável valor2. 2.7.5. Exemplo 2 Modifique o programa de cálculo das raízes, para o uso de uma função que calcule o valor da exponencial de um número qualquer (x^y), sem o uso do comando pow(). #include <vcl.h> #pragma hdrstop #include "raizes.h" #include <stdlib.h> // contém atoi() #include <math.h> // contém pow() Capítulo 2 56 2.8. Incrementos e Decrementos Incrementar e decrementar variáveis são tarefas muito comuns em programação. A linguagem C oferece alguns comandos para realizar estas operações. Exemplo A: { int total, valor; valor = 0; total = valor + 1; //conteúdo de valor mais 1 ... } Exemplo B: { int total, valor; valor = 0; total = valor++; //conteúdo de valor mais 1 ? ... } 2.8.1. Incremento/Decremento a Posteriori Neste caso, primeiro é feito a operação de atribuição e depois incrementa/decrementa a variável. Exemplo: Incremento Decremento { int total; int valor; valor = 1; total = valor++; /** neste exemplo total recebe valor e depois da atribuição é somado 1 a variável valor **/ ... } { int total; int valor; valor = 1; total = valor--; /** neste exemplo total recebe valor e depois da atribuição é subtraído 1 da variável valor **/ ... } Capítulo 2 57 2.8.2. Incremento/Decremento a Priori Neste caso, primeiro é incrementado o valor, e depois é atribuído a variável. Exemplo: Incremento Decremento { int total; int valor; valor = 1; total = ++valor; /** neste exemplo valor é incrementado e depois é feita a atribuição **/ ... } { int total; int valor; valor = 1; total = --valor; /** neste exemplo valor é decrementado e depois é feita a atribuição **/ ... } 2.8.3. Exercício Qual o conteúdo das variáveis total e valor após a execução dos seguintes comandos? { int valor, total; valor = 3; total = 5; total = valor++; total = ++valor; total = valor--; total = --valor; } Capítulo 2 58 2.9. Atribuição Composta Através da combinação de operadores pode-se fazer atribuições das seguintes formas: Exemplo: total += valor; // total = total + valor; valor += 1; // valor = valor + 1; valor *= 10; // valor = valor * 10; 2.9.1. Exercício Qual o valor das variáveis valor e total após a execução dos seguintes comandos? { int valor = 3; int total = 5; total *= ++valor; } 2.10. Atribuição Múltipla Depois de declaradas as variáveis podem-se ter comandos de atribuição da seguinte forma: total = valor = resposta = 0; // atribui 0 a todas as variáveis 2.10.1. Exemplo { int resposta, valor, total; resposta=total=0; valor=4; reposta = total + valor; } ou, { int resposta, valor, total; resposta=total=0; reposta = total + (valor = 4); } Capítulo 2 61 Dentro do botão: { int x; x = random(10); switch(x) { case 0 :{ Edit1->Text = “Reservatório vazio”; break; } case 9 :{ Edit1->Text = “Reservatório cheio”; break; } default: ShowMessage(“Reservatório Ok”); } } 2.14. Timer A geração de números aleatórios é muito utilizada em ambiente de simulação. No caso do exemplo anterior, o usuário ao clicar um botão no formulário, faz o computador gerar um único número aleatório, que dependendo do valor, apresenta resultados diferentes do nível do reservatório. O problema é que o usuário deverá clicar no botão toda vez que quizer gerar um valor. Muitas vezes pode ser interessante que o computador gere vários números aleatórios a fim de analizar um processo. Para isto usa-se o timer do Windows. 2.14.1. O Componente timer no C++ Builder O componente timer pode ser acessado na barra de componentes dentro do menu system. ícone do timer. Capítulo 2 62 2.14.2. As propriedades do timer 2.14.3. Exemplo Pode-se modificar o exemplo 3.13.2, para que os valores aleatório sejam gerados a cada 1s. void __fastcall TForm1::Timer1Timer(TObject *Sender) { int x; x = random(10); switch(x) { case 0 :{ Edit1->Text = “Reservatório vazio”; break; } case 9 :{ Edit1->Text = “Reservatório cheio”; break; } default: Edit1->Text = “Reservatório Ok”; } } 2.14.4. Exercício 1- Desenvolva um programa que simule o sorteio da mega-sena (6 números de 0 a 60 ). habilta/desabilita o timer Intervalo de repetição em ms Nome do componente Os comandos ficam dentro do evento timer. Capítulo 3 63 3. ESTRUTUAS HOMOGÊNEAS DE DADOS 3.1. MATRIZES UNIDIMENSIONAIS (VETORES) Um vetor é um caso especial de matriz, onde ela possui apenas uma linha, e é declarado da seguinte forma: tipo nome[ tamanho ]; Onde: tipo especifica o tipo de dados que a matriz contém. nome identifica a matriz dentro do programa; tamanho valor constante que define a área de memória ocupada pelos elementos; 3.1.1. Exemplos int vetor[10] = {1,2,3,4,5,6,7,8,9,10}; //inicializado com valores inteiros float S[3] = {0,0,0}; //inicializado com zeros long V[250]; // não inicializado 3.1.2. Indexação Cada valor é armazenado em uma das posições do vetor (definido pelo tamanho). Então, o vetor possui índices que identificam a posição do conteúdo no vetor. O primeiro elemento sempre está na posição 0 (zero) do vetor. Exemplo int vetor[10] = {1,2,3,4,5,6,7,8,9,10}; pode ser representado na memória como: Capítulo 3 66 iii) Teste de mesa Exemplo Dado o vetor vet[4] = {50,36,1,8}, ordenar os elemento em ordem crescente: primeira vez: comparar vet[0] com vet[1] (50 com 36); é maior, então troca; comparar vet[1] com vet[2] (50 com 1); é maior então troca; comparar vet[2] com vet[3] (50 com 8); é maior então troca. O vetor vet agora contém {36, 1, 8, 50} segunda vez: comparar vet[0] com vet[1] (36 com 1); é maior então troca comparar vet[1]com vet[2] (36 com 8); é maior então troca comparar vet[2] com vet[3] (36 com 50) não é maior então não troca após N-1 vezes, o vetor vet contém {1,8,36,50}. 3.2.2. Exercício 1 - Escreva um programa em C, para preencher um vetor V de 6 elementos com valores aleatórios entre 0 e 10, e que ordene este vetor da seguinte forma: a)botão 1: ordena automaticamente todos os elementos através do método bolha; b)botão 2: ordena todos os elementos através do método bolha, mostrando passo a passo cada iteração (a cada clique do botão). Obs.: crie um botão para gerar os números aleatórios para o vetor. Capítulo 3 67 2 - Escreva um programa em C que preencha um vetor V de 100 elementos com valores aleatórios entre 0 e 10 e localize neste vetor, um valor procurado pelo usuário. Se o elemento existir neste vetor, apresentar uma mensagem que o elemento foi encontrado, caso contrário apresentar uma mensagem que o elemento não foi encontrado. 3 – Implemente modificações no método bolha para se diminuir a quantidade de comparações necessárias na ordenação, tornando-o mais eficiente. 4 - Pesquisar sobre o tema "Pesquisa Binária" e desenvolver o programa; 3.3. STRINGS A string em C define uma sequëncia de caracteres alfanuméricos (texto). O exemplo: "CEP80215-901", contém letras, números e símbolos. Tudo o que está entre aspas duplas é dito string. Uma string pode ser lida num formulário através de uma caixa de texto (EditBox), e armazenada em uma variável do tipo char (caracter) da seguinte forma: 3.3.1.Exemplo 1 Lembre que no C, 1 caracter ocupa 1 byte na memória . Então se definirmos uma variável do tipo char, estaremos reservando apenas 1 byte, possibilitando armazenar apenas um único caracter. { char letra; // variável para armazenar um caracter. ... letra = 'a'; // a variável letra recebe o // caracter a, observe o uso de // aspas simples ... Edit->Text = letra; } Capítulo 3 68 3.3.2.Exemplo 2 A string "CEP80215-901" ocupa 12 bytes. Como armazenar esta string, se a variável do tipo char possui tamanho de 1 byte? Se 1 caracter = 1 byte na memória, então para armazenar 12 caracteres são necessários 12 bytes. Então pode-se criar vetores para armazenar strings (texto). Um detalhe importante é lembrar que o C, na manipulação de strings, precisa de um byte a mais além do necessário, devido ao caracter de final de arquivo \0 (barra zero). Se a string cep possui 12 caracteres, então deve ser criado o vetor com o tamanho 13, como apresentado abaixo. Note o uso da função strcpy() para a leitura do Edit1, em substituição aos atoi( ), atof( ), etc. 3.3.3. Copiando strings Quando se opera com strings faz-se necessário o uso de um comando específico para copiar a string, como apresentado abaixo: strcpy(string_destino, string_fonte) No Botão OK: { char cep[13]; strcpy(cep, Edit1-Text.c_str()); Edit2->Text = cep; } c e p 8 0 2 1 5 - 9 0 1 \0 Capítulo 3 71 3.3.7.1. convertendo valores numéricos para caracter a) comando itoa(valor inteiro, string, base) { int num = 12345; char string[6]; itoa(num, string, 10); Edit1->Text = string; } b) comando sprintf( string, format , argumentos); { int num = 12345; char string[6]; sprintf(string,"%d", num); Edit1->Text = string; } { float num = 123.456; char string[20]; sprintf(string,"O valor é %.2f", num); Edit1->Text = string; } 3.3.7.2. convertendo string para valores numéricos a) comando atoi(string) { int num; char string[6]=”12345”; num = atoi(string); num+=1; Edit1->Text = num; } Capítulo 3 72 b) comando atof(string) { float num; char string[7]=”1.2345”; num = atof(string); num+=1; Edit1->Text = num; } 3.3.8 Exercícios 1 – Num programa em C, o que acontece se a quantidade de carcteres digitada pelo usuário é maior que o tamanho da string definida no programa? 2 - O acontece de manipularmos uma string sem o ‘\0’ ? 3 - Escreva um programa, que leia o valor de um número de CEP fornecido pelo usuário, e diga a qual cidade pertence este CEP; após identificar a cidade, fornecer o nome da rua associado a ele. O problema deve reconhecer no mínimo 3 cidades e 2 ruas cada. (cidades e ruas podem ser fictícios); O primeiro caracter da string do cep se refere à cidade; os restantes correspondem à rua; O programa deve identificar se o número fornecido pelo usuário é válido, através dos requisitos: tamanho do cep, presença do sinal "-", presença de uma cidade cadastrada e presença de uma rua cadastrada. 4 – Digite um programa que coloque em ordem alfabética (crescente) um string de 20 caracteres. 5 – Digite um programa para inverter uma string fornecida pelo usuário. Capítulo 3 73 3.4. MATRIZES Uma Matriz é uma coleção de variáveis do mesmo tipo, referenciada por um nome comum. Um elemento específico de uma matriz é acessado através de um índice. Todos os elementos ocupam posições contíguas na memória. 3.4.1. Matrizes Bidimensionais As matrizes em C podem ser de várias dimensões. Uma matriz de duas dimensões pode ser declarada da seguinte forma: int nome[tamanho 1] [tamanho 2]; Os dados de uma matriz são acessados através de índices. Existe um índice associado a uma linha da matriz e outro índice para a coluna da matriz, de onde está alocado o dado. Exemplo: int mat [3][3]; As posições da matriz são formadas por: mat[0][0] contém 1 mat[1][0] contém 4 mat[2][0] contém 7 mat[0][1] contém 2 mat[1][1] contém 5 mat[1][0] contém 8 mat[0][2] contém 3 mat[1][2] contém 6 mat[2][0] contém 9 1 2 3 4 5 6 7 8 9 0 1 2 0 1 2 Mat[1][2] Capítulo 3 76 3.4.4. Exercícios 1) Escreva um programa em C que preencha uma matriz 4X4 com "0" e a sua diagonal principal com "1", e apresente a matriz através de um form; 2) Para um professor que tenha 3 turmas de 5 alunos, escreva um programa que calcule a média de notas de cada turma; 3) Escreva um programa em C que preencha uma matriz 4X4 com "0" e a sua diagonal principal com "1", e apresente na tela uma linha da matriz por vez, a cada clique em um botão; 4) Desenvolva um programa do “jogo da velha”, de forma que o usuário possa jogar contra o computador; 5) Desenvolva um programa do tipo “tetris” usando matriz e os conceitos de C já adquiridos; 6) Desenvolva um programa que permita obter a transposta de uma matriz 4 x 4 fornecida pelo usuário; 7) Desenvolva um programa que permita somar, subtrair e multiplicar duas matrizes 3 x 3, fornecidas pelo usuário; 8) Desenvolva um programa que some todos os elementos de uma matriz 5 x 5; 9) Desenvola um programa que permita movimentar o elemento 1 da matriz abaixo em uma direção aleatória a cada 1s. O movimento do elemento não pode extrapolar os limites da matriz. 1 Capítulo 4 77 TP II Capítulo 4 78 4. PONTEIROS EM C 4.1. DEFINIÇÃO Um ponteiro é uma variável que contém um endereço de memória [Schildt,97]. Este endereço é normalmente a posição de outra variável na memória. Se uma variável contém o endereço da outra, então a primeira variável aponta para a segunda. Exemplo Endereço na Memória Conteúdo na Memória 1000 1001 1100 ... ... 1100 ‘A’ 1101 Neste exemplo, uma variável que está alocada na posição 1001 possui como conteúdo, o valor 1100; - este valor é o endereço de uma outra posição de memória, que possui uma informação armazenada, por exemplo, o caracter 'A'. Então neste exemplo, diz-se que a variável da posição 1001 aponta para a variável da posição 1100, e ambas tem o mesmo conteúdo, a letra'A' No C, ao se definir: char letra; // cria variável do tipo char ... letra = 'A'; // a variável letra armazena o caracter A ... É reservada uma área na memória com o tamanho especificado pelo tipo da variável (char = 1 byte). Esta área é identificada no programa por um nome (letra), mas internamente ao sistema, por um valor numérico, chamado endereço da variável. O conteúdo da variável também é convertido para um número na base binária. Capítulo 4 81 Resposta endereço conteúdo 1001 1002 1 1003 2 1004 1005 1006 1.o) int x = 1; int y = 2; endereço conteúdo 1001 1002 1 1003 2 1004 1002 1005 1006 2.o) ip = &x; ip só é adicionado na memória após ser inicializado endereço conteúdo 1001 1002 1 1003 1 1004 1002 1005 1006 3.o) y = *ip; endereço conteúdo 1001 1002 0 1003 1 1004 1002 1005 1006 4.o) *ip = 0; 2. Qual o valor da variável Y após a execução do trecho de programa abaixo. // associado ao evento clique de um botão { int X,Y; int *Z; X = atoi(Edit1->Text.c_str()); Z = &Y; Y = X++; (*Z)++; Edit2->Text = Y; } 3. Dado o trecho de programa do exercício 2, o que acontece se: a) a linha Z=&Y fosse alterada para Z=Y ? Por quê ? b) a linha (*Z)++ fosse alterada para (Z)++ ? Por quê ? Capítulo 4 82 4. Qual é o valor de x e de y, após a execução do procedimento troca() das situações A e B? Situação A Situação B // globais int x = 0; int y = 1; // procedimento troca void troca(int val_x, int val_y) { int temp; temp = val_x; val_x = val_y; val_y = temp; } //dentro de um botão: { troca(x,y); } // globais int x = 0; int y = 1; // procedimento troca void troca(int * val_x, int * val_y) { int temp; temp = *val_x; *val_x = *val_y; *val_y = temp; } //dentro de um botão: { troca(&x,&y); } 4.4. Ponteiros para matriz Dados do tipo matriz podem ser indexados através de ponteiros. Um ponteiro para uma matriz (ou vetor) sempre apontará para o primeiro elemento desta matriz (posição de índice 0). O exemplo 1, apresenta um ponteiro p que aponta para o primeiro elemento do vetor V. a linha de comado p=v é igual a p=&v[0]. Para acessar outro elemento da matriz, basta apontar para ela, na posição desejada (p. ex. p=&v[2] faz p apontar para o terceiro elemento de v. Exemplo 1 { int v[10]; int *p; // o sinal * indica que a variável é do tipo ponteiro p = v; //atribui a p o endereço do primeiro elemento de vetor } Capítulo 4 83 Exemplo 2 { int i[10]; int *p; // o sinal * indica que a variável é do tipo ponteiro p = i; // atribui a “p” o endereço do primeiro elemento de i p[5] = 100; // 6º elemento recebe 100 usando o índice *(p+5) = 100; // 6º elemento recebe 100 } Observe no exemplo 2, que o ponteiro p pode ser indexado como se fosse o próprio vetor i (p[5]=100). Também, este comando pode ser escrito da forma *(p+5)=100. Então, para acessar todos os elementos de um vetor, o ponteiro p pode ser indexado através de um loop, como apresenta o exemplo 3. Exemplo 3 { int i,v[10]; int *p; // o sinal * indica que a variável é do tipo ponteiro p = v; // atribui a “p” o endereço do primeiro elemento de v for (i=0; i <10; i++) *(p+i)=0; // preenche o vetor v com o valor zero } Dado o vetor v[10] expresso a seguir: v[0] v[1] V[9] Se declaramos um ponteiro para inteiro: int *p; a atribuição: p = v; faz com que "p" aponte para o elemento zero do vetor "v" (&v[0]); Se "p" aponta para um elemento particular de um vetor, então "p+1" aponta para o próximo elemento.
Docsity logo



Copyright © 2024 Ladybird Srl - Via Leonardo da Vinci 16, 10126, Torino, Italy - VAT 10816460017 - All rights reserved