PRG1-2012-2-Engenharia

PRG1 - PROGRAMAÇÃO I

CARGA HORÁRIA

TOTAL: 72 HORAS (4 HORAS/SEMANA)

TEÓRICA: 36 HORAS

LABORATÓRIO: 36 HORAS

DIAS COM AULA: 36 (18 semanas)

EMENTA

Introdução a lógica de programação e algoritmos. Constantes, variáveis e tipos de dados. Operadores aritméticos, relacionais e lógicos. Concepção de fluxograma e pseudocódigo. Estruturas de decisão e estruturas de repetição. Introdução a linguagem de programação c. Vetores de caracteres e multidimensionais. Ponteiros e aritmética de ponteiros. Funções: chamada por valor e por referência. Chamada recursiva de funções. Tipos de dados compostos. Operação com arquivos textos e binários.

Bibliografia Básica

• SCHILDT, Herbert. C Completo e Total - 3.ed. [S.l.]: Makron, 1997. 830p. ISBN 978-8534605953

Referências Complementares

• Apostila adotada: Curso de Linguagem C - Engenharia Elétrica - UFMG

• Apostila sobre Lógica de Programação

AULAS

AULA 1 DIA 5/10/2012

AULA 1 DIA 5/10/2012 Como fazer um churrasco Vamos observar atentamente este vídeo para iniciarmos o nosso curso de programação: EmbedVideo received the bad id "U0xSYIXE9vo#!" for the service "youtube". O que tem o churrasco com a nossa aula?? Trata-se de uma sequência de passos para execução de um objetivo. EXERCÍCIO: Na forma textual, descrever as etapas para fazer um bom churrasco. O que é um algoritmo Um algoritmo pode ser visto como uma sequência de instruções ou operações que resolvem um dado problema. A receita de um bom churrasco corresponde a um algoritmo. Como representar um algoritmo ? Uma forma é representar na forma textual ordenada: 1.Comprar a carne 2.Colocar carvão na churrasqueira 3.Acender o carvão 4.Cortar a carne (picanha) 5.Espetar a carne 6.Salgar a carne 7.Colocar a carne na churrasqueira 8.Aguardar a carne ficar no ponto desejado 9.Bater a carne 10.Servir a carne Outras formas são mais apropriadas para o uso no meio computacional: pseudo-código fluxogramas A PENSAR: É possível mudar a ordem das instruções? É possível paralelizar algumas instruções? O problema da raposa, do milho e da galinha EmbedVideo received the bad id "yifW9XueSaI#!" for the service "youtube". EXERCÍCIO 1: Descrever na forma de etapas um solução para o problema da raposa, do milho e da galinha. Note que somente é possível escrever o algoritmo se tivermos uma solução para o problema. EXERCÍCIO 2: Descrever na forma de etapas uma solução para o problema dos canibais/padres. Torres de Hanoi Veja este jogo: EmbedVideo received the bad id "hLnuMXO95f8#!" for the service "youtube". EXERCÍCIO 3: Escrever na forma de etapas numeradas a solução para o problema das torres de Hanói usando 3 discos. EXERCÍCIO 4: Escrever na forma de etapas numeradas a solução para o problema das torres de Hanói usando 4 discos. E para quem são os algoritmos? Uma receita de bolo é apropriada para ser executada por um ser humano. Um procedimento de como trocar um pneu também. Mas muitas vezes queremos que o algoritmo seja executado por uma máquina! O computador é perfeito para isto! Neste curso vamos nos concentrar no desenvolvimento de algoritmos simples, desde a sua concepção até a sua implementação através de uma LINGUAGEM DE PROGRAMAÇÃO, em um computador. Um PROGRAMA implementa um algoritmo. É o algoritmo materializado na forma de uma sequência de instruções. Neste sentido, vamos entender minimamente o funcionamento de um computador. Como funciona um computador? Como ele executa programas ("receitas")? Partes de um computador: UCP (CPU) (Unidade Central de Processamento) Barramentos Memórias: Primária (semicondutora -> RAM e ROM) e Secundárias (disco, pendrive) Dispositivos de Entrada e Saída de Dados (Teclado, Monitor etc) O computador é digital: Dados e Instruções são sequências de bits Representação de dados em sistemas computacionais: uso de códigos (ex:código ASCII); A -> 01000001 B -> 01000010 As instruções também são palavras binárias interpretadas pela CPU; De forma simplificada podemos dizer que as instruções ficam em uma memória de programa enquanto os dados a serem processados pelo programa ficam em uma memória de DADOS; O programa que está na memória de programa está escrito em LINGUAGEM DE MÁQUINA Funcionamento Simplificado de um Computador Suponha que um programa a ser executado se encontra em uma memória de programa. Ao ligar o sistema, a CPU busca na memória de programa uma instrução a ser executada (ciclo de busca) e, então, executa a instrução (ciclo de execução). Na SEQUÊNCIA, a CPU busca a PRÓXIMA instrução na memória de programa, e assim sucessivamente... O fluxo de execução do programa é, a princípio SEQUENCIAL no sentido que a execução de uma instrução é realizada somente após a execução da instrução antecedente. (apresentação do Prof.Semprebom sobre computadores) Possíveis linguagens de programação Na prática, é inviável desenvolver programas complexos em LINGUAGEM DE MÁQUINA. Em geral, utilizamos linguagens de ALTO NÍVEL que podem, de alguma forma, serem traduzidas (compiladas) para a linguagem de baixo nível ou interpretadas em tempo de execução. Exemplo: Linguagem C Fortran Basic C++ Pascal Java Python Neste curso utilizaremos a linguagem C. Por que? É uma linguagem muito usada na implementação de produtos eletrônicos, incluindo àqueles voltados as Telecomunicações. Um exemplo completo PROBLEMA: Computar a média de dois números reais fornecidos pelo teclado. Mostrar o resultado no monitor. SOLUÇÃO: ALGORITMO DADOS DE ENTRADA: NUM1 e NUM2 DADOS DE SAÍDA: MEDIA INÍCIO 1.Ler NUM1 2.Ler NUM2 3.MEDIA <- (NUM1+NUM2)/2 4.Mostrar MEDIA FIM /* Calculador de media de dois números reais */ #include <stdio.h> main() { float num1,num2; scanf(&num1); scanf(&num2); media = (num1+num2)/2; printf ("media =\n", media); } EXERCÌCIO 5: Implementar o algoritmo com o Scratch. Plano de Ensino Agora que temos uma ideia do que será tratado neste curso, vamos apresentar o plano de ensino.

AULA 2 DIA 9/10/2012

AULA 2 DIA 9/10/2012 Objetivos Recordando o significado de algoritmo Um algoritmo é um "um conjunto de instruções para resolver um determinado problema". O nome advém de al-Khwārizmī Segundo Knuth um algoritmo deve: Sempre terminar após um determinado número de passos. Caso contrário, é chamado (por Knuth) de método computacional; Cada passo do algoritmo deve ser precisamente definido (sem ambiguidades); Um certo número (ou nenhum) de dados de entrada deve ser fornecido no início ou dinamicamente na execução do algoritmo; Ter dados de saída, resultantes do processamento dos dados de entrada; Ser efetivo, no sentido que suas operações sejam simples e se executem em tempo finito de tempo; Não existe algoritmo para fazer um algoritmo É sempre bom lembrar que não existe um algoritmo para fazer um algoritmo. Podemos considerar que fazer um algoritmo é uma forma de arte. No entanto, existem algumas diretrizes que podem ser consideradas. Vamos ver estas: Comprender bem o problema é fundamental para a solução; “If I had an hour to solve a problem I'd spend 55 minutes thinking about the problem and 5 minutes thinking about solutions.” ― Albert Einstein Tentar enumerar estratégias possíves; Tentar dividir o problema e resolver os subproblemas. A Descrição de Algoritmos usando Fluxogramas Um fluxograma é uma linguagem semi-gráfica que pode ser utilizada para descrição de algoritmos. Exemplo: O algoritmo de cálculo da média de dois números da aula anterior: Pontos fortes: permite fácil entendimento do algoritmo, mesmo para pessoas leigas; Ponto fraco: a descrição das estrutura dos dados inexiste. O usuário deve descrevê-los a parte; Observe no exemplo anterior que nada é dito sobre as variáveis NUM1, NUM2 e MEDIA. Símbolos de um Fluxograma Teste de Mesa Constantes, Variáveis Algoritmos operam sobre dados. O que podem ser estes dados? Variáveis e Constantes No exemplo anterior podemos identificar três variáveis NUM1, NUM2 e MEDIA Também podemos identificar uma CONSTANTE. O número 2. Tipo de Variáveis: Numéricas: reais e inteiras Ex: NUM1 = 5.5 /* NUM1 é uma variável real */ Booleanas: true ou false Ex: RES = TRUE /* RES é uma variável booleana */ caracter: Ex: LETRA = 'A' alfanumérica Ex: FRASE = "ALO MUNDO" E como estas variáveis armazenam os dados?? Depende da linguagem usada. Vamos passar uma primeira noção do C Expressões Expressões sentenças que relacionam variáveis e constantes através de operadores matemáticos e que RESULTAM em um valor. A instrução do algoritmo: MEDIA = (NUM1 + NUM2) / 2 será considerada como uma expressão, que usa os operadores '+', '/' e '=' O operador '=' é um OPERADOR DE ATRIBUIÇÃO e indica que a expressão do lado direito do '=' será atribuída a variável do lado esquerdo. Neste curso, para mantermos coerência com a Linguagem C, consideraremos que a expressão como um todo resulta no valor que é atribuído a variável. Operadores Aritméticos Os operadores aritméticos que usaremos neste curso serão os disponíveis no C: Operador Significado + adição - subtração * multiplicação / divisão % resto O único operador desconhecido aqui é o resto, cujo significado é o resto entre dois números inteiros. Exemplo, se B possui o valor 9, então o resultado da atribuição na expressão: A = B%2 será 1. Operadores relacionais Os operadores relacionais permitem realizar comparações entre dois operandos. Os operadores são os seguintes: Operador Significado > maior que >= maior ou igual que < menor que <= menor ou igual que == igual a (se o operando a esquerda é maior que o da direita) != diferente de (se o operando a esquerda é diferente do da direita) LINK PARA O EDITOR YED Se você quiser um editor de fluxogramas pode utilizar a ferramenta abaixo: Se baixar o zip com o java, descompactar, entrar no diretório e executar com: java -jar yed.jar Editor Yed Sheldon e o fluxograma da amizade Vamos observar o fluxograma da amizade do Sheldom da série de TV "Big Bang Theory" EmbedVideo received the bad id "VAX4jLlNo-Q#!" for the service "youtube". Observer que a caixa no formato de LOSANGO permite testar uma condição: é uma caixa de decisão. Controle do Fluxo de Execução: Caixas de Decisão Em algumas situações é necessário realizar algum teste sobre uma expressão. Seja o problema: Problema do Controle de Acesso PROBLEMA: Controlar o acesso a uma porta usando uma senha pré-configurada no sistema. DADO DE ENTRADA: SENHA (variável alfanumérica) DADO DE SAÌDA: porta aberta (simulado com msg "PORTA ABERTA") ou mensagem de "SENHA NAO CONFERE" EXERCÍCIO: Elaborar um fluxograma para o o problema de controle de acesso prevendo um procedimento para modificar a senha de acesso. Para tanto, assuma a existência de uma senha de administrador fixa (por exemplo, "xY12"). Se a senha do administrador for fornecida, mostrar um menu de modificação de senha. A nova senha deve ser repetida. Exercícios OBS: sempre anote antes do fluxograma os tipos e significado das variáveis usadas, caracterizando os dados de entrada e os de saída. Apresentar um fluxograma para ler 3 números e fazer a média; Fazer um teste de mesa usando como valores de entrada 2.0, 5.0 e 3.0; Construir um fluxograma para ler 3 números e calcular a média dos dois maiores números lidos; Refazer o exercício anterior, para calcular a média do maior e do menor número entre os 3 lidos. Considere um algoritmo para calcular o comprimento de uma circunferência. Quem são os dados de entrada e os dados de saída. Fazer um fluxograma para resolver o problema; Modifique o algoritmo acima para calcular, além do comprimento, a área da circunferência; Considere que a função de uma reta é dada por: $y=5x+2$. Elabore um fluxograma para calcular o valor de y dado o valor de x. Um estudo sobre sensibilidade de pessoas a temperaturas da água identificou que a maioria das pessoas considera fria a água com temperaturas abaixo de 25 graus, morna entre 25 e 30 graus, e quente acima de 30 graus. Escreva um algoritmo na forma de fluxograma que mostre as palavras "fria", "morna" ou "quente" dependendo da temperatura da água que for informada;

AULA 3 DIA 11/10/2012

Objetivos

O aluno deverá ser capaz de:

• construir fluxogramas usando estruturas de repetição;
• compreender o aninhamento de estruturas de controle de fluxo
• dividir problemas em subproblemas e utilizar subrotinas para organizar a solução.

Quebrando um problema em subproblemas: SUBPROGRAMAS

PROBLEMA: Aprimorar o exemplo do controle de acesso para que, no caso de 3 tentativas de acesso seguidas, com senha errada, o sistema seja bloqueado.

• DADOS DE ENTRADA: SENHA /* variável que armazena a senha entrada pelo usuário ou administrador */
• DADOS DE SAÍDA: mensagem de abertura da porta / usuário bloqueado*/
• VARIÁVEIS INTERMEDIÁRIAS: CONT_ACESSO /* valor inicial zero - incrementada a cada senha inválida */

Note que a variável CONT_ACESSO é iniciada com zero e
incrementada a cada erro no fornecimento da senha. A 
atribuição CONT_ACESSO = CONT_+ACESSO + 1 deve ser 
interpretada da forma: acesse o valor de CONT_ACESSO e some 1
a este valor. Coloque o resultado novamente em CONT_ACESSO
(o conteúdo anterior é sobrescrito!)

Neste procedimento pode ser observado que:

• começa a aparecer uma certa complexidade no fluxograma;
• Além disto, não ficou uma abordagem muito interessante, pois se for o administrador que erra a senha, ele pode bloquear o usuário;
• não existe forma de desbloquear a senha (zerar o contador), a não ser mudando a senha.

Em síntese, existem subproblemas adicionais a serem resolvidos. Como podemos resolvê-los sem deixar um fluxograma complexo?

Usaremos a caixa de processos pré-definidos que usaremos para invocar funções que resolvem determinado subproblema.

Inicialmente, vamos construir três subprogramas:

• Iniciar_Sistema(): inicia variáveis do sistema, colocando o sistema em um estado inicial conhecido;
• Tratar_Admin(): é o código que trata a funcionalidade associada ao administrador;
• Tratar_User(): é a funcionalidade que trata o usuário (procedimento de abrir porta, bloquear etc).

OBS: Note que foi usada uma variável auxiliar AUX que permite ajustar o valor
de número de acessos a ser mostrado no display. Note também que na caixa DISPLAY foi usado
uma string a ser impressa e a variável AUX cujo conteúdo deve ser impresso. Ambos separados
por vírgula.

• ANINHAMENTO DE DECISÔES

A função Tratar_User() se utiliza de aninhamento de decisões. Em um primeiro momento é testado se a senha confere com a senha do usuário. SE ela conferir ENTÂO é testado se o contador de bloqueios está dentro do aceitável.

Estruturas de repetição

No exemplo de controle de acesso da aula passada já construímos uma estrutura de repetição (um loop infinito). Vamos elaborar um pouco mais estas estruturas de repetição.

Uma das grandes vantagens de um sistema computacional é a capacidade de repetir um conjunto de instruções
possivelmente sobre dados diferentes, a uma velocidade muito grande.

PROBLEMA: Calcular a somatório de N valores a serem fornecidos pelo teclado.

$S=\sum _{i=0}^{N-1}a_{i}=a_{0}+a_{1}+..+a_{N-1}$

DADOS DE ENTRADA:

• N /* número de valores */,
• a_i /* valor de um dos N números a serem inseridos */

DADOS DE SAÌDA = S /* somatório */

NOTA: Observe que a estrutura de repetição utilizada é caracterizada por um teste (decisão) de uma expressão que deverá resultar em verdadeiro enquanto houver número a ser lido (dentro da quantidade N de números), um contador de itens lidos "i" e um bloco de repeticão terminado em um arco que conduz o fluxo de execução ao início da decisão.

EXERCÍCIOS

EXERCÍCIO 1: Modificar o sistema de controle de acesso para incluir a inserção de nome de usuário (USERID) e senha (SENHA). Prever a existência de dois usuários (USERID_1, USERID_2, SENHA_1, SENHA_2). O admin poderá ser identificado pelo nome ADMIN. Prever bloqueio por usuário (duas variáveis contadores). Sugestão: criar funcões separadas para tratamento de cada usuário. Em breve veremos como podemos contornar esta duplicação através da parametrização de funções/subprogramas.

EXERCÍCIO 2: Implementar o sistema do exercício 1 com o Scratch. Simule as funções usando envio de sinais (isto foi feito no projeto integrador do semestre passado).

EXERCÍCIO 3: Escrever um fluxograma que leia como dados de entrada dois números inteiros positivos: "s" e "q". O programa deve computar os dez primeiros números da PG (progressão geométrica), onde "s" é o número inicial e "q" a razão da progressão.

Obs: Para PG tem-se:

$a_{1}=s$

$a_{n}=q\times a_{n-1}$ ou

$a_{n}=a_{1}.q^{n-1}\,\!$

EXERCÍCIO 4: Implementar um fluxograma que permita computar a somatória dos N primeiros termos de uma PG, cujos valores de "s" e "q" são também fornecidos como dados de entrada.

AULA 4 - 15/10/2012

OBJETIVOS

O aluno deverá ser capaz de:

• Fazer mapeamento de estruturas de controle de fluxo do fluxograma para o Scratch;
• Compor expressões lógicas utilizando operadores relacionais e lógicos;
• Parametrizar e retornar valores em subprogramas;
• distinguir e usar variáveis locais e globais;

Mapeamento de Fluxograma em Pseudocódigo e código SCRATCH

Fluxograma	Pseudocódigo	Scratch	Comentário
	SE i < 10 ENTÃO IMPRIMIR "i menor que 10" FIMSE </syntaxhighlight>||	SE a condição i<10 for verdadeira então será impressa a mensagem caso contrário nada será feito e a próxima instrução depois do comando será execuatda.
	SE i < 10 ENTÃO IMPRIMIR "valor de i menor que 10" SENÂO IMPPRIMIR "valor de i maior ou igual a 10" FIMSE </syntaxhighlight>
	SE i <10 ENTÃO IMPRIMIR "valor de i menor que 10" SENAO IMPPRIMIR "valor de i maior ou igual a 10" SE i == 10 ENTÃO IMPRIMIR "Ok valor de i igual a 10 FIMSE </syntaxhighlight>		Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).
340px	ENQUANTO verdadeiro FAÇA IMPRIMIR "Alo" FIMENQUANTO </syntaxhighlight>		Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).
340px	ENQUANTO verdadeiro FAÇA SE a == 1 ENTÃO IMPRIMIR "Alo" FIMSE FIMENQUANTO </syntaxhighlight>		Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).
340px	SE i <10 ENTÃO IMPRIMIR "valor de i menor que 10" SENAO IMPPRIMIR "valor de i maior ou igual a 10" SE i == 10 ENTÃO IMPRIMIR "Ok valor de i igual a 10 FIMSE </syntaxhighlight>		Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).
340px	SE i <10 ENTÃO IMPRIMIR "valor de i menor que 10" SENAO IMPPRIMIR "valor de i maior ou igual a 10" SE i == 10 ENTÃO IMPRIMIR "Ok valor de i igual a 10 FIMSE </syntaxhighlight>		Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).

Expressões Lógicas

Nas aulas anteriores utilizamos expressões usando operadores aritméticos e relacionais. É possível construir expressões ainda mais completas usando os operadores lógicos, apresentados abaixo:

Operador	Significado
&&	AND
||	OR
!	NOT

Uma expressão lógica tem como resultado da sua avaliação um valor VERDADEIRO ou FALSO. Para manter a coerência com a linguagem C
qualquer expressão que resultar em 0 será considerada FALSA e se resultar em algo diferente de 0 será considerada verdadeira.

PROBLEMA: Entrar com um número inteiro pelo teclado. Se o número for maior que 1 e menor que 10, imprimir uma mensagem "Número maior que 1 e menor que 10".

DADO DE ENTRADA: NUM /* Número inteiro a ser comparado */ DADO DE SAÍDA: Mensagem no display PROBLEMA: Entrar com um número inteiro pelo teclado. Se o número for menor ou igual a 1 OU se for maior ou igual a 10 então mostrar a mensagem "Número menor ou igual a 1 ou maior ou igual a 10"

DADO DE ENTRADA: NUM /* Número inteiro a ser comparado */ DADO DE SAÍDA: Mensagem no display

Uma outra solução para este último problema poderia ser:

ARRAYS UNIDIMENSIONAIS (VETORES)

Um vetor pode ser visto como uma variável que pode ser indexada e onde em cada posição existe um elemento do vetor. Os elementos do vetor possuem um tipo único.

PROBLEMA: Ler 10 números inteiros para um vetor de inteiros. Computar um segundo vetor que é o resultado da multiplicação por um escalar inteiro 5.

DADO DE ENTRADA: Os 10 números armazenados em VET1 DADO DE SAÍDA: VET2, o vetor resultado da multiplicação de VET1 por 5.

Exercício 1: Implementar um algoritmo para ler 10 números inteiros para um vetor e imprimir o número de números acima da média. OBS: Definir um contador, iniciado em zero. Calcular a media e fazer um loop sobre o vetor testando cada item para verificar se é maior que a média.

Armazenamento de cadeias de caracteres em vetores

Em aulas anteriores vimos que um caracter pode ser representado por uma sequência de bits. Utilizando um código é possível definir o significado da sequência. Um código amplamente usado é o ASCII. Com 8 bits (7 no Ascii original) tem-se então a possibilidade de representar qualquer letra, número, ou símbolo (vírgula, ponto-e-vírgula etc). Note que um número representado em ASCII NÂO serve para realizar operações aritméticas. Trata-se de representação textual, por exemplo, um dígito de um número telefone.

Uma cadeia de caracteres ou string nada mais é que uma sequência de caracteres ASCII. Para mantermos coerência com a linguagem C, vamos assumir que uma string bem comportada termina com um zero (0, não o caracter '0' que é o número 48 decimal em ASCII). Em inglês chama-se "string NULL terminated".

Exemplo: A string "IFSC" armazenada em um vetor CADEIA, na memória de um computador, teria a seguinte implementação:

Estamos assumindo que cada caracter é armazenado em um byte. Uma string terminada em 0 facilita o seu processamento pois pode-se facilmente detectar o seu final. Note que no exemplo acima, a string está armazenada em um vetor CADEIA cujo tamanho excede ao da string. Os bytes que se seguem ao zero podem ser considerados lixo.

Processando cadeias de caracteres

Sabendo como uma string é armazenada na memória de um computador torna-se fácil processá-la. Por exemplo, vamos ver um algoritmo para contar o número de caracteres de uma string lida pelo teclado para dentro de um vetor CADEIA.

EXERCÍCIO 1: Elaborar um fluxograma para computador o número de ocorrências do caracter 'b' em uma string lida pelo teclado.

EXERCÍCIO 2: Estude a tabela ASCII e elabore um fluxograma para capitalizar todos os caracteres minusculos de uma string lida pelo teclado.

AULA 4 - 15/10/2012

PARÂMETROS E RETORNO DE VALORES EM SUBPROGRAMAS

Na aula anterior estudamos o uso de subprogramas como forma de reaproveitar código e estruturar um algoritmo, permitindo a quebra de um problema em subproblemas. Para tornar ainda mais interessante o uso de subprogramas, vamos ver o conceito de passagem de parâmetros e retorno de valores.

Quando chamamos (invocamos) um subprograma podemos passar valores (dados de entrada) para este subprograma.
Estes valores são passados através de variáveis especiais que chamamos de parâmetros.

Parâmetros podem ser passados por valor e por referência. Por valor é quando os dados a serem passados na invocação
do subprograma são copiados para uma variável do subprograma.

Os parâmetros são passados por referência quando o que é passado para o subprograma é simplesmente o endereço da variável
repassada na invocação do subprograma.

Não existe uma forma explícita de definir os parâmetros em um fluxograma. Deve-se realizar um comentário antes ou ao lado do mesmo especificando o tipo e como será tratado o parâmetro.

EXEMPLO: Seja elaborar um fluxograma correspondente a uma subrotina que deve calcular o fatorial de um número inteiro passado como parâmetro. O subprograma deve retornar o valor calculado.

A função fatorial é definida por:

$n!=\prod _{k=1}^{n}k\qquad \forall n\in \mathbb {N}$

Neste fluxograma, o subprograma denominado CalcFatorial recebe um valor no parâmetro N (implicitamente inteiro) e retorna o valor calculado do fatorial.

O fluxograma principal invoca duas vezes o subrograma. O retorno é armazenado nas variáveis NUM1 e NUm3.

Quando um subprograma retorna um valor, ele é chamado de função. Para manter coerência com o C chamaremos
qualquer subrprograma de função (independente de retornar valor).

EXERCÍCIO 1: Implementar uma função, usando fluxgrama, para computar o valor da PG, dados como parâmetros s e q.

EXERCÍCIO 2: Implementar uma função chamada str_len() que recebe uma string como parâmetro e retorna o tamanho da mesma.

VETORES DE STRINGS

Na aula passada aprendemos vetores de caracteres e como usá-los para armazenamento de strings. Note que é possível construir vetores de strings. Vamos ao exemplo do controle de acesso.

PROBLEMA: Suponha que existe uma Tabela global de usuários chamada TabUserID. Suponha também que esta tabela tem tamanho finito de 20 posições. Posições não usadas estão com string VAZIA (0 na primeira posição). Construir uma função chamada LocalizarUserID, que recebe um UserID (string) como parâmetro (a tabela não precisa ser passada pois é GLOBAL) e retorna o índice onde se encontra o usuário UserID na tabela. Se o usuário não for encontrado, a função deve retornar -1.

EXERCÌCIO: Implementar uma função TratarUsuario() que se utiliza de duas tabelas: a TabUserID e a TabPassword para cada usuário na primeira tabela existe uma senha na segunda tabela. A função deve ler o UserID, usar a função LocalizarUserID para determinar o índice do usuário, ler a senha do usuário e validá-la usando o índice encontrado.

AULA 6 - Dia 20/10/2012

Objetivos

O aluno devera ser capaz de:

• descrever o processo de compilação;
• diferenciar código fonte, objeto e executável;
• compilar, executar pequenos programa em C usando o gcc;
• declarar e usar variáveis locais inteiras e reais;
• usar as funções de entrada e saída: scanf() e printf.

Introdução a linguagem C

• Histórico

EmbedVideo received the bad id "rGCbvqz6Kt4#!" for the service "youtube".

• Características da Linguagem
• O C K&R (uma especificação informal da linguagem) e o ANSI C
• linguagem imperativa e procedural.

Visão geral do processo de compilação com gcc

• Linguagens compiladas (ex: C) versus linguagens interpretadas (ex: Basic)

Compilando o programa

Neste curso usaremos o compilador da coleção gcc do projeto GNU. O manual completo do gcc pode ser encontrado aqui.

O processo de desenvolvimento do programa envolve:

• Editar o programa com um editor de texto tal como o vi ou gedit;
• Salvar o programa com a terminação ".c" (ou ".h" se for um cabeçalho);

NOTA: crie um diretório para trabalhar nos exercícios que se seguem:

mkdir ExerciciosC
cd Exercicios

Exemplo: salve o programa abaixo como teste.c

 

#include <stdio.h>

main()
{
  printf("Alo Mundo\n");
}

• Compilar/gerar executável do programa usando o gcc:

 gcc teste.c -o teste

• Testar o programa:

./teste

Nota: o atributo -o permite que se forneça um nome para o executável diferente de a.out

É possível somente compilar (gerar código objeto):

 gcc -c teste.c

Observe os subprodutos listando com detalhes:

 ls -l

Declarando variáveis inteiras e reais locais

No "c" temos que declarar as variáveis que serão utilizadas no programa. Se estas variáveis forem declaradas DENTRO da função elas serão "vistas" somente localmente (escopo local). Este conceito será estendido para blocos de códigos posteriormente.

 
#include <stdio.h>

main()
{
  /* aqui começam as declarações de variáveis */
  int x; /* declaração de uma variável inteira */
  float y;  /* declaração de uma variável real */

  /* aqui começam as instruções do programa principal */ 
  x=5;   /* atribuindo o valor 5 (constante) a variável x */
  y=6.5; 
}

Funções de entrada e saída de dados

No "c" não existe instrução especialmente para leitura ou saída de dados. Este procedimento é realizado através de funções da biblioteca. Na sequência são mostradas duas funções "clássicas" de entrada e saída de dados.

 
#include <stdio.h>

main()
{
 
  int x; /* declaração de uma variável inteira */
  float y;  /* declaração de uma variável real */

  printf ("Entre com o valor de x ");
  scanf("%d",&x);

  printf ("Entre com o valor de y ");
  scanf("%f",&y);

  printf ("O valor de x é %d\n",x);
  printf ("O valor de y é %f\n",y); 
}

Comandos de decisão if() e if() else

 

#include <stdio.h>

main()
{
 
  int x; /* declaração de uma variável inteira */
  int y;  /* declaração de uma variável inteira */

  printf ("Entre com o valor de x ");
  scanf("%d",&x);

  printf ("Entre com o valor de y ");
  scanf("%d",&y);

  if (y>x)
     printf("MSG1:y é maior que x\n");


  if (y>x)
     printf("MSG2:y é maior que x\n");
  else
     printf("MSG3:y é igual ou menor que x\n");
 
}

Outro exemplo, usando blocos:

 
#include <stdio.h>

main()
{
 
  int x,y,z; /* declaração de uma variável inteira */

  printf ("Entre com o valor de x ");
  scanf("%d",&x);

  printf ("Entre com o valor de y ");
  scanf("%d",&y);

  if (y>x) {
     printf("MSG1: y é maior que x\n");
     z = y-x;
     printf("MSG2: Neste caso z =  %d\n", z);
  } else {
     printf("MSG3: y é igual ou menor que x\n");
     z = x-y;
     printf("MSG4: Neste caso z =  %d\n", z);
  }
 
}

Comando de repetição while (): decisão no início do loop

O comando while permite implementar loops com controle no início:

#include <stdio.h>
main() 
{
  int contador;
  
  contador=0;
  while (contador<5) {  
     printf("valor do contador =  %d\n", contador);
     contador=contador+1;
  }
}

Relação de comandos do fluxograma com Programa C

Fluxograma	C	Comentário
	main() { printf("Alo Mundo\n"); }	O fluxogram do programa principal corresponde a função main() do C. A primeira instrução que se executa é a primeira instrução da função main() e a última instrução é a última do main()
	if (y>5) x=x+1;
	if (y>5) { x=x+1; z=z+1; }	Observar que quando existe mais de uma instrução simples sob o controle do if, deve-se usar as chaves (conceito de bloco).
	if (y>5) { x=x+1; z=z+1; } else { x=x-1; z=z-1; }	comando if com a parte else (SENÃO)
	while(contador<5) { printf("Entre com x\n"); scanf("%f",&x); soma=soma+x; contador = contador + 1; }	comando while() aplicado sobre um bloco de instruções. Note que se for uma instrução simples, as chaves podem ser omitidas.
	if (z>5) { while(contador<5) { printf("Entre com x\n"); scanf("%d",&x); soma=soma+x; if (soma>150) y=z+x; } }	Note que instruções while e if são tratadas como instruções normais que podem ser aninhadas normalmente em outros comandos.

Exercícios

1. Ler 2 números reais e imprimir a média deles.

    
   #include <stdio.h>
   main()
   {
      float num1, num2, media;
   
      printf("Entre com o primeiro numero ");
      scanf ("%f", &num1);
   
      printf("Entre com o segundo numero ");
      scanf ("%f", &num2);
   
      media = (num1 + num2) / 2;
   
      printf ("\nMedia = %f \n", media);
   }
   

2. Ler 3 números reais e imprimir o produto dos três.
3. Ler dois números complexos, em formato retangular, e calcular a soma dos mesmos. Obs: Ler de forma independente a parte real e a parte imaginária de cada um deles.
4. Ler as aulas 1 e 2 das aulas de C da UFMG (ver referências no início).

AULA 8 Dia 25/10/2012
AULA 8 Dia 25/10/2012

Objetivos da Aula

O aluno deverá ser capaz de:

• utilizar funções: passar parâmetros por valor (reais, inteiros e caracter) e retornar valores;
• compor expressões complexas usando constantes, variáveis e operadores;

Funções no C

Chamando funções

Um programa em C basicamente é um conjunto de funções. 
Uma função pode ser vista como um subprograma para o qual podemos repassar 
dados de entrada através de parâmetros e receber os resultados através 
do retorno da função.

Normalmente, um programa bem comportado em C possui pelo menos uma função: a função main(). Esta função é chamada no início da execução do programa. A primeira instrução da função main() é a primeira instrução executada pelo programa (pelo menos do ponto de vista do programador). Da mesma forma, a última instrução desta função é a última instrução a ser chamada.

Um programa normalmente vai apresentar um conjunto de funções. Por exemplo:

#include <stdio.h>

func4()
{
    printf("Esta é a função func4()\n");
}

func3()
{
    printf("Esta é a função func3()\n");
    func4();
}

func2()
{
    printf("Esta é a função func2()\n");
}

func1()
{
    printf("Esta é a função func1()\n");
    func2();
    func3();
}

main()
{
    printf("Esta é a primeira instrução da função main()\n");
    func1();
    printf("Esta é a última instrução da função main()\n");
}

A sequência de chamada de funções pode ser ilustrada da forma:

EXERCÍCIO: Compile e execute o programa acima. Verifique a ordem de impressão das mensagens e compare com as chamadas das funções.

NOTA: Uma função pode ser chamada várias vezes no programa. 
É O REAPROVEITAMENTO DE CÓDIGO...

Passando parâmetros e recebendo valores de retorno

Uma função normalmente resolve um determinado problema para um determinado conjunto de dados e produz uma saída. Estes dados podem ser passados como parâmetros e a saída pode ser retornada pela função.

Exemplo: Uma função media_nums() que retorna a média de 3 números reais passados como parâmetros

float media_nums(float num1, float num2, float num3)
{
  float media_local;

  media = (num1 + num2 + num3)/3;
  return media;
}

main()
{
  float media, aux1, aux2, aux3;

  printf("\nEntre com numero 1: ");  
  scanf ("%f",&aux1);

  printf("\nEntre com numero 2: ");  
  scanf ("%f",&aux2);

  printf("\nEntre com numero 3: ");  
  scanf ("%f",&aux3);

  media = media_nums(aux1, aux2, aux3);
  printf ("\nmedia dos 3 numeros é %f\n", media);
}

Deve ser observado que:

• após o nome da função, entre parênteses, são fornecidos os três parâmetros com os seus respectivos tipos. Os valores (conteúdos das variáveis) aux1, aux2 e aux3 são copiados para as variáveis num1, num2 e num3 da função media_nums().
• a função media_nums() retorna um valor do tipo float (informado antes do nome da função) que é o valor da variável media_local. Este valor é copiado para a variável media da função main()
• as variáveis num1, num2 e num3 bem como a variável media_local possuem escopo LOCAL, ou seja, são "vistas" somente pela função media_nums();
• as variáveis media, aux1, aux2 e aux3 também possuem escopo LOCAL, ou seja são "vistas" somente pela função main();

NOTE que o formato de declaração de uma função é

 tipo_retorno nome_funcao( lista_de_parametros )
 {
   declaracao_variaveis_locais

   instruções
 }

Por enquanto, assumiremos que variáveis devem ser somente declaradas no início da função. Existem situações que poderemos relaxar esta afirmação.

Um pouco mais sobre parâmetros

O termo argumento ou parâmetro real (atual) é usado para referenciar os valores que estão sendo passados na CHAMADA da função. Os parâmetros formais referem-se aos parâmetros listados na função. É comum, no entanto, usar os termos argumentos e parâmetros como sinônimos e identificados pelo contexto em que estão sendo usados.

A passagem de parâmetros POR VALOR diz respeito a copiar o valor do argumento na CHAMADA da função para a variável associada ao parâmetro na função. Mais tarde falaremos na passagem de parâmetro POR REFERÊNCIA. Por ora, usaremos a passagem POR VALOR.

Os parâmetros passados na CHAMADA de uma função não são necessariamente variáveis. Eles podem ser uma expressão qualquer (uma expressão SEMPRE resulta em um VALOR).

Exemplo de chamadas para a função media_nums():

main()
{
  float media, x,y,z;

  x = 5.7;
  y = 9.8;

  /* exemplo de chamada 1 */  
  media = media_nums(4.8,x,y*3);

  /* exemplo de chamada 2 */ 
  media = media_nums (x+y,y*y+5,(x+y)/2);
}

Deve ser observado que:

• na chamada 1 do exemplo, os parâmetros são uma CONSTANTE, o valor de x, e o valor de y*3. Note que o compilador deve gerar código para resolver estas expressões antes de INVOCAR a função!.
• na chamada 2 aparecem expressões ainda mais complexas. Todas elas devem ser resolvidas antes da função ser INVOCADA.

Variáveis GLOBAIS e variáveis LOCAIS

Se variáveis são declaradas dentro de uma função, então a visbilidade (ESCOPO) destas variáveis é LOCAL. Nenhuma outra função tem acesso a estas variáveis.

Uma variável pode ser GLOBAL, ou seja, declarada FORA das funções. Neste caso a variável é VISTA por todas as funções. Seja o exemplo anterior modiificado:

float media; /* Variável GLOBAL */

void media_nums(float num1, float num2, float num3)
{
  media = (num1 + num2 + num3)/3;
  return media;
}

main()
{
  float aux1, aux2, aux3; /* Variáveis LOCAIS */

  printf("\nEntre com numero 1: ");  
  scanf ("%f",&aux1);

  printf("\nEntre com numero 2: ");  
  scanf ("%f",&aux2);

  printf("\nEntre com numero 3: ");  
  scanf ("%f",&aux3);

  media_nums(aux1, aux2, aux3);
  printf ("\nmedia dos 3 numeros é %f\n", media);
}

Neste exemplo, a variável media é declarada como GLOBAL. Ela é MODIFICADA diretamente pela função media_nums() e impressa pela função main()

NOTE que como a função media_nums() não retorna valor então declaramos 
seu tipo de retorno como void que significa aqui NADA ou VAZIO. 

NOTE também que MESMO que a função retorne um valor, não é obrigatório colocá-la
no lado direito do sinal de atribuição.

Na realidade, uma função pode ser chamada dentro de qualquer expressão. Por exemplo, para o caso em que a função media_nums() retorna um valor, ela poderia ser usada como:

float media_nums(float num1, float num2, float num3)
{
  float media_local;

  media = (num1 + num2 + num3)/3;
  return media;
}

main()
{
  float media, aux1, aux2, aux3;
  printf("\nEntre com numero 1: ");  
  scanf ("%f",&aux1);).

  printf("\nEntre com numero 2: ");  
  scanf ("%f",&aux2);

  printf("\nEntre com numero 3: ");  
  scanf ("%f",&aux3);

  media = media_nums(aux1, aux2, aux3);
  printf ("\nmedia dos 3 numeros multiplicada por 10 é %f\n", 10*media_nums(aux1, aux2, aux3));
}

Nome de variáveis

Um nome de variável pode conter letras, dígitos e o underscore(sublinhado). Ela DEVE iniciar com um underscore ou uma letra. Letras maúsculas e minúsculas podem ser usadas e são distinguidas (o C é CASE SENSITIVE

Variáveis LOCAIS e GLOBAIS podem ter o mesmo nome. A variável LOCAL terá preferência no uso.

Exercício: Execute o programa abaixo e verifique as saídas.

#include <stdio.h>

int i=1;          /* GLOBAL  */

func()
{
    int i=100;     /* LOCAL */
    i=i+1;          /* incrementa LOCAL
    printf( "Valor de i = %d na função func()\n", i );
}
   
main()
{
    i=i+1;          /* incrementa GLOBAL  */
    func();
    printf( "Valor de i = %d \n", i );
}

 NOTA: não é recomendado o uso de variáveis com o mesmo nome.

Iniciando variáveis na declaração

Tanto as variáveis LOCAIS como as GLOBAIS podem ser inicializadas na declaração.

Exemplo:

int alfa=1;

main()
{
  float beta=1.5

  printf("Valor de alfa = %d e valor de beta = %f\n", alfa, beta);
}

 NOTA: variáveis LOCAIS não são iniciadas automaticamente: cabe ao programador iniciá-la corretamente.

 NOTA: variáveis GLOBAIS são iniciadas automaticamente com zero. 
       Mas mantenha-se informado sobre o sistema que está trabalhando...
       Em sistemas embarcados pode não ser verdade

Tipo de Dados no C

Tipo	Explanação	Tamanho	Opção	Explanação
char	Tipo inteiro. Pode ser sinalizado ou não dependendo da implementação.	tamanho	signed char	same as char</syntaxhighlight>, but guaranteed to be signed.
		Predefinição:Cpp	same as char</syntaxhighlight>, but guaranteed to be unsigned.
Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp	short signed integer type. At least 16 bits in size.	Predefinição:Cpp Predefinição:Cpp	same as short</syntaxhighlight>, but unsigned.
Predefinição:Cpp Predefinição:Cpp	basic signed integer type. At least 16 bits in size.	Predefinição:Cpp Predefinição:Cpp	same as int</syntaxhighlight>, but unsigned.
Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp	long signed integer type. At least 32 bits in size.	Predefinição:Cpp Predefinição:Cpp	same as long</syntaxhighlight>, but unsigned.
Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp Predefinição:Cpp	long long signed integer type. At least 64 bits in size. Specified since the C99 version of the standard.	Predefinição:Cpp Predefinição:Cpp	same as long long</syntaxhighlight>, but unsigned. Specified only in C99 version of the standard.
Predefinição:Cpp	(single precision) floating-point type. Actual properties unspecified, however on most systems this is IEEE 754 single precision floating point format.
Predefinição:Cpp	double precision floating-point type. Actual properties unspecified, however on most systems this is IEEE 754 double precision floating point format.
Predefinição:Cpp	extended precision floating-point type. Actual properties unspecified. Unlike types Predefinição:Cpp and Predefinição:Cpp, it can be either 80-bit floating point format, the non-IEEE "double-double" or IEEE 754 quadruple precision floating-point format if a higher precision format is provided, otherwise it is the same as Predefinição:Cpp. See this page for details.

Exercícios

1. Implementar um programa com uma função que recebe dois números inteiros como parâmetro e imprime uma mensagem caso primeiro número seja igual ao segundo. A função não retorna nada. A função main deve mostrar como funciona a função, chamando-a três vezes com diferentes valores.

   #include <stdio.h>
   
   void comp_num(int a, int b)
   {
      if (a == b)
   	printf("parametros iguais\n");
   }
   
   main()
   {
      int x = 2;
      comp_num(2,4);
      comp_num(2,2);
      comp_num(2,x);
   }
   

2. Refazer o exercício anterior mas agora a função não deve imprimir nada. Ela deve retornar 1 se o primeiro parâmetro é maior que o segundo, 0 se forem iguais e -1 se o segundo for maior que o primeiro.

   #include <stdio.h>
   
   int comp_num(int a, int b)
   {
      int aux;
   
      /* o codigo abaixo pode ser otimizado com if elseif */
      if (a == b)
   	aux = 0;
      if(a > b)
          aux = 1;
      if (a < b)
          aux = -1;
   
      return aux;
   }
   
   main()
   {
      int x;
      x = comp_num(2,4);
      printf ("Retorno igual a %d\n", x);
      x = comp_num(2,2);
      printf ("Retorno igual a %d\n", x);
      x = 2;
      x = comp_num(2,x);
      printf ("Retorno igual a %d\n", x);
   }
   

   outra solução seria

   #include <stdio.h>
   
   int comp_num(int a, int b)
   {
      int aux;
   
      /* o codigo abaixo pode ser otimizado com if elseif */
      if (a == b)
   	aux = 0;
      else {
           if(a > b)
               aux = 1;
           else
               aux = -1;
      }
   
      return aux;
   }
   
   main()
   {
      int x;
      x = comp_num(2,4);
      printf ("Retorno igual a %d\n", x);
      x = comp_num(2,2);
      printf ("Retorno igual a %d\n", x);
      x = 2;
      x = comp_num(2,x);
      printf ("Retorno igual a %d\n", x);
   }
   

3. Implementar uma função chamada imprime_faixa que recebe dois números inteiros como parâmetros e, caso o segundo parâmetro seja maior que o primeiro ela deve imprimir todos os números inteiros entre oos dois parâmetros (incluindo eles). Exemplo: Seja a chamada

    imprime_faixa(4,6);
   

   A saída deve ser: 4 5 6

#include <stdio.h>

void imprime_faixa(int a, int b)
{
   if (b>a) {
        while (a <=b)
		printf("%d ",a++);
        printf("\n");
   }   
}

main()
{
   imprime_faixa(1,3);
   imprime_faixa(2,7);
}

AULA 35

SOLUÇÔES:

1.Atravessar G
2.Retornar
3.Atravessar M
4.Retornar G
5.Atravessar R
6.Retornar
7.Atravessar G

1.ATR CP
2.RET P
3.ATR CC
4.RET C
5.ATR PP
6.RET PC
8.ATR PP
9.RET C
10.ATR CC
11.RET C
12.ATR CC

PROBLEMA: determinar as raízes da equação do segundo grau (Baskara)
DADOS DE ENTRADA: coeficientes reais A, B e C
DADOS DE SAÍDA: raízes X1-REAL,X1-IMG e X2-REAL, X2-IMAG 
VARÍAVEIS INTERMEDIÁRIAS: DELTA
COMENTÁRIO: DELTA pode ser positivo, 0 ou negativo. O valor de DELTA deve ser testado.

FLUXOGRAMA

1. Construir um fluxograma para ler 3 números e calcular a média dos dois maiores números lidos;
2. Construir um fluxograma para ler 3 números e calcular a média do maior e do menor número entre os 3 lidos.

1. Refazer o exercício para ler 3 números e calcular a média dos dois maiores números lido usando variáveis auxiliares MAIOR e MENOR;
2. Refazer o exercício 4 para calcular a média do maior e do menor número entre os 3 lidos usando variáveis auxiliareas MAIOR e MENOR;
3. Construir um fluxograma para ler 6 números e calcular a média dos dois maiores números lidos. Faça um teste de mesa;

1. Faça um algoritmo para fazer a divisão de dois números reais. Antes de dividí-los deve ser feito um teste de validade. Caso não seja possível dividi-los, deve ser mostrada uma mensagem de erro. Se for possível, deve-se mostrar o resultado da divisão;
2. Fazer um algoritmo para computar a área e perímetro de um retângulo. Entrar com os dois lados;
3. Fazer um programa para computar as áreas de um retângulo e de um círculo. O programa deve mostrar uma mensagem indicando qual figura possui maior área;