C Introdução à Aplicações Gráficas

Prévia do material em texto

- LINGUAGEM C – 
 
INTRODUÇÃO À PROGRAMAÇÃO 
COM APLICAÇÕES GRÁFICAS 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Nilson Luiz Maziero 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Passo Fundo, setembro de 2008. 
SUMÁRIO 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 2 
 
 
 
 
Introdução........................................................................................................................................ 4 
Capítulo 1 ........................................................................................................................................ 5 
1. Programação ............................................................................................................................... 5 
1.1 Conceitos básicos de programação .......................................................................................... 5 
1.2 Tipos de dados .......................................................................................................................... 5 
1.3 Operações aritméticas............................................................................................................... 6 
1.4 Operadores relacionais.............................................................................................................. 6 
1.5 Operadores de incremento e decremento................................................................................. 6 
1.6 Funções básicas........................................................................................................................ 7 
1.6.1 Função clrscr( )....................................................................................................................... 7 
1.6.2 Função printf( ) ....................................................................................................................... 7 
1.6.3 Função getch( )....................................................................................................................... 7 
1.6.4 Função scanf( )....................................................................................................................... 8 
1.6.5 Função for( ) ........................................................................................................................... 9 
1.6.6 Função while( ) ....................................................................................................................... 10 
1.6.7 Função do while( ) .................................................................................................................. 11 
1.6.8 Função if( )....else................................................................................................................... 12 
1.6.9 Função delay( ) ....................................................................................................................... 12 
1.6.10 Função sqrt( ) ....................................................................................................................... 13 
1.6.11 Função sin().......................................................................................................................... 13 
1.6.12 Função cos()......................................................................................................................... 13 
1.6.13 Função tan() ......................................................................................................................... 13 
1.6.14 Função atan() ....................................................................................................................... 13 
1.7 Construção de funções do usuário............................................................................................ 13 
1.8 Interface gráfica......................................................................................................................... 14 
1.9 Funções gráficas ....................................................................................................................... 14 
1.10 Programa de desenho de uma reta e um círculo .................................................................... 17 
 
Capítulo 2 ........................................................................................................................................ 20 
2. Aplicações ................................................................................................................................... 20 
2.1Programa Parábola..................................................................................................................... 20 
2.1.1 O que é uma parábola............................................................................................................ 20 
2.1.2 Elementos da parábola........................................................................................................... 20 
2.1.3 Processo de traçado............................................................................................................... 21 
2.1.4 Desenvolvimento do algoritimo............................................................................................... 21 
2.1.5 Fluxograma............................................................................................................................. 22 
2.1.6 O programa básico ................................................................................................................. 22 
2.1.7 O programa parábola – versão 1............................................................................................ 23 
2.1.8 O programa parábola – versão 2............................................................................................ 24 
2.1.9 O programa parábola – versão 3............................................................................................ 25 
2.1.10 Comentários ......................................................................................................................... 26 
2.2 Programa Elipse ........................................................................................................................ 27 
2.2.1 O que é uma elipse................................................................................................................. 27 
2.2.2 Elementos de uma elipse ....................................................................................................... 28 
2.2.3 Processo dos círculos concêntricos ....................................................................................... 28 
2.2.4 Desenvolvimento do algoritimo............................................................................................... 28 
2.2.5 Fluxograma do programa ....................................................................................................... 29 
2.2.6 Estrutura básica do programa ................................................................................................ 30 
2.2.7 Desenvolvimento do programa............................................................................................... 31 
2.2.8 Comentários ........................................................................................................................... 34 
2.3 Programa espiral de Arquimedes .............................................................................................. 35 
2.3.1 O que é uma espiral de Arquimedes ...................................................................................... 35 
2.3.2 Elementos de uma espiral de Arquimedes............................................................................. 35 
2.3.3 Processo de traçado............................................................................................................... 36 
2.3.4 Desenvolvimento do algoritimo...............................................................................................36 
2.3.5 O programa ............................................................................................................................ 37 
2.3.6 Comentários ........................................................................................................................... 38 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 3 
2.4 Programa falsa espiral de dois centros ..................................................................................... 38 
2.4.1 O que é uma falsa espiral de dois centros ............................................................................. 38 
2.4.2 Elementos de uma falsa espiral de dois centros .................................................................... 38 
2.4.3 Processo de traçado............................................................................................................... 39 
2.4.4 Desenvolvimento do algoritimo............................................................................................... 39 
2.4.5 Desenvolvimento do programa............................................................................................... 40 
2.4.7 Comentários ........................................................................................................................... 41 
2.4.8 Animação gráfica.................................................................................................................... 41 
2.4.9 Comentários ........................................................................................................................... 43 
2.5 Programa evolvente do círculo.................................................................................................. 43 
2.5.1 O que é uma evolvente do círculo.......................................................................................... 43 
2.5.2 Elementos de uma evolvente do círculo................................................................................. 44 
2.5.3 Processo de traçado............................................................................................................... 44 
2.5.4 Desenvolvimento do algoritimo............................................................................................... 44 
2.5.5 O programa evolvente do círculo ........................................................................................... 45 
2.5.6 Programa de traçado da evolvente do círculo com animação da reta ................................... 46 
2.5.7 Comentários ........................................................................................................................... 48 
2.6 Programa ciclóide regular.......................................................................................................... 48 
2.6.1 O que é uma ciclóide regular.................................................................................................. 48 
2.6.2 Elementos de uma ciclóide regular ........................................................................................ 48 
2.6.3 Processo de traçado............................................................................................................... 49 
2.6.4 Desenvolvimento do algoritimo............................................................................................... 49 
2.6.6 Desenvolvimento do programa............................................................................................... 49 
2.7 Jogo de tênis ............................................................................................................................. 53 
2.7.1 O problema............................................................................................................................. 53 
2.7.2 Solução do problema.............................................................................................................. 54 
2.7.3 Entendimento da lógica do problema ..................................................................................... 54 
2.7.4 Programa básico .................................................................................................................... 56 
2.7.5 Programação .......................................................................................................................... 57 
2.7.6 Definição do espaço de movimento da bola........................................................................... 57 
2.7.7 Animação................................................................................................................................ 59 
2.7.8 Implementação da raquete..................................................................................................... 65 
 
Capítulo 3 ........................................................................................................................................ 73 
3. Desafios....................................................................................................................................... 73 
3.1 Problemas a serem resolvidos .................................................................................................. 73 
 
BIBLIOGRAFIA................................................................................................................................ 74 
 
ANEXO 1 – Definições matemáticas .............................................................................................. 75 
 
ANEXO 2 – Código do teclado ....................................................................................................... 76 
 
ANEXO 3 – O ambiente do Turbo C ............................................................................................... 77 
 
 
 
 
 
 
 
 
 
 
 
 
 
INTRODUÇÃO 
 
 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 4 
 
Considerando que o aprendizado de um assunto está relacionado ao interesse que o mesmo 
desperta sobre o indivíduo e de como o assunto é apresentado. Também que imagens servem como 
atrativos para despertar a curiosidade para o aprendizado. 
Assim, este trabalho enfoca o uso da computação gráfica como objeto de trabalho para a 
aprendizagem dos princípios de programação em linguagem C. 
 O trabalho inicia com a introdução dos comandos básicos para a programação em linguagem C; 
comandos estes utilizados nos programas exemplo apresentados. Não é a intenção deste trabalho 
descrever um tratado sobre programação em linguagem C, mas mostrar que é possível e fácil de 
aprender a programar. 
 Deste modo, os conteúdos são apresentados na forma de problemas gráficos a serem resolvidos, 
apresentando inicialmente um estudo sobre o problema a ser resolvido e as definições necessárias. 
Posteriormente, é apresentada a solução matemática para o problema, independente do programa de 
computador. 
 Os problemas estudados são os traçados de curvas matemáticas conhecidas, mas que são 
analisadas sobre o enfoque gráfico, baseando-se nos conceitos de desenho geométrico. 
 Juntamente com o trabalho, acompanham os programas executáveis para que o usuário possa 
ver os resultados a serem atingidos ao final do desenvolvimento de cada programa. Os programas 
fontes estão escritos no trabalho, o que obriga o leitor a digitá-los, e consequentemente a conhecer os 
comandos que foram utilizados, complementando assim a forma de aprendizagem. 
 O leitor poderá observar que os programas desenvolvidos, podem ser reutilizados posteriormente 
com algumas alterações para o problema seguinte. 
 Todos os programas são feitos em linguagem C para o ambiente DOS, onde pode-se utilizar o 
compilador TURBO C 3.0, encontrado na internet. 
 Para outras informações e dúvidas a rsspeito desta apostila, pode-se contatactar através do emailnmaziero@terra.com.br. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CAPÍTULO 1 
 
 
 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 5 
 
1 - PROGRAMAÇÃO 
 
 Nos dias atuais, o uso da informática está em todas as atividades humanas, desde atividades 
industriais, comerciais, educacionais e até mesmo dentro de nossas casas, onde vários tipos de 
equipamentos já a utilizam sem que sejam percebidos. 
 Deste modo, é interessante um conhecimento básico de programação para que o indvíduo possa 
entender este assunto como algo possível de ser utilizado, e não algo do outro mundo, que somente 
está acessível aos indivíduos super dotados. 
 Os itens de programação aqui apresentados são aqueles necessários ao entendimento dos 
programas apresentados. 
 Deve-se lembrar que a matemática é uma parte muito importante para o entendimento e 
execução de um programa de computador. 
 
 
1.1 - CONCEITOS BÁSICOS DE PROGRAMAÇÃO 
 
 A programação é um conjunto de instruções, descrita numa linguagem que o sistema operacional 
do computador consegue analisar, e que são executadas sequencialmente, de acordo com o que o 
programador determinou. 
 Para escrever um programa, é necessário conhecer uma linguagem, onde se utiliza um 
compilador para transformar o programa escrito numa linguagem compreensível pelo ser humano, 
numa linguagem dita “linguagem de máquina”. 
 Esta linguagem de máquina é escrita num formato que o computador consegue entender e 
processar rapidamente, mas para o ser humano é difícil. 
 A linguagem de programação é composta por uma série de comandos, que são ordens para a 
execução de determinadas instruções, que são aquelas operações específicas do programa que o 
programador descreve para obter um resultado desejado. 
 Além dos comandos, outro elemento importante são as variáveis, que são responsáveis pelo 
armazenamento das informações, que podem ser numéricas (números inteiros, números reais, etc.) 
e de caracteres (letras e palavras). 
 Na linguagem C, se uma palavra que representa uma variável é escrita em letras minúsculas, e a 
mesma palavra é escrita com a letra inicial maiúscula, elas são consideradas variáveis diferentes. 
 Após cada instrução de programa, deve ser colocado um ponto e vírgula ( ; ). 
 
 
1.2 - TIPOS DE DADOS 
 
 Na linguagem C, há vários tipos de dados como int, float e char, etc. Os tipos de dados irão 
definir os tipos de variáveis que serão utilizadas no programa, o que é feito pelo usuário. A definição 
das variáveis é função específica dos dados utilizados para resolver o problema. 
 
int 
Define uma variável que armazena um número inteiro. Um número inteiro é definido como: 
 int num; num é uma variável inteira. 
 int controle = 2; controle é uma variável inteira e armazena o valor 2. 
 
float 
Define uma variável que armazena um número real. Um número real é definido como: 
 float valores; valores é uma variável real. 
 float numero = 3.23; numero é uma variável real e armazena o valor 3,23. 
 Obs.: Ao escrever um programa com número real, a parte inteira é separa da parte decimal por 
um ponto (.), e não uma vírgula (,). 
 
 
char 
Define uma variável que armazena um caracter, que pode ser uma letra um número, ou uma cadeia 
de caracteres, que é uma palavra. Um char é assim definido: 
 char nome; nome é uma variável que armazena um caracter. 
 char letra = ‘d’; letra é uma variável que armazena um caracter e que é o d. 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 6 
 char numero = ‘5’; numero é uma variável que armazena um caracter e que é o 5. Não é 
interpretado como o número 5, não podendo ser usado para cálculos. 
 char nomes[5] = “joao”; nomes é uma variável que armazena um vetor de caracteres (cinco 
posições), mas no máximo quatro caracteres podem ser colocados. 
 
 
1.3 - OPERAÇÕES ARITMÉTICAS 
 
( = ) Atribuição 
 Este sinal corresponde a atribuir um valor da variável do lado direito do sinal para a variável do 
lado esquerdo. Onde: 
a = b; a variável a assume o valor da variável b, e a variável b ainda permanece com o referido 
valor. 
 
c = 5; a variável c passa a armazenar o valor 5. 
b = c/a; a variável b passa a assumir o valor da divisão da variável c pela variável a. 
x = y = z; as variáveis x e y recebem o valor da variável z. 
 
( + ) Adição 
c = a + b; Executa a adição de duas variáveis, a e b, que são armazenadas em c. 
d = a + b + c; Executa a adição de três variáveis, a, b e c, que são armazenadas em d. 
 
( - ) Subtração 
c = a - b; Executa a subtração de uma variável da outra (a e b), onde o resultado é armazenado em 
c. 
c = a – b - d; Subtrair a variável b da variável a, e deste resultado subtrair a variável d. 
 
( * ) Multiplicação 
c = a * b; Efetua a multiplicação das duas variáveis a e b, sendo o resultado armazenado em c. 
c = a * b * d; Efetua a multiplicação das três variáveis e o resultado é armazenado na variável c. 
 
( / ) Divisão 
c = a / b; Efetua a divisão da variável a pela variável b, sendo o resultado armazenado na variável c. 
 
 No caso da variável que recebe o resultado de uma operação aritmética, esta deve ser do tipo que 
resulta o dado. Uma variável inteira (int) não pode receber um resultado que é uma variável de ponto 
flutuante (float), pois a parte fracionária será suprimida. 
 
 
1.4 - OPERADORES RELACIONAIS 
 
 Os operadores relacionais se utilizam para a análise comparativa entre as variáveis. 
 
( > ) maior que (a > b) O valor da variável a é maior que o da variável b. 
 
( >= ) maior ou igual a (a >= b) O valor da variável a é maior ou igual ao da variável b. 
 
( < ) menor que (a < b) O valor da variável a é menor que o da variável b. 
 
( <= ) menor ou igual a (a <= b) O valor da variável a é menor ou igual ao da variável b. 
 
( == ) igual (a == b) O valor da variável a é igual ao valor da variável b. 
 
( != ) diferente (a != b) O valor da variável a é diferente do valor da variável b. 
 
 
1.5 - OPERADORES DE INCREMENTO E DECREMENTO 
 
( ++ ) Operador de incremento. Adiciona uma unidade a variável inteira j. j++; 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 7 
( -- ) Operador de decremento. Subtrai uma unidade a variável inteira j. j--; 
 
 
1.6 – FUNÇÕES BÁSICAS 
 
 São funções que executam um conjunto de instruções para o programador. Elas fazem parte da 
linguagem de programação utilizada. Na realidade, em diferentes linguagens de programação, os 
nomes das funções básicas são semelhantes. Isto permite extender o aprendizado de uma linguagem 
para outra. 
 
1.6.1 - FUNÇÃO clrscr() 
Este comando limpa a tela quando no formato texto. O formato texto permite apenas que sejam 
escritos caracteres na tela. 
 
1.6.2 - FUNÇÃO printf ( ) 
Permite apresentar na tela um resultado, que pode ser um número ou uma expressão. De acordo com 
o tipo de variável a ser escrita, deve-se especificar na função o seu formato. 
 
Especificação da variável: 
 %d identifica uma variável inteira 
 %f identifica uma variável real 
 %c identifica uma variável caracter 
 %s identifica uma uma variável que tem uma seqüência de caracteres 
 
Caracter de controle: 
 \n nova linha – inicia o texto a ser escrito na linha seguinte 
 
formato: 
printf( < formato> , <var1>, <var2>,...); 
 
<formato> é o campo que especifica a impressão através de uma seqüência de caracteres que inicia 
e termina com aspas. 
 
<var1>,<var2>,... são expressões que serão impressas de acordo com a especificação feita em<formato>. 
 
printf ( “\nescreve o numero real: %f ”,numero ); Antes de imprimir na tela, deve ir para uma nova 
linha \n, imprime o texto escreve o numero real:, onde %f diz que a variável numero é um número 
real (float), e imprime o que estiver armazenado na variável numero. 
 
printf ( “ escreve o numero inteiro: %d \n”,numeroInteiro ); onde %d diz que a variável 
numeroInteiro representa um número inteiro (int). Depois de escrever deve pular para nova linha 
(\n), e imprime o que estiver armazenado na variável numeroInteiro. 
 
printf ( “ escreve caracteres: %s ”,nome ); onde %s diz que a variável nome representa um 
caracter (char) ou uma cadeia de caracteres ( char [ ] ). Escreve sem mudar de linha o que estu\iver 
armazenado na variável nome. 
 
1.6.3 - FUNÇÃO getch ( ) 
A função lê um caracter introduzido pelo teclado. Ao encontrar este comando, o programa para 
esperando que seja introduzido uma informação pelo teclado, por apenas um toque. O valor da tecla é 
capturado pela função, donde pode-se escrever: 
char Letra; 
Letra = getch ( ); O que permite que seja capturado o valor da tecla e transferido para a variável 
Letra. 
Ou simplesmente getch( ); para interromper o programa a espera do toque em uma tecla para 
continuar. 
 
// 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 8 
A colocação de duas barras em seqüência, é interpretado que o que está escrito após as duas barras, 
e na mesma linha, não seja interpretado pelo programa. Utiliza-se para a colocação de comentários 
no programa, ou o cancelamento de partes do programa que não serão usados mas é interessante 
que estejam no arquivo do programa. 
 
 Digite o programa a seguir e rode no compilador para ver o resultado (ver anexo 3). 
Programa exemplo 1 
 
#include <stdio.h> //cabeçario necessário para identificar os comandos utilizados. 
#include <conio.h> 
void main() // indica a função principal 
{ 
float numero = 3.8; 
int numeroInteiro = 5; 
char nome = ‘h’; 
char nomeCompleto[5] =“joao”; 
 
clrscr(); // limpa a tela 
 
printf ( “escreve o numero real: %f ”,numero ); 
printf ( “ \n escreve o numero inteiro: %d ”,numeroInteiro ); 
printf ( “ \n escreve caracter: %c ”,nome ); 
printf ( “ \n escreve nome completo: %s ”,nomeCompleto ); 
getch(); 
} // termino da funcao principal 
 
 
resultado: 
escreve o numero real: 3.8 
escreve o numero inteiro: 5 
escreve o caracter: h 
escreve nome completo: joao 
 
1.6.4 - FUNÇÃO scanf ( ) 
Permite ler um conjunto de informações introduzidas pelo teclado. 
 
formato: 
scanf(<formato>,<end1>,<end2>,...); 
 
<formato> a especificação é semelhante ao printf( ); 
 
<end1>,<end2>,... correspondem aos endereços onde os dados devem ser lidos. 
 
int num; 
printf ( “tecle um numero”); 
scanf ( “%d”,&num); (informa o tipo de dado, captura o endereço da variável) 
O símbolo & na frente da variável permite que o programa leia o endereço da memória onde está 
armazenado o valor da variável. 
 
Programa exemplo 2 
 
#include <stdio.h> 
#include <conio.h> 
void main() 
{ 
float numero; 
int numeroInteiro; 
char nome; 
char nomeCompleto[10]; 
 
clrscr(); // limpa a tela 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 9 
printf ( “ Digite um numero real: ” ); 
scanf ( “ %f”, &numero); 
printf ( “ Digite um numero inteiro: ” ); 
scanf ( “ %d”, &numeroInteiro); 
printf ( “ Digite um caracter: ” ); 
nome = getch(); 
printf ( “ \n Digite até 9 caracteres : ” ); 
scanf ( “ %s”, &nomeCompleto ); 
 
printf ( “\n\n O numero real e: %f ”,numero ); 
printf ( “ \n O numero inteiro e: %d ”,numeroInteiro ); 
printf ( “ \n O caracter e: %c ”,nome ); 
printf ( “ \n A sequencia de caracteres e: %s ”,nomeCompleto ); 
 
getch(); 
} 
 
resultado: 
Digite um numero real: 5.2 ( tecle o número 5.2 e tecle Enter) 
Digite um numero inteiro: 3 (tecle o número 3 e tecle Enter) 
Digite um caracter: a (tecle o caracter a e tecle Enter) 
Digite ate 9 caracteres: abcdefghi (tecle os caracteres abcdefghi e tecle Enter) 
 
O numero real e: 5.2 
O numero inteiro e: 3 
O caracter e: a 
A sequencia de 9 caracteres e: abcdefghi 
 
1.6.5 - FUNÇÃO for( ) 
Permite que uma instrução ou um grupo de instruções seja executado um determinado número de 
vezes que é especificado. O número de vezes que as instruções devem ser executadas deve ser 
conhecido exatamente. 
 
int i; 
for(i=0;i<10;i++){printf(“\nola!);} 
 
Esta instrução diz para o comando for executar um laço com o que está dentro das chaves, iniciando 
o contador i=0; até que o contador i seja menor que dez (i<10), e a cada volta no laço acrescentar o 
valor um no contador i (i++). A palavra ola! será escrita dez vezes uma abaixo da outra. 
 O programa exemplo 3 faz com que o valor do contador i seja multiplicado por 2 a cada laço 
executado eplo comando for( ). 
 
printf("\n i*2 = %d",i*2)
for (i=0; i<10 i++)
 
Programa exemplo 3 
 
#include <stdio.h> 
#include <conio.h> 
 
void main ( ) 
{ 
int i; 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 10 
clrscr(); 
for (i=0; i<10; i++) 
{ 
printf(“\n i*2= %d”,i*2 ); 
} 
getch(); 
} 
 
resultado: 
i*2= 0 
i*2= 2 
i*2= 4 
i*2= 6 
i*2= 8 
i*2= 10 
i*2= 12 
i*2= 14 
i*2= 16 
i*2= 18 
 
1.6.6 - FUNÇÃO while( ){ ... } 
Permite que uma instrução ou um grupo seja executado um certo número de vezes, enquanto uma 
determinada condição não ocorra. O teste é feito no início do laço. Comando utilizado quando não se 
conhece o número de interações a ser realizado. O comando testa a condição inicial entre parentesis 
e se for válida realiza os comandos que estão entre chaves {...}. 
 
j++
j=0
while(j<10)
printf("ola!")
 
Programa exemplo 4 
 
#include <stdio.h> 
#include <conio.h> 
 
void main ( ) 
{ 
int j=0; 
 
clrscr(); 
while( j<10) 
{ 
printf ( “ olá! ” ); 
j++; 
} 
getch(); 
} 
 
resultado: 
ola! ola! ola! ola! ola! ola! ola! ola! ola! ola! 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 11 
 Nesta aplicação, o comando while() fica repetindo a expressão ola enquanto a variável j tem um 
valor menor que dez (j<10). A cada repetição, j é incrementado de um (j++;), sendo que j inicia com 
valor zero. Se a variável j fosse igual a 10 (j=10), seria impresso apenas uma vez. Como no comando 
printf() não há o caracter de controle \n, o resultado é impresso lado a lado. 
 
1.6.7 - FUNÇÃO do { ... } while( ) 
Permite que uma instrução ou um grupo de instruções seja executado um determinado número de 
vezes, enquanto uma determinada condição não ocorra. O teste é feito no final do laço. Comando 
utilizado quando não se conhece o número de interações a ser realizado. Inicialmente são executados 
os comando que estão entre chaves {...}, e depois é realizado o teste do comando. 
 
j=0;
do
printf("ola!");
j++;
while(j<10)
 
 
Programa exemplo 5 
 
#include <stdio.h> 
#include <conio.h> 
 
void main ( ) 
{ 
int j=0; 
 
clrscr(); 
do 
{ 
printf(“ olá!”); 
j++; 
} while( j<10); 
getch(); 
} 
 
resultado: 
ola! ola! ola! ola! ola! ola! ola! ola! ola! ola! 
 
 Nesta aplicação, o comando while() fica repetindo a expressão olá enquanto a variável j tem um 
valor menor que dez ( j<10 ). A cada repetição, j é incrementado de um, sendo que j inicia com valor 
zero. Se a variável j fosse igual a 10 (j=10), não seria impresso nada. 
 
1.6.8 - FUNÇÃO if ( ){...} ... else{...} 
Permite executar testes comparativos entre variáveis. 
 
if ( x > y) {printf( “o valor de X é maior que o valor de Y”);} 
 else { printf ( “o valor de Y é menor que o valor de X”);} 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 12 
 A instrução if( ) compara as variáveis X e Y. Se X é maior que Y, condição verdadeira, as 
instruções seguintes dentro das chaves {...} são executadas e ignora a opção else. 
 Se o resultado da comparação é que Y é maior que X, a instrução seguinte é ignorada e passa 
para a instrução else, que será executado o que estiver dentro das chaves {...}. As instruções 
executadas diretamente pelo if ou else, são identificadas pelo conjunto de chaves. 
 Depois do if( ) e dentro dos parenteses, podem se colocadas quaisquer tipos de comparação. 
 
if
...
else{...}
{...}
 
Programa exemplo: 
 
#include <stdio.h> 
#include <conio.h> 
 
void main ( ) 
{ 
int x =10, y = 5; 
 
clrscr(); 
if ( x > y) {printf ( “\n O valor de X é maior que o valor de Y.”);} 
 else { printf ( “\n O valor de Y é menor que o valor de X.”);} 
x=5; y=10; 
if ( x > y) {printf ( “\n Agora o valor de X é maior que o valor de Y.”);} 
 else { printf ( “\n Agora o valor de Y é menor que o valor de X.”);} 
getch(); 
} 
 
resultado: 
O valor de X é maior que o valor de Y. 
Agora o valor de Y é menor que o valor de X. 
 
1.6.9 - FUNÇÃO delay(int) 
Esta função faz com que o programa pare um determinado tempo. Este valor de tempo é medido em 
milisegundos (1/1000 segundo), um segundo dividido em mil partes. Para que o programa pare 
durante meio segundo, deve-se escrever: delay(500);. 
Esta função pertence ao #include <dos.h>. 
 
 
 
1.6.10 - FUNÇÃO double sqrt( double x ) 
Obtém o resultado da raiz quadrada de um número real de dupla precisão. Também pode ser 
colocada uma expressão matemática. Do resultado desta expressão será extraída a raiz quadrada, 
que é um número real de dupla precisão. 
sqrt( 16 ); Extrai a raiz quadrada do número 16. 
sqrt( a + b); Extrai a raiz quadrada do resultado da adição das variáveis a e b. 
 
1.6.11 – FUNÇÃO double sin( double x ) (Anexo 1) 
Resulta no valor do seno de uma variável x, que é um número real de dupla precisão, resultando 
como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. 
sin(10); obtém o valor do seno de 10 (valor em radianos). 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 13 
sin(a + b); Resulta no valor do seno da soma das variáveis a e b. 
 
1.6.12 – FUNÇÃO double cos( double x ) (Anexo 1) 
Resulta no valor do cosseno de uma variável x, que é um número real de dupla precisão, resultando 
como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. 
cos(10); obtém o valor do cosseno de 10 (valor em radianos). 
cos(a + b); Resulta no valor do cosseno da soma das variáveis a e b. 
 
1.6.13 – FUNÇÃO double tan( double x ) (Anexo 1) 
Resulta no valor da tangente de uma variável x, que é um número real de dupla precisão, resultando 
como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. 
tan(10); obtém o valor da tangente de 10 (valor em radianos). 
sin(a + b); Resulta no valor do seno da soma das variáveis a e b. 
 
1.6.14 – FUNÇÃO double asin( double x ) 
Resulta no valor do arco seno de uma variável x, que é um número real de dupla precisão, resultando 
como valor um número real de dupla precisão. 
asin(10); obtém o valor do arco seno de 10, resultando no valor do ângulo em radianos. 
asin(a + b); Resulta no valor do arco seno da soma das variáveis a e b. 
 
1.6.15 – FUNÇÃO double acos( double x ) 
Resulta no valor do arco cosseno de uma variável x, que é um número real de dupla precisão, 
resultando como valor um número real de dupla precisão. 
acos(10); obtém o valor do arco cosseno de 10, resultando no valor do ângulo em radianos. 
acos(a + b); Resulta no valor do arco cosseno da soma das variáveis a e b, valor resultante é do 
ângulo em radianos. 
 
1.6.16 – FUNÇÃO double atan( double x ) 
Resulta no valor do arco tangente de uma variável x, que é um número real de dupla precisão, 
resultando como valor um número real de dupla precisão. 
atan(10); obtém o valor do arco tangente de 10, resultando no valor do ângulo em radianos. 
atan(a + b); Resulta no valor do arco seno da soma das variáveis a e b, valor resultante é do ângulo 
em radianos. 
 
Obs.: Ver no anexo 1, as definições matemáticas das funções acima. 
 
 
1.7 - CONSTRUÇÃO DE FUNÇÕES DO USUÁRIO 
São utilizadas quando é necessário repetir em vários trechos do programa o mesmo conjunto de 
instruções. Deste modo, este conjunto de instruções é transformado numa função e chamado sempre 
que necessário. 
float quad ( float x) 
{ 
return ( x * x ); 
} 
 
Esta função recebe a variável x, e multiplica por ele mesmo, resultando no quadrado do respectivo 
número, e devolvendo o resultado. A palavra float, antes do nome da função quad, indica que a 
função devolve um valor que é um número real. A expressão float x, indica que a função deve 
receber um valor que é um número real, que passa para dentro da função através da variável x. A 
expressão return, devolve o resultado do que estiver dentro do parentesis. 
Logo, pode-se escrever: 
 
float resultado; 
resultado = quad (5 ); Onde o resultado é o valor de 25. 
 
 
1.8 - INTERFACE GRÁFICA 
 A interface gráfica permite que sejam executados desenhos através do computador. Para isso, a 
interface deve ser inicializada através de algumas instruções adequadas. 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 14 
 Por exemplo, deve ser colocado um include especial no programa: #include <graphics.h>, que 
permite que as instruções gráficas possam ser interpretadas, transformando a tela para formato 
gráfico. A tela no formato gráfico é definida como tendo 640x480 pixels, que são pontos na tela que 
podem ser acesos. 
 O sistema de coordenadas da tela gráfica é igual ao sistema de coordenadas cartesiano, 
possuindo os eixos X e Y. Porém, possui algumas alterações. Por exemplo, a origem está 
posicionada no canto esquerdo superior, sendo o eixo X positivo da esquerda para a direita. Já o eixo 
Y positivo, de cima para baixo (figura 1.1). 
 
X
Y
(x1,y1)
(x2,y2)
x1
y1
640 pixels
48
0 
pi
xe
ls
reta
raio
(x3,y3)
 
Figura 1.1 - Representação da tela gráfica. 
 
 O trecho de programa descrito a seguir, é o responsável pela inicialização do ambiente gráfico do 
compilador C (TURBO C 3.0). Se o teste if(errorcode != grOk), resultar num valor diferente de grOk, 
que identificou corretamente os arquivos, o programa, emite mensagens a respeito do erro. 
 No caso de erro, normalmente é a falta do arquivo egavga.bgi, que possui as informações 
gráficas. Sendo que o compilador não conhece o caminho (path) de onde ele está. É necessário 
indicar através da seqüência Options-Linker-Libraries e assinalar Graphics Library, no editor do 
TURBO C. 
 
 
//=================== inicializa ambiente grafico ============== 
gdriver=DETECT; 
initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); //inicialização com a indicação do caminho 
errorcode=graphresult(); 
if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1);// retorna codigo de erro 
 } 
//========================================================= 
 
 
1.9 – FUNÇÕES GRÁFICAS 
Alguns destes comandos são apresentados a seguir: 
 
FUNÇÃO line (x1,y1,x2,y2 ) 
 Permite o traçado de uma reta conhecendo-se as coordenadas do ponto inicial(x1,y1) e do ponto 
final (x2,y2). Estes pontos tanto podem ser variáveis do tipo int ou float (figura 1.1). 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 15 
 
(x1,y1)
(x2,y2)
 
 
FUNÇÃO circle ( x,y,r ) 
 Permite traçar um circulo, conhecendos-se as coordenadas do centro (x,y) e o valor do raio r. 
Estes pontos tanto podem ser variáveis do tipo int ou float (figura 1.1). 
 
 
raio
(x,y)
 
 
FUNÇÃO setcolor( int ) 
 Este comando permite que a cor da linha seja alterada, para isso pode ser passada o nome da cor 
ou seu numero inteiro (int) correspondente. As cores podem ser indicadas por números ou palavras 
como descrito a seguir: 
BLACK
BLUE
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
LIGHTRED
YELLOW
WHITE
Comando Cor
14 White
Yellow13
12 Light Red
Light Cyan11
10 Light Green
9 Light Blue
Dark Gray8
Light Gray7
Brown6
Magenta5
4 Red
3 Cyan
Green2
Blue1
Black0
# Nome da cor
 
pode-se escrever: setcolor(YELLOW); ou setcolor(14); 
 
FUNÇÂO setbkcolor(int) 
Função que seleciona a cor de fundo da tela. O número inteiro pode ser entre 0 e 15, ou o nome da 
cor. 
 
FUNÇÂO settextstyle(int fnt,int dir,int tc) 
Esta função permite configurar os valores para os atributos do texto visualizado em tela gráfica. 
 
fnt indica o estilo de fonte do texto; 
 
dir direção em que a fonte deve ser escrita. Na horizontal ou vertical. 
 
tc Tamanho do caracter visualizado na tela 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 16 
As tabelas abaixo indicam os valores destas variáveis. 
 
# fnt Nome Fonte de texto 
0 DEFAULT_FONT Mapa de bits 8x8 
1 TRIPLEX_FONT Triplex 
2 SMALL_FONT Small 
3 SANS_SERIF_FONT Sans-serif 
4 GOTHIC_FONT Gothic 
5 SCRIPT_FONT Script 
6 SIMPLEX_FONT Simplex 
7 TRIPLEX_SCR_FONT Triplex-script 
8 COMPLEX_FONT Complex 
9 EUROPEAN_FONT European 
10 BOLD_FONT Bold 
 
 
 
# dir Nome Direção 
0 HORIZ_DIR Esquerda para a direita 
1 VERT_DIR De baixo para cima 
 
 
 
 
Valor de tc Efeito em outtext/outtextxy 
0 Ampliação da fonte (stroked) usando fator de 
ampliação default de caracteres (4) ou o tamanho do 
caractere definido pelo usuário (dado por 
setusercharsize) 
1 Visualização de caracteres da fonte 8x8 (bit-mapped) 
em um retângulo da tela contendo 8x8 pixels 
2 Visualização de caracteres da fonte 8x8 (bit-mapped) 
em um retângulo da tela contendo 16x16 pixels 
3 Visualização de caracteres da fonte 8x8 (bit-mapped) 
em um retângulo da tela contendo 24x24 pixels 
...... ............... 
10 Visualização de caracteres da fonte 8x8 (bit-mapped) 
em um retângulo da tela contendo 80x80 pixels 
 
 
FUNÇÃO putpixel(int x, int y, int cor) 
Função que coloca um pixel na tela nas coordenadas (x,y) e acordo com a cor desejada. 
 
 
FUNÇÃO setlinestyle(int style, unsigned pattern, int thickness) 
Função de configuração do tipo de linha e da espessura 
Style – estilo, pode ser dado de acordo c om a tabela abaixo. 
DescriçãoNome#
_ _ _ _ _ _
_..._..._..._
...............
Efeito
Linha definida pelo usuárioUSERRBIT_LINE4
Linha tracejadaDASHED_LINE3
Linha tracejada pontilhada2 CENTER_LINE
Linha pontilhadaDOTTED_LINE1
Linha cheia0 SOLID_LINE
 
 
Thickness – espessura, varia com a quantidade de pixels. 
 
# Nome Descrição 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 17 
1 NORM_WIDTH Espessura de 1 pixel 
3 THICK_WIDTH Espessura de 3 pixels 
 
 
FUNÇÃO closegraph( ) 
Função responsável pela finalização do ambiente gráfico e retorno à tela normal, tela de texto. 
 
 
1.10 - PROGRAMA PARA O DESENHO DE UMA RETA E UM CÍRCULO 
 
 O programa a seguir permite executar o desenho de uma reta e de um círculo, onde as 
coordenadas de cada um podem ser alteradas para verificar os resultados. 
 
//Nome do arquivo DESENHA.C 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
//============================================================= 
void main() //define a funcao principal 
{ 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
//=================== final das variaveis do programa=========== 
 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1); // retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
setcolor(YELLOW); //desenha em amarelo 
line(100,200,400,350); //desenha uma reta 
setcolor(RED); //desenha em vermelho 
circle(90,150,50); //desenha um circulo 
//===================== final do programa propriamente dito ============ 
getch(); // espera que seja tocada uma tecla 
closegraph(); //fecha o modo gráfico 
} 
//==================== final do arquivo ============================ 
 
 
1.11 Interpretação do código 
 
 Este conjunto de instruções abaixo, corresponde a informação ao compilador dos arquivos 
necessários ao funcionamento do programa 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#include <dos.h> 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 18 
 
 A função void main(), corresponde ao programa propriamente dito. As instruções escritas entre 
as duas chaves definirão o programa. 
 
void main() 
{//1 
............ 
............ 
}//1 
 
 A seguir há um espaço onde são definidas as variáveis utilizadas no programa para a identificação 
do ambiente gráfico. As variáveis são definidas como números inteiros, int. 
 
//================= definicao das variaveis ================ 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
 No espaço a seguir, estão definidas as variáveis utilizadas no programa, isto por uma questão de 
organização, pois na linguagem C, as variáveis podem ser criadas em qualquer parte do programa. 
 
//============ variaveis do programa ====================== 
 
//========== final das variaveis do programa ================== 
 
 O conjunto de instruções a seguir permite inicializar o ambiente gráfico, de modo a localizar os 
arquivos necessários ao programa. Se forem encontrados os arquivos gráficos, o programa 
funcionará normalmente. Do contrário apresentará mensagens na tela como estas: 
 
 Erro do adaptador grafico 
 Falta o arquivo EGAVGA.BGI 
 Pressione alguma tecla para retornar: 
 
//========== inicializa ambiente grafico ===================== 
 gdriver = DETECT; 
 initgraph(&gdriver, &gmode, "c:\\borlandc\\bgi"); 
 errorcode = graphresult(); 
 if (errorcode != grOk) 
 { 
 printf(" Erro do adaptador grafico \n"); 
 printf("Falta o arquivo EGAVGA.BGI\n "); 
 printf("Pressione alguma tecla para retornar:"); 
 
 getch(); 
 exit(1); // retorna codigo de erro 
 } 
 
 Neste próximo espaço, será escrito o programa propriamente dito. 
 
//============inicia o programa propriamente dito ========== 
 
//========== final do programa propriamente dito ============= 
 
 
Nas últimas linhas, o programa espera que seja tocada qualquer tecla, finalizando o ambiente gráfico 
e o programa. 
 
getch(); 
closegraph(); 
 return 0; 
}//1//================ final do arquivo ==================== 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 19 
 
Comentários: 
 O programa desenha uma reta e um cículo, apresentando o formato de como deve ser escrito um 
programa gráfico. 
 Na primeira linha do programa está escrito: //Nome do arquivo DESENHA.C, que é 
interpretado como um comentário pelo compilador devido as duas barras inclinadas (//), e apenas 
indica o nome do programa. 
 Nas linhas a seguir, estão os #include, que especificam os arquivos do compilador C que devem 
ser agregados ao programa para que o compilador possa interpretar as instruções escritas. As linhas 
escritas em negrito correspondem ao programa propriamente dito. 
 
Resultado 
 Após rodar o programa, aparecerá como resultado o desenho de uma reta em amarelo e de um 
círculo em vermelho. Experimente alterar o valor das coordenadas nas funções line(), circle() e 
setcolor(); comparando os resultados obtidos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CAPÍTULO 2 
 
 
 
 
2. APLICAÇÕES 
 Neste capítulo são implementadas as aplicações gráficas que envolvem a definição do problema, 
busca da solução, e a solução final que é o programa. 
 
2.1 - PROGRAMA PARÁBOLA 
 O desenho da parábola a ser desenvolvido é baseado no traçado gráfico que considera que um 
ponto (P) sobre a parábola possui a mesma distância ao foco e a diretriz (figura 2.1 (b)). 
 
2.1.1 - O que é uma parábola 
 Uma parábola é uma curva plana infinita resultante da seção de um cone reto por um plano 
paralelo a uma das geratrizes (figura 2.1 (a)). 
 A parábola é o lugar geométrico dos pontos de um plano cuja relação entre a distâncias de cada 
ponto P da curva ao foco F e à diretriz é equidistante (igual) (figura 2.1(b)). 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 20 
 
F
P
D
IR
ET
R
IZ
 (a) (b) 
Figura 2.1 - Cone truncado por um plano paralelo a uma geratriz; desenho da parábola. 
 
2.1.2 - Elementos de uma prábola 
 Uma parábola é composta por vários elementos. Os mais importantes para o desenvolvimento do 
problema são descritos a seguir (figura 2.2): 
 
a) Diretriz: Reta perpendicular ao eixo. 
b) Eixo: Segmento de reta que contém o vértice e o foco da parábola. 
c) Parâmetro: distância da diretriz ao foco. 
d) Foco (F): centro da curva. 
d) Vértice (V): ponto de cruzamento da curva com o eixo. 
e) Raios vetores: distância do foco ao ponto P da curva e da diretriz ao ponto P da curva. 
 
Obs.: Numa parábola deve ser observada a seguinte condição de distância entre o ponto P da curva 
com o foco F e a diretriz. FP = Pdiretriz (figura 2.2). 
 
F
P
diretriz
eixo
foco
vértice
raio vetor
parâmetro
 
Figura 2.2 - Elementos de uma parábola. 
2.1.3 - Processo de traçado 
 A parábola inicia-se com o traçado do eixo e da diretriz, que são perpendiculares entre si (ângulo 
de 90°). Após, deve-se marcar o vértice (V) da parábola e o foco (F). Sendo que o vértice está 
localizado no ponto médio da distância entre o foco e a diretriz (figura 2.3 (a)). 
 Como a distância de um ponto (P) da curva ao foco deve ser igual à distância do mesmo ponto 
(P) à diretriz, deve-se traçar retas paralelas a diretiz a partir do vértice da parábola. A distância entre 
as paralelas é arbitrária e, de preferência, que sejam iguais para facilitar o traçado. 
 O próximo passo consiste em pegar a distância (d) (figura 2.3(a)) entre a diretriz e a primeira 
paralela, com o compasso, e colocar a ponta seca do compasso no foco e traçar um arco que corte a 
primeira paralela. 
 A seguir pegar a distância da diretriz (d1) (figura 2.3(b)) até a segunda paralela. Colocar a ponta 
seca do compasso no foco e traçar arco para interseptar a segunda paralela, acima e abaixo do eixo. 
 Novamente pegar a distância da diretriz (d2) (figura 2.3(c)) até a terceira paralela. Colocar a ponta 
seca do compasso no foco e traçar arco para interseptar a terceira paralela, acima e abaixo do eixo. 
 Repetindo este procedimento, obtém-se os pontos por onde passa a parábola. A curva é então 
traçada a mão (figura 2.3(d)). 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 21 
FV
d
d
d
FV
d
d
d
d1
d1
d1
V F
d1
d
d1
d
d1
d
d2
d2
d2 d2
FV
d1
d1
d
d
d2
d1
d
d2
(a) (b) (c) (d)
 
Figura 2.3 - Processo de traçado da parábola 
 
2.1.4 - Desenvolvimento do algoritmo 
 
 Considerando a curva traçada, e analizando um ponto P(x,y) qualquer da curva (figura 2.4), pode-
se verificar que a distância X da diretriz até ponto P(x,y), será exatamente a distância do foco F até o 
ponto P(x,y), onde (X = R). 
 A coordenada Y deste ponto é resultante da dimensão do cateto maior do triângulo, e Dx, o cateto 
menor, será função da diferença entre a coordenada X e a distância do foco DF (figura 2.4). 
 
Assim, a distância do vértice até a diretriz é dada por: DV
DF
=
2
 
Dx DF x= −| |, sendo o resultado em módulo. logo, Y R Dx= −2 2 
 
Considerando (xo,yo) como pontos de referência do sistema, tem-se as coordendas dos seguintes 
pontos: 
 
V (xo + DF/2, yo) 
F (xo + DF, yo) 
P (x, y) 
 
Assim: 
P(x) = xo + DV + Dx P(y) = yo + Y 
sendo DeltaX um incremento para descrever a curva. 
 
V F
X Y
R
Dx
DF
xo,yo
P(x,y)
 
Figura 2.4 - Modelo geométrico para definição do modelo matemático. 
 
 
2.1.5 – FLUXOGRAMA LÓGICO DO PROGRAMA 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 22 
 O fluxograma descreve a lógica do programa, onde os retangulos descrevem as instruções e os 
losangos os comandos de teste (if()) (figura 2.5). 
 
STocou
alguma
tecla?
Desenha um trecho da curva
entre dois pontos
Calcula a posição do ponto
P(x,y) da curva
Desenha a diretriz e o eixo
incrementa X
Armazena coordenadas
X e Y
controle=1
N
S
controle>0
N
fim
Parâmetros da parábola:
início
 
Figura 2.5 - Fluxograma do programa parábola. 
 
2.1.6 - O programa básico 
 O programa apresentado a seguir é uma estrutura que servirá para o desenvolvimento de todos 
os programas deste trabalho. A partir destes conceitos, serão implemtados os programa, sendo 
acrescentadas novas funções e instruções, e a cada novidade, na evolução de um programa, serão 
escritos em negrito para salientar. 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
//======================================================== 
void main()//define a funcao principal 
{ 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
//=================== final das variaveis do programa=========== 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 23 
 getch(); 
 exit(1);// retorna codigo de erro 
 } 
//============= inicia o programa propriamente dito =========== 
 
//========== final do programa propriamente dito =========== 
getch(); 
closegraph(); //fecha o formato grafico 
} 
//============= final do arquivo ================2.1.7 - O programa parábola - versão 1 
 A versão 1, é o programa básico acrescido das novas instruções para que sejam desenhados a 
diretriz, o eixo e o foco da parábola. 
 
//PROGRAMA PARABOLA.C 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
//============================================================= 
void main() //define a funcao principal 
{ 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
float xo=50; //coordenada inicial X – cruzamento diretriz-eixo 
float yo=240; //coordenada inicial Y – cruzamento diretriz-eixo 
float distanciaFocal=30; // DF 
float focoX=xo+distanciaFocal; //coordenada X do foco 
float focoY=yo; //coordenada Y do foco 
//=================== final das variaveis do programa=========== 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1); // retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
line(xo-50,yo,xo+680,yo); //desenha a diretriz 
line(xo,yo-240,xo,yo+240); //desenha o eixo 
circle(focoX,focoY,2); //desenha o foco 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph();//fecha o formato grafico 
} 
//==================== final do arquivo ================================== 
 
Comentários 
 Após compilar e rodar o programa (ctrl-F9), basta tocar uma tecla para que o mesmo volte para o 
editor. Neste programa somente apareceu a estrutura para a construção da parábola, o eixo e a 
diretriz. 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 24 
2.1.8 - O programa parábola - versão 2 
 Na versão 2, são acrescentadas as funções e variáveis para que seja desenhado ramo acima do 
eixo da parábola. 
 
//PROGRAMA PARABOLA.C 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//============================================================= 
float quad(float x) // funcao para elevar ao quadrado um numero armazenado na variável X 
{ 
return (x*x); 
} 
//============================================================= 
void main() //define a funcao principal 
{ 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
float xo=50; //coordenada X inicial 
float yo=240; //coordenada Y inicial 
float distanciaFocal=30; 
float focoX=xo+distanciaFocal; //coordenada X do foco 
float focoY=yo; //coordenada Y do foco 
float x=xo+(distanciaFocal/2); //coordendada X inicial do ponto P da curva 
float y=yo; //coordendada Y inicial do ponto P da curva 
float xOld=x; // armazena a coordenada anterior X 
float yOld=y; // armazena a coordenada anterior Y 
float Dx; // Incremento de X 
//=================== final das variaveis do programa=========== 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1); // retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
line(xo-50,yo,xo+680,yo); //desenho da diretriz 
line(xo,yo-240,xo,yo+240); //desenho do eixo 
circle(focoX,focoY,2); //desenho do foco 
 
while(!kbhit( )) 
{ 
x=x+1; 
Dx=abs(focoX-x); //calcula o novo valor de Dx 
y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y acima do eixo 
 
setcolor(YELLOW); //muda a cor para amarelo 
line(xOld,yOld,x,y); //desenha um trecho da curva acima do eixo 
 
xOld=x; //armazena a coordenada X 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 25 
yOld=y; // armazena a coordenada Y 
 
delay(10); //o programa para por 10 milisegundos 
 
} 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph(); 
} 
//==================== final do arquivo ================================== 
 
Comentários 
 Nesta outra versão, foi introduzido o comando while( !kbhit( ) ), que faz com que o programa 
fique num laço até que seja tocada uma tecla para então sair. 
Os novos includes: 
 #include <math.h> é devido ao uso da função matemática sqrt(). 
 #include <dos.h> é devido ao uso da função matemática delay(). 
 
2.1.9 - O programa parábola - versão 3 
 Na versão 3, são acrescentadas as funções e variáveis para que seja desenhado ramo abaixo do 
eixo da parábola (figura 2.6). 
 
//PROGRAMA PARABOLA.C 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//============================================================= 
float quad(float x) // funcao para elevar ao quadrado um numero aramzenado na variável X 
{ 
return (x*x); 
} 
//============================================================= 
void main() //define a funcao principal 
{ 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
float xo=50; //coordenada X inicial 
float yo=240; //coordenada Y inicial 
float distanciaFocal=30; 
float focoX=xo+distanciaFocal; //coordenada X do foco 
float focoY=yo; //coordenada Y do foco 
float x=xo+(distanciaFocal/2); //coordendada X inicial do ponto P da curva 
float y=yo; //coordendada Y inicial do ponto P da curva 
float xOld=x; // armazena a coordenada anterior X 
float yOld=y; // armazena a coordenada anterior Y 
float Dx; // Incremento de X 
float xold=x; // armazena variavel X para desenhar abaixo do eixo 
float yold=y; // armazena variavel Y para desenhar abaixo do eixo 
//=================== final das variaveis do programa=========== 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 26 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1);// retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
line(xo-50,yo,xo+680,yo); //desenho da diretriz 
line(xo,yo-240,xo,yo+240); //desenho do eixo 
circle(focoX,focoY,2); //desenho do foco 
 
while(!kbhit( )) 
{ 
x=x+1; 
Dx=abs(focoX-x); //calcula Dx 
y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y acima do eixo 
 
 
setcolor(YELLOW); //muda a cor para amarelo 
line(xOld,yOld,x,y); //desenha um trecho da curva acima do eixo 
 
xOld=x; //armazena a coordenada X 
yOld=y; // armazena a coordenada Y 
 
y=yo+sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y abaixo do eixo 
line(xold,yold,x,y); //desenha a curva abaixo do eixo 
 
xold=x; 
yold=y; 
 
delay(10); //o programa para por 10 milisegundos 
} 
 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph();} 
//==================== final do arquivo ================================== 
 
2.1.10 - Comentários 
 Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a 
seguir: 
float xo=80; //coordenada X inicial 
float yo=240; //coordenada Y inicial 
float distanciaFocal=70; 
 Como resultado, surgirá uma parábola diferente. As variáveis xo e yo, permitem mudar a posição 
que a parábola será desenhada. A variável distanciaFocal, permite alterar a forma da parábola. 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 27 
 
Figura 2.6 – Desenho resultante na tela. 
 
 
2.2 - PROGRAMA ELIPSE 
 
 O programa elipse apresenta o desenho de uma elipse. O algoritimo é desenvolvido baseado no 
processo dos circulos concêntricos. 
 
 
2.2.1 - O que é uma elipse 
 Uma elipse é uma curva plana fechada resultante da secção de um cilindro reto por um plano 
oblíquo a base do cilindro (figura 2.7(a)). Também pode ser obtida pela seção de um cone reto por um 
plano oblíquo a base (figura 2.7(b)). 
 
ELIPSE
 
Figura 2.7 - Obtenção da elipse por secção de um sólido (a) cilindro - (b) cone. 
 
 
2.2.2 - Elementos de uma elipse 
 Uma elipse possui vários elementos a serem identificados para executar a sua representação 
gráfica. Aqui são apresentados os mais importantes, que são (figura 2.8): 
 
a) Diâmetro maior: Também chamado de eixo maior (distância AB ). 
b) Diâmetro menor: Também chamado de eixo maior (distância CD). Os diâmetros maior e menor são 
perpendiculares entre sí. 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 28 
c) Vértices: Extremidades dos diâmetros maior e menor (pontos A, B C e D). 
d) Centro: Interseção dos diâmetros maior e menor (ponto O). 
e) Focos: Centro dos raios vetores. A elipse tem dois focos (F e F’). 
e) Raios vetores: Distância do foco a um ponto da curva (ponto P). Assim, pode-se escrever: AB = FP 
+ F'P. 
 
A B
C
D
F F'O
P
 
Figura 2.8 - Elementos da elipse. 
 
2.2.3 - Processo dos circulos concêntricos 
 O processo dos circulos concêntricos é um dos processos gráficos utilizado para desenhar uma 
elipse com instrumentos (figura 2.9). 
 Os dois circulos concêntricos correspondem aos círculos traçados tendo como centro o centro da 
elipse e o raio da circunferência externa a metade do diâmetro maior e o da circunferência interna a 
metade do diâmetro menor (figura 2.9(a)). 
 O próximo passo corresponde a dividir uma das circunferências em partes iguais, por exemplo, a 
maior. A partir de cada divisão, são traçados raios que cortam a circunferência interna (figura 2.9(a)). 
 Traçando-se linhas horizontais a partir da interseção dos raios com a circunferência interna e retas 
verticais a partir da intersecção dos raios com a circunferência externa, resultam na interseção destas 
duas retas que resultam num ponto (P) pertencente a elipse (figura 2.9(b)). 
 Realizando este traçado para cada divisão, é possível obter uma série de pontos da elipse. A 
união destes pontos resulta no traçado da curva (figura 2.9(c)). 
 
BA
D
C
D
C
A B
D
C
BA
(a) (b) (c)
 
Figura 2.9 - Traçado da elipse pelo processo dos círculos concêntricos. 
 
 
2.2.4 - Desenvolvimento do algoritmo 
 O algoritmo é baseado no processo gráfico dos circulos concêntricos. Deste modo, deve-se aliar a 
matemática e o desenho geométrico para achar a solução do problema. 
 Inicialmente, determina-se a posição de um ponto aleatório da elipse. Pode utilizar-se de um dos 
pontos determinado pelas divisões iguais da circunferência externa. 
 Na figura 2.10, pode-se observar que a determinação das coordenadas P(x,y) de um ponto 
qualquer, a partir do centro da elipse, pode ser obtida considerando-se o ângulo (α), e a relação dele 
com os raios das circunferências interna e externa. 
 Deste modo, fazendo-se variar o ângulo (α) de um valor conhecido, é possível determinar uma 
série de pontos da elipse e efetuar o seu traçado. 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 29 
 Assim, pode-se calcular as coordenadas do ponto P(x,y) (figura 2.10) através das seguintes 
relações: 
x = Raio . cos α (1) 
y = raio . sen α (2) 
P(x)=xo+x 
P(y)=yo+y 
A
D
C
B
α y
x
ra
ioR
ai
o
P(x,y)
(xo,yo)
 
Figura 2.10 - Determinação das coordenadas de um ponto da curva. 
 
 O traçado dos raios vetores, que são na realidade os elementos do traçado pelo processo do fio, 
são obtidos unindo cada foco ao ponto da curva em análise. Para isso, é necessário saber a posição 
de cada foco que é determinado da seguinte forma (figura 2.11): 
FO AO CO= −2 2 (3) 
Onde FO é denominada de semi-distância focal (figura 2.11). 
 
F
A O
D
F'
C
B
AO
 
=
 
FC
 
Figura 2.11 - Determinação da posição dos focos. 
 
2.2.5 - Fluxograma do programa 
 O fluxograma apresenta a lógica de construção do programa. Inicialmente são definidas as 
variáveis do programa, calculados os parâmetros principais e desenvolvida a formulação para o 
desenho da curva (figura 2.12). 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 30 
Desenha um trecho da curva
entre dois pontos
Calcula a posição do ponto
P(x,y) da curva
Desenha os diâmetros e os
focos
Armazena coordenadas
X e Y
varia ângulo alfa
N
início
Determina a posição dos focos
F1 e F2
Calcula a semi distância focal
Parâmetros da elipse:
Coordenadas do centro (x0,y0)
Diâmetro Maior
Diâmetro Menor
Focos - F1 e F2
Ponto da curva P(x,y)
Tocou
alguma
tecla?
fim
S
 
Figura 2.12 - Fluxograma do programa elipse. 
 
 
2.2.6 - Estrutura básica do programa 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//======================================================== 
void main()//define a funcao principal 
{//1 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
 
//=================== final das variaveis do programa=========== 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1); // retorna codigo de erro 
 } 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 31 
//============= inicia o programa propriamente dito =========== 
 
//========== final do programa propriamente dito =========== 
getch(); 
closegraph(); 
}//1 
//============= final do arquivo ================ 
 
 
2.2.7 - Desenvolvimento do programa 
 
Versão 1: 
 Na Versão 1 é feito o desenho do diâmetro maior e do menor da elipse, tomando como referência 
o centro da elipse (cruzamento dos diametros (xo,yo)) 
 Deste modo, para dertminar as duas retas a serem desenhadas a partir do centro tem-se (figura 
2.13): 
 
A(x) = xo - DiametroMaior/2 A(y) = yo 
B(x) = xo + DiametroMaior/2 B(y) = yo 
 
C(x) = xo C(y) = yo - DiametroMenor/2 
D(x) = xo D(y) = yo + DiametroMenor/2 
 
xo,yo
A
D
C
B
xo+DiametroMaior/2,yo
xo-DiametroMaior/2,yo
xo,yo-DiametroMenor/2
xo,yo+DiametroMenor/2
 
Figura 2.13 - Determinação dos vértices da elipse. 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h>#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//============================================================= 
void main() //define a funcao principal 
{//1 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
//=================== final das variaveis do programa=========== 
int xo=320,yo=240; //coordenadas do centro da elipse 
int DiametroMaior=400,DiametroMenor=200; //diametros da elipse 
 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 32 
 getch(); 
 exit(1);// retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
 
line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior 
line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor 
 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph(); 
}//1 
//==================== final do arquivo ================================== 
 
 
Versão 2: 
 Na versão é determinada a posição dos dois focos F1 F2, a partir do centro da elipse. Isto pode 
ser visto na figura 2.11 e na equação 3. Onde F e F’, podem ser agora denominadas de F1 e F2. 
 
F1 = xo - FO (3) 
F2 = xo + FO (4) 
 
 Nas respectivas posições, traça-se um círculo para localizar os focos. 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//============================================================= 
float dobro(float x) 
{ 
return( x*x); 
} 
//============================================================= 
 
void main()//define a funcao principal 
{//1 
 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
//=================== final das variaveis do programa=========== 
int xo=320,yo=240; //coordenadas do centro da elipse 
int DiametroMaior=400,DiametroMenor=200; //diametros da elipse 
float SemiDistanciaFocal; //distancia do centro da alipse até o foco 
float F1,F2; // focos 
 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1);// retorna codigo de erro 
 } 
//===================== inicia o programa propriamente dito =========== 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 33 
 
//calculo da semi distancia focal 
SemiDistanciaFocal=sqrt( dobro(DiametroMaior/2)-dobro(DiametroMenor/2) ); 
 
//posicao dos focos no eixo X 
F1=xo-SemiDistanciaFocal; 
F2=xo+SemiDistanciaFocal; 
 
//desenho dos focos 
circle(F1,yo,2); //posição do foco 
circle(F2,yo,2); //posição do foco 
 
line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior 
line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor 
 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph(); 
}//1 
//==================== final do arquivo ================================== 
 
 
Versão 3: 
 Nesta versão, é executado o traçado da elipse, sendo esta executada através de pequenas retas. 
A metodologia utilizada para determinar as coordenadas da curva, está explicada no desenvolvimento 
do algoritmo, nas equações 1 e 2. 
 
 
#include <graphics.h> 
#include <conio.h> 
#include <stdlib.h> 
#include <stdio.h> 
#include <dos.h> 
#include <math.h> 
//============================================================= 
void main() //define a funcao principal 
{//1 
 
//=================== definicao das variaveis ================== 
int gdriver,gmode,errorcode; //=== variaveis graficas 
//=================== final das variaveis do programa=========== 
int xo=320,yo=240; //coordenadas do centro da elipse 
int DiametroMaior=400,DiametroMenor=200; //diametros da elipse 
float SemiDistanciaFocal; // Distancia do centro da elipse até o foco 
float F1,F2; //posicao dos focos no eixo X 
float Dalfa,alfa=0; 
float xOld,yOld; //pontos anteriores 
int x,y; //pontos da curva 
 
//=================== inicializa ambiente grafico ============== 
 gdriver=DETECT; 
 initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); 
 errorcode=graphresult(); 
 if(errorcode!=grOk) 
 { 
 printf("Erro do adaptador grafico\n"); 
 printf("Falta o arquivo EGAVGA.BGI\n"); 
 printf("Pressione qualquer tecla para retornar"); 
 getch(); 
 exit(1);// retorna codigo de erro 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 34 
 } 
//===================== inicia o programa propriamente dito =========== 
 
//calculo da semi distancia focal 
SemiDistanciaFocal=sqrt( dobro(DiametroMaior/2)-dobro(DiametroMenor/2) ); 
 
//posicao dos focos no eixo X 
F1=xo-SemiDistanciaFocal; 
F2=xo+SemiDistanciaFocal; 
 
//desenho dos focos 
circle(F1,yo,2); 
circle(F2,yo,2); 
 
Dalfa=M_PI/36; //divide a circunferencia em 72 partes 
xOld=xo+DiametroMaior/2; // coordenada X inicial 
yOld=yo; // coordenada Y inicial 
 
setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH); 
 
while(!kbhit()) 
{ 
setcolor(WHITE); 
line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior 
line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor 
 
alfa=alfa-Dalfa; 
x=xo+(DiametroMaior/2)*cos(alfa); // calculas as coordenadas X 
y=yo+(DiametroMenor/2)*sin(alfa); // calculas as coordenadas Y 
setcolor(YELLOW); 
line(xOld,yOld,x,y); // Desenha a elipse 
 
xOld=x; //armazenas pontos anteriores 
yOld=y; //armazenas pontos anteriores 
 
delay(40); //tempo de retardo 
} 
//===================== final do programa propriamente dito ============ 
getch(); 
closegraph(); 
}//1 
//==================== final do arquivo ================================== 
 
 
 
 Basta rodar o programa e ver a formação de uma elipse pelo processo dos círculos concêntricos 
(figura 2.14). 
 
 
2.2.8 - Comentários 
 Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a 
seguir: 
float DiametroMaior=200,DiametroMenor=400; 
 Como resultado, surgirá uma elipse em posiçao diferente. As variáveis xo e yo, permitem mutar a 
posição que a elipse será desenhada. 
 Experimente alterar DiametroMaior=300 e DiametroMenor=300. 
 
 
Linguagem C – Introdução à programação com aplicações gráficas 2008 
Nilson Luiz Maziero nmaziero@terra.com.br 35 
 
Figura 2.14 – Desenho da elipse na tela. 
 
 
 
 
2.3 - PROGRAMA ESPIRAL DE ARQUIMEDES 
 O programa executa o traçado de uma espiral de arquimedes. 
 
2.3.1 - O que é uma Espiral de Arquimedes 
 A espiral de Arquimedes é a trajetória resultante do deslocamento de um ponto (P) com 
velocidade retilínea uniforme sobre uma reta que possui movimento de rotação uniforme em torno de 
um centro (figura 2.15). 
Ponto P(x,y) em 
translação sobre a reta
reta em rotação
centro
 
Figura 2.15 - Espiral de Arquimedes. 
 
2.3.2 - Elementos de uma espiral de Arquimedes