Fundamentos de Programação 1 - Alcides Maya Tecnologia

1 

Fundamentos de Programação 

ESCOLA 

Fundamentos 

de Programação

Escola Alcides Maya - Primeiro Módulo 

2

Sumário 

Fundamentos de Programação 1 

3 


1 Introdução ....................................................................................................................................... 4 

2 Introdução à Linguagem C ............................................................................................................ 4 

3 Técnicas Básicas de Programação ................................................................................................. 8 

4 Estruturas de Controle – A Tomada de Decisões ....................................................................... 30 

5 Estruturas de Controle – Laços de Repetição ............................................................................ 43 

6 Estruturas de Dados Homogêneas I ............................................................................................ 52 

7 Estruturas de Dados Homogêneas II........................................................................................... 59 

8. Programação Estruturada ......................................................................................................... 64


1 Introdução 

A disciplina de Fundamentos de Programação está ligada a de Lógica de Programação e vamos aplicar as 

estruturas lógicas utilizando a linguagem C. 

C é uma linguagem de programação de finalidade geral. Foi criada por Dennis M. Ritchie e Ken Thompson, 

na Bell Laboratories em 1972, e estava associada ao sistema operacional UNIX. A linguagem, entretanto não 

está ligada a um sistema operacional, hoje usamos C em DOS, Windows e Linux. 

C foi baseada na linguagem B de Thompson que era uma evolução da antiga Linguagem BCPL. B foi nomeada 

com a primeira letra de BCPL e C com a segunda. 

C é uma linguagem de “baixo nível”, que o deixa especificar todos os detalhes em lógica de algoritmos para 

obter a máxima eficácia do computador. Mas C também é uma linguagem de alto nível que pode esconder 

detalhes da arquitetura dos computadores, resultando no aumento da eficiência na programação. 

C foi escrita para que o programador possa planejar programas estruturados e modulares. O resultado é 

um programa mais legível e documentado. Hoje já podemos programar de forma moderna utilizando a OOP 

(Programação Orientada para Objetos) e também a Programação voltada para Eventos. 

o padrão ansI C 

O comitê ANSI desenvolveu padrões para a linguagem C. Diversas destas modificações tiveram a intenção 

de aumentar a flexibilidade da linguagem, enquanto outras tentaram padronizar características previamente 

deixadas a cargo do implementador do compilador. 

Anteriormente, o único padrão era o livro: Linguagem de Programação C, de Brian Kernighan e Dennis Ritchie. 

Este livro não era específico em alguns detalhes da linguagem, o que levou a divergências entre os compiladores. 

O padrão ANSI tentou remover essas ambigüidades. Embora algumas das modificações propostas pudessem 

causar problemas para alguns programas escritos anteriormente, elas não afetam muito o código existente. O 

padrão ANSI C proporciona uma oportunidade melhor para escrever um código C portátil. Entretanto, o padrão 

não corrige todas as áreas de confusão e, por causa da eficiência da interface da linguagem C, com o hardware 

da máquina, muitos programas sempre exigirão algumas revisões quando você os mover para um ambiente 

diferente. 

2 Introdução à LInguagem C 

Vamos agora ver alguns detalhes iniciais da linguagem. 

Primeiro programa em C 

Iniciaremos nosso estudo com um programa simples, que apenas escreve na tela de seu computador a frase: 

“meu primeiro programa”. Veja, abaixo, como é o programa: 

main( ) 

{ 

printf (“meu primeiro programa” ); 

} 

Agora algumas considerações sobre o programa acima: 

• Um programa em C consiste de uma ou mais funções que especificam o que deve ser feito. No exemplo 

acima main( ) é uma função. Qualquer programa em C começa com a função main( ) que marca o ponto inicial 

da execução do programa. 

• Todas as instruções devem estar dentro das chaves que iniciam e terminam a função, elas têm a mesma 

função que o begin e end em Pascal. 

4


• A linha: printf (“Meu primeiro programa”); é uma chamada a função printf, com o argumento “Meu primeiro 

programa”, que é uma seqüência de caracteres entre aspas “. . . “, chamada de: cadeia de caracteres, ou também 

string. A printf é uma função de biblioteca que escreve o argumento na tela do seu computador. Os parênteses 

devem estar presentes mesmo quando não há argumentos. 

• As instruções C são sempre encerradas por um ponto-e-vírgula (;). 

Limpando a tela 

Seria interessante você colocar uma função para limpar a tela, antes de escrever a mensagem: “Meu primeiro 

programa”. Para fazer isto podemos utilizar a função clrscr( ) que serve para este propósito. Veja as alterações 

feitas no programa abaixo: 

main( ) 

{ 

clrscr( ); 

printf (“meu primeiro programa” ); 

} 

a Função printf( ) 

A função printf( ) é uma das funções de E/S (entrada e saída) que podem ser usadas em C. Ela não faz parte 

da definição de C, mas todos os sistemas têm uma versão de printf( ) implementada. 

Os parênteses indicam que estamos em uma função. Entre os parênteses estão as informações que são 

passadas pelo programa main( ) para a função printf( ), isto é “Meu primeiro programa”. Esta informação é 

chamada de argumento. 

Quando o programa encontra esta linha, passa o controle para a função printf( ) que imprime na tela do seu 

computador “Meu primeiro programa” e, quando encerra a execução, o controle é transferido novamente para a 

função main. Vamos ver o próximo exemplo: 

main( ) 

{ 

clrscr( ); 

printf(“escola técnica alcides maya\n”); 

printf(“estamos na etapa número: 2”); 

} 

A função printf( ) pode ter um ou vários argumentos. Na primeira printf temos o seguinte argumento: “escola 

técnica alcides maya\n” onde encontramos a string: Escola Técnica Alcides Maya, e também os caracteres 

“\n”. 

Este caractere \n é a notação C para o caractere de nova-linha, que provoca o avanço do cursor para o início 

da próxima linha. Se você omitir o \n, você verá como resultado as duas string´s escritas em apenas uma linha 

na tela. 

Além do caractere \n temos outros caracteres que estão na tabela abaixo: 

Código Significado 

\n Nova linha 

\t Tabulação 

\b Retrocesso 

\” Aspas 

\\ Barra 

5


Formato inteiro decimal 

Veja as alterações que fizemos no programa anterior: 

main( ) 

{ 

clrscr( ); 

printf(“escola técnica alcides maya\n”); 

printf(“estamos na etapa número: %d” , 2); 

} 

Agora, colocamos dois argumentos na segunda printf: “Estamos na etapa número: %d” , 2 

Estes dois argumentos são separados por uma virgula. 

A expressão de controle pode conter caracteres que serão exibidos na tela e códigos de formatação que 

indicam o formato em que os argumentos devem ser impressos. 

No exemplo o código de formatação %d solicita a printf( ) imprimir o segundo argumento no formato de um 

número inteiro decimal. 

escrevendo uma string na tela 

Além do código de formatação decimal (%d), existe outros. No exemplo a seguir veremos o uso do código %s 

para escrever na tela uma string. 

main( ) 

{ 

clrscr( ); 

printf(“o %s é um dos melhores transportes urbanos”, “metrô”); 

} 

Vamos agora escrever um programa com mais de uma instrução: 

main( ) 

{ 

clrscr( ); 

printf(“o %s venceu de %d gols de diferença contra o time adversário”, “Inter” , 4); 

} 

Neste exemplo passamos dois argumentos para a função printf o %s do nome do time: “Inter” e o %d da 

quantidade de gols: 4. 

Vejamos o próximo exemplo: 

main( ) 

{ 

clrscr( ); 

printf(“a letra %c ”, ´x´); 

printf(“pronuncia-se %s.”, “xis” ); 

} 

Note que o ´x´ é delimitado por aspas simples enquanto que “xis” é delimitado por aspas duplas. Isto indica 

ao compilador como diferenciar um caractere de uma string. 

6


A tabela, a seguir, mostra os códigos para impressão formatada de printf( ); 

Código Significado 

%c Caracteres simples 

%d Decimal 

%f Ponto flutuante 

%s String de caracteres 

%u Decimal sem sinal 

%x Hexadecimal 

exerCíCIos de FIxação 

Vamos agora realizar alguns exercícios de fixação para sedimentar em nossa mente os conhecimentos 

adquiridos: 

1. No programa abaixo há alguns problemas, faça as correções necessárias. 

main( ) 

( 

clrscr( ) 

printf(Temos %d aulas no semestre, 33 ); 

) 

2. Qual será o resultado do programa abaixo: 

main( ) 

( 

clrscr( ) 

printf(“as notas escolares são: %d %d %d\n” , 4, 7, 9); 

) 

3. Neste outro programa o que será apresentado na tela do computador: 

main( ) 

( 

clrscr( ) 

printf(“%s \n %s \n %s” , “escola”, “técnica”,”alcides maya” ); 

) 

4. Faça um programa que contenha uma única instrução e escreva na tela: 

Esta é a primeira linha. 

Esta já é a segunda linha. 

7


5. Escreva um programa que escreva na tela: 

UM 

DOIS 

TRES 

QUATRO 

6. Qual será a impressão obtida na tela por cada uma destas instruções? Assuma que fazem parte de um 

programa completo. 

a) printf (“Boa Tarde ! Maria.”); 

printf (“Você já lanchou ? \n”); 

b) printf(“Escola Técnica\nAlcides Maya\n”); 

8. Faça um programa que escreva na tela o teu nome, o nome da tua mãe e o nome da tua avó, todos em 

linhas diferentes na tela. (Use o \n). 

9. Faça um programa que escreva na tela uma mensagem do tipo: “Eu tenho 23 anos”, sendo que a idade 

deverá ser um argumento do tipo inteiro decimal. (Use o %d). 

10. Faça um programa que numere as linhas da tela (cada linha com um número). 

3 téCnICas BásICas de Programação 

A partir deste momento vamos ter um contato direto com a parte pratica da Lógica de Programação. 

Variáveis 

O computador possui uma área de armazenamento temporária conhecida como memória. A memória do 

computador pode ser entendida como uma seqüência finita de caixas, que num dado momento, guardam algum 

tipo de informação, como um número, uma letra, uma palavra, uma frase, etc, não importa, basta saber que lá 

sempre existe alguma informação. 

O computador, para poder trabalhar com algumas destas informações, precisa saber onde, na memória, o 

dado está localizado. 

Fisicamente, cada caixa, ou cada posição de memória, possui um endereço, ou seja, um número, que indica 

onde cada informação está localizada, este número é representado através da notação hexadecimal, tendo o 

tamanho de quatro, ou mais bytes. Abaixo segue alguns exemplos: 

endereço Físico Informação 

3000:B712 “João” 

2000:12EC 45 

3000:0004 ‘J’ 

Como pode ser observado, o endereçamento das posições de memória através de números hexadecimais é 

perfeitamente compreendido pela máquina, mas para nós humanos torna-se uma tarefa complicada. 

Pensando nisto, as linguagens de computador facilitaram o manuseio, por parte dos programadores, das 

posições de memória da máquina, permitindo, que, ao invés de trabalhar diretamente com o número hexadecimal, 

fosse possível dar nomes diferentes a cada posição de memória. 

Tais nomes seriam de livre escolha do programador. 

Com este recurso, os programadores ficaram livres dos endereços físicos (números hexadecimais) e passaram 

a trabalhar com endereços lógicos (nomes dados pelos próprios programadores). 

8


Desta forma, o exemplo acima, poderia ser alterado para ter o seguinte aspecto: 

endereço Físico Informação 

Cliente “João” 

Idade 45 

Inicial ‘J’ 

Como tínhamos dito, os endereços lógicos são como caixas, que num dado instante guardam algum tipo de 

informação. Mas é importante saber que o conteúdo desta caixa não é algo fixo, permanente, na verdade, uma 

caixa pode conter diversas informações, ou seja, como no exemplo acima, a caixa (endereço lógico) rotulada de 

“Cliente” num dado momento contém a informação “João”, mas em um outro momento, poderá conter uma outra 

informação, por exemplo “Pedro”. 

Com isto queremos dizer que o conteúdo destas caixas (endereço lógico) podem variar, isto é, podem sofrer 

alterações em seu conteúdo. 

Tendo este conceito em mente, a partir de agora iremos chamar as caixas ou endereços lógicos, de 

Variáveis. 

Desta forma podemos dizer que uma variável é uma posição de memória representada por um Nome simbólico 

(atribuído pelo programador), a qual contém, num dado instante uma informação. 

Variáveis na linguagem C 

Uma variável em C é um espaço de memória reservado para armazenar um certo tipo de dado com um nome 

para referenciar o seu conteúdo. 

Em um programa a variável poderá conter um valor em um determinado momento e um outro valor em outro 

momento. Veja o programa a seguir: 

main( ) 

{ 

int num; 

num = 2; 

printf(“este é o número: %d \n” , num); 

num = 5 + 10; 

printf(“este é o número: %d \n” , num); 

} 


• Na linha int num; é a declaração da variável, que tem nome: num e tipo: int, ou seja, irá armazenar valores 

numéricos inteiros. 

• Na linha num = 2; estamos atribuindo a variável o valor 2 (dois), portanto o endereço de memória 

identificado como num contém neste instante o número 2 (dois). 

• Na linha printf(“Este é o número: %d \n” , num); estamos apresentado o conteúdo desta variável. 

• Na linha num = 5 + 10; estamos efetuando um cálculo e atribuindo a variável o resultado deste cálculo, 

portanto a variável num contém neste instante o número 15 (quinze). 

• Na linha printf(“Este é o número: %d \n” , num); estamos apresentando o conteúdo desta variável. 

9


nomes das variáveis 

Para nomearmos variáveis, geralmente, seguimos algumas regras, que, conforme o livro Linguagem de 

Programação C, de Brian Kernighan e Dennis Ritchie, elas seriam as seguintes: 

• Os nomes das variáveis são construídos com letras e dígitos. 

• O primeiro caractere deve ser uma letra. 

• O caractere de sublinha “_” vale como uma letra; ele é útil para aumentar a clareza de nomes muito longos 

de variáveis. Exemplo: data_de_nascimento. 

• Letras em maiúsculo e minúsculo são diferentes; uma prática tradicional em C é de usar letras minúsculas 

para vaiáveis. CASA, Casa, casa, representam variáveis diferentes. 

• Somente os primeiros oito caracteres de um nome interno são significativos, embora mais caracteres 

possam ser usados. 

• Naturalmente é melhor escolher nomes de variáveis que tenham algum significado, que estejam 

relacionados com a finalidade da variável, e que sejam diferenciados tipograficamente. 

declarações das variáveis 

Na declaração de uma variável instruímos ao programa reservar uma quantidade de memória apropriada 

para armazenar o tipo especificado e indicar que o seu conteúdo será referenciado pelo nome dado. 

Se você tiver mais de uma variável do mesmo tipo, poderá declará-las de uma única vez, separando seus 

nomes por virgulas. 

int idade, casa, livro; 

O local indicado para declarar as variáveis é logo após a chave inicial da função main, veja o exemplo 

abaixo: 

main( ) 

{ 

int num, nota1, nota2, nota3, nota4, media; 

. 

. 

. 

. 

. 

} 

Antes de prosseguir, temos uma observação importante: “Em C todas as variáveis devem ser declaradas 

antes de serem utilizadas”. 

tipos de variáveis 

O tipo de uma variável informa a quantidade de memória, em bytes, que está irá ocupar. 

tipo Bit Bytes escala 

char 8 1 -128 a 127 

int 16 2 -32768 a 32767 

float 32 4 3.4 E -38 a 3.4 E +38 

double 64 8 1.7 E -308 a 1.7 E +308 

O tipo char é capaz de conter um caractere. O tipo int poderá conter números inteiros (ex.: 35, 0, -56) e o tipo 

float e double poderá conter números reais (35, 0, -56, 1.2, -45.897). 

10


C provê os modificadores de tipo como o short que é um inteiro curto que varia de –32.763 até 32.762 e 

também o long que é um inteiro longo e que varia de –2.147.483.648 até 2.147.483.647. 

main( ) 

{ 

int idade; 

char inicial; 

float tempo; 

idade = 25; 

inicial = ´C´; 

tempo = 17.25; 

printf(“a inicial do meu nome é: %c \n” , inicial); 

printf(“minha idade é: %d anos\n” , idade); 

printf(“meu tempo na prova foi de %f minutos \n” , tempo); 

} 

Agora algumas considerações sobre o programa anterior: 

• Na linha int idade; é a variável, do tipo inteiro, que irá conter a idade. 

• Na linha char inicial; é a variável, do tipo caractere, que irá conter a letra inicial de um nome. 

• Na linha float tempo; é a variável, do tipo ponto flutuante, que irá conter o tempo em minutos. 

• Na linha idade = 25; é a inicialização da variável idade. 

• Na linha inicial = ’C’; é a inicialização da variável inicial. 

• Na linha tempo = 17.25; é a inicialização da variável tempo. 

• Na linha printf(“A inicial do meu nome é: %c \n” , inicial); é a apresentação do conteúdo da variável 

inicial. 

• Na linha printf(“Minha idade é: %d anos\n” , idade); é a apresentação do conteúdo da variável idade. 

• Na linha printf(“Meu tempo na prova foi de %f minutos \n” , tempo); é a apresentação do conteúdo da 

variável tempo. 

operadores 

Veremos agora o conteúdo relacionado a operadores aritméticos e operadores de atribuição. 

C é uma linguagem rica em operadores. Alguns são mais usados que outros, como é o caso dos operadores 

aritméticos que executam operações aritméticas. 

operadores aritméticos 

Para efetuar cálculos matemáticos temos os seguintes operadores aritméticos: 

operador ação exemplo resultado 

- Subtração 5 – 1 4 

+ Adição 5 + 1 6 

* Multiplicação 5 * 2 10 

/ Divisão 10 / 2 5 

% Resto da divisão 11%2 1 

11


operador de atribuição 

Em C, o sinal de igual não tem a interpretação dada em matemática. Representa a atribuição da expressão 

à direita ao nome da variável à esquerda. Por exemplo: 

num = 2000; 

atribui o valor 2000 a variável num. A ação é executada da direita para a esquerda deste operador. 

C aceita várias atribuições numa mesma instrução: 

laranjas = bergamotas = cenouras = abacates = 80; 

A seguir temos um programa que usa vários operadores aritméticos e converte temperatura Fahrenheit em 

seu correspondente Celsius. 

main( ) 

{ 

float ftemp, ctemp; 

ftemp = 120; 

ctemp = ( ftemp – 32.0 ) * ( 5.0 / 9.0 ); 

printf(“temperatura em graus Celsius é: %f” , ctemp); 

} 


• Na linha float ftemp, ctemp; é a declaração de duas variáveis, do tipo float, que irá conter a temperatura 

em graus Fahrenheit e Celsius. 

• Na linha ftemp = 120; estamos utilizando o operador de atribuição que armazena a temperatura de 120 

graus Fahrenheit na variável ftemp. 

• Na linha ctemp = ( ftemp – 32.0 ) * ( 5.0 / 9.0 ); estamos efetuando o cálculo de conversão da temperatura 

em Fahrenheit para Celsius e atribuindo o resultado do cálculo para a variável ctemp. Note que colocamos 

parênteses em ftemp – 32.0. Se você lembra um pouco de álgebra, a razão estará clara. Nós queremos que 32 

seja subtraído de ftemp antes de multiplicarmos por 5 e dividirmos por 9. A multiplicação e a divisão são feitas 

antes da soma ou subtração. 

• Na linha printf(“Temperatura em graus Celsius é: %f” , ctemp); estamos apresentando o resultado do 

cálculo. 

12


ComentárIos 

Comentários podem ser colocados em qualquer lugar de seu programa. Comentários são recomendados 

para documentar a lógica utilizada no programa. Tudo que começa com dois caracteres, chamados símbolos de 

comentários, barra-asterisco (/*) e terminam por asterisco-barra (*/), são comentários e o conteúdo entre eles 

não será verificado pelo compilador. 

No programa abaixo mostraremos vários comentários: 

/* Exercício 015 

* Este programa calcula 

* a idade de uma pessoa 

* em dias 

*/ 

main( ) 

{ 

float anos, dias; /* declaração de variáveis */ 

anos = 12; /* inicializa a variável anos */ 

dias = anos * 365; /*calcula idade em dias*/ 

printf(“a idade em dias é: %f \n” , dias); /* apresentar o resultado */ 

} 


1. Faça um programa que armazene a quilometragem inicial de um carro. Depois de uma viagem, armazenar 

a quilometragem final do carro. Calcular e apresentar a distância percorrida pelo carro. 

2. Faça um programa que armazene as notas de um aluno (serão 4 notas, portanto, teremos 4 variáveis). 

Calcule a média do aluno e armazene em uma variável, depois apresente a média do aluno (use variáveis do tipo 

inteiro). 

3. Faça um programa que armazene as notas de um aluno (serão 4 notas, portanto, teremos 4 variáveis). 

Calcule a média do aluno e armazene em uma variável, depois apresente a média do aluno (use variáveis do tipo 

ponto flutuante). 

4. Faça um programa que calcule e apresente o valor do volume de uma lata de óleo, utilizando a fórmula: 

volume = 3.14159 * raio² * altura. Obs.: Atribua valores a variável raio e altura. 

5. Faça um programa que calcule e apresente o volume de uma caixa retangular, por meio da fórmula: 

volume = comprimento * largura * altura. Obs.: Atribua valores a variável comprimento, largura e altura. 

6. Faça um programa que leia dois valores inteiros para as variáveis A e B, e efetuar a troca dos valores de 

forma que a variável A passe a possuir o valor da variável B e a variável B passe a possuir o valor da variável A. 

Apresentar na tela os novos valores das variáveis A e B. 

7. Faça um programa que leia quatro números inteiros e apresentar o resultado da adição destes números. 

(A + B + C + D) 

8. Faça um programa que leia quatro números inteiros e apresentar o resultado da multiplicação destes 

números. (A * B * C * D) 

13


9. Indique com um X quais dos dados abaixo são do tipo inteiro. 

( ) 1000 

( ) “0” 

( ) “-900” 

( ) -456 

( ) 34 

( ) ‘C’ 

( ) 0 

( ) –1.56 

( ) 34.76 

10. Indique com um X quais dos dados abaixo são do tipo float. 

( ) -678 

( ) “0.87” 

( ) 99.8 

( ) “cinco” 

( ) 34 

( ) ‘C’ 

( ) 45.8976 

( ) –1.56 

( ) 34.76 

Funções de entrada e saída 

O computador não é uma máquina isolada, pois ele precisa se comunicar com o mundo exterior, com 

vídeo, impressora, teclado, discos, fitas, etc. Para realizar esta comunicação existem comandos que permitem 

que informações sejam exibidas, por exemplo, no vídeo, como também existem comandos que permitem que 

informações sejam colocadas na memória do computador através do teclado do PC. 

Os comandos que iremos ver são os comandos para LER e ESCREVER, respectivamente, comando de 

entrada e de saída. 

entrada, Processamento e saída 

Para criar um programa que seja executável dentro de um computador, deve-se ter em mente três coisas: a 

entrada de dados, o seu processamento e a saída deles. 

Sendo assim, todo programa estará trabalhando com estes três conceitos. Se os dados forem entrados de 

forma errada, serão conseqüentemente processados de forma errada e resultarão em respostas erradas. 

Desta forma, dizer a alguém que foi erro do computador é ser um tanto “medíocre”. E isto é o que mais 

ouvimos quando nosso saldo está errado e vamos ao banco fazer uma reclamação ou quando recebemos uma 

cobrança indevida. Se houve algum erro, é porque foi causado por falha humana. Realmente é impossível um 

computador errar por vontade própria, pois vontade é uma coisa que os computadores não têm. 

O processo de execução de um programa ocorre segundo o exposto, após a entrada de dados com a 

instrução leia e a sua saída com a instrução escreva. O processamento será uma conseqüência da manipulação 

das variáveis de ação. 

Uma entrada e uma saída poderá ocorrer dentro de um computador de diversas formas. Por exemplo, uma 

entrada poderá ser feita via teclado. Uma saída poderá ser feita em vídeo. 

As funções de biblioteca da linguagem C, mais comuns para a entrada e saída de dados são a printf() e a 

scanf(). 

14


a função printf( ) 

A função printf( ) é uma das funções de saída de dados da linguagem C, que você já utilizou na Aula 1. 

A função scanf( ) 

A função scanf( ) é o complemento de printf( ) e nos permite fazer a entrada de dados do teclado. 

Sua sintaxe é uma expressão de controle seguida por uma lista de argumentos separados por virgulas. Os 

argumentos de scanf( ) devem ser endereços de variáveis, cuja sintaxe será apresentada a seguir: 

scanf( “expressão de controle”, lista de argumentos); 

A expressão de controle contem códigos de formatação, sempre precedida por um sinal de % 

(percentagem). 

A lista de argumentos deve consistir nos endereços das variáveis, onde serão armazenados os valores lidos. 

C oferece um operador para tipos básicos chamados operador de endereço e referenciado pelo símbolo & que 

retorna o endereço do operando, voltaremos a este assunto quando será abordado a aula de pointers. 

Para exemplificar o que estamos apresentando, veremos no programa a apresentação do conteúdo 

armazenado em uma variável e o endereço da variável. 

main( ) 

{ 

int num; 

num = 2; 

printf(“Conteúdo da variável.......: %d \n” , num); 

printf(“endereço decimal............: %u \n” , &num); 

printf(“endereço Hexadecimal....: %u \n” , &num); 

} 


• Na declaração int num; estamos declarando a variável inteira num. 

• Na linha seguinte num = 2; estamos inicializando a variável com o número inteiro 2. 

• Na linha printf(“Conteúdo da variável.......: %d \n” , num); a função printf vai apresentar o conteúdo da 

variável através do código de formatação “%d” e na linha seguinte, através do código “%u” o endereço da variável 

num. Repare que o nome da variável vem precedido do caractere “&”, indicando que é o endereço da variável. 

Um endereço de memória é visto como um número inteiro sem sinal, por isso usamos o “%u”. 

Mas o que este programa tem a ver com a entrada de dados? 

Nada, apenas estamos apresentando a você o endereço da variável, já que para ler um valor para uma 

variável, utilizando a função scanf, temos que informar o endereço da variável. 

No programa abaixo, ao invés de inicializar o valor da variável, como em num = 2; vamos ler um número 

qualquer e depois apresentá-lo. 

main( ) 

{ 

int num; 

printf(“digite um número: “); 

scanf(“%d” , &num); 

15


printf(“o número digitado foi: %d “ , num); 

} 


• Na declaração int num; estamos declarando a variável inteira num. 

• Na linha printf(“Digite um número: “); informamos ao usuário que ele deverá digitar um número. 

• Na linha seguinte scanf(“%d” , &num); estamos esperando que o usuário digite um número inteiro e 

pressione a tecla ENTER. Nunca esqueça que ao usar a função scanf você deve informar o endereço da variável 

para onde vamos ler alguma coisa, caso contrário você terá surpresas desagradáveis no teu programa. 

• Na última linha printf(“O número digitado foi: %d “ , num); a função printf vai apresentar o conteúdo da 

variável num. 

Veja na tabela a seguir os códigos básicos de formatação da função scanf( ) 

Código Função 

%c Leia um único caractere 

%d Leia um inteiro decimal 

%f Leia um número em ponto flutuante 

Agora vamos fazer um exemplo ligeiramente mais difícil. O próximo programa pede ao usuário o comprimento 

em “jardas”, e então escreve na tela o valor convertido em “pés” e “polegadas”. 

main( ) 

{ 

int jardas, pes, polegadas; 

printf(“digite o comprimento a ser convertido: “); /* entrada de dados */ 

scanf(“%d” , &jardas); 

polegadas = 36 * jardas; 

pes = 3 * jardas; 

/* processamento */ 

printf(“ %d jardas = %d pés \n” , jardas, pés ); /* saída de dados */ 

printf(“ %d jardas = %d polegadas \n” , jardas, polegadas ); 

} 


• Na declaração int jardas, pes, polegadas; estamos declarando as variáveis inteiras jardas, pés, 

polegadas. 

• Na linha printf(“Digite o comprimento a ser convertido: “); solicitamos ao usuário que ele deverá digitar um 

comprimento. 

• Na linha seguinte scanf(“%d” , &jardas); estamos esperando que o usuário digite um número inteiro e 

pressione a tecla ENTER. Este número será armazenado na variável: jardas. 

• Nas duas linhas seguintes: polegadas = 36 * jardas; e na linha pes = 3 * jardas; estamos calculando a 

conversão de jardas em polegadas e a conversão de jardas em pés. 

• E, finalmente nas duas últimas chamadas a função printf, estamos apresentando o resultado das 

conversões realizadas. 

16

17 


Observação importante: veja como ficaram visíveis, neste programa, as três partes básicas do processamento 

de dados: entrada, processamento e saída, destacadas no programa através dos comentários. 

Se em cada programa, nos concentrássemos nestas partes básicas, já teríamos metade da solução do 

programa resolvida. Veja o exemplo a seguir: 

Exemplo – Faça um programa que leia um número inteiro qualquer, que representa o comprimento em jardas. 

Sabendo-se que esta medida de comprimento poderá ser transformada em polegadas multiplicando-se pelo 

número 36, e que poderá ser transformada em pés multiplicando-se pelo número 3, calcular e apresentar este 

valor convertido em pés e polegadas. 

Conforme o enunciado do programa devemos procurar identificar os elementos básicos do processamento 

de dados, ou seja, a entrada, o processamento e a saída de dados, fazendo algumas perguntas. Veja abaixo: 

Entrada de dados 

Pergunta: O que devemos ler? 

Resposta: Um número inteiro que represente o comprimento em jardas. 

Pergunta: Temos que ler mais alguma coisa? 

Resposta: Não 

Processamento de dados 

Pergunta: O que devemos fazer com esta informação lida? 

Resposta: Calcular a conversão de jardas para polegadas e pés. 

Pergunta: Como fazemos isto? 

Resposta: Matematicamente 1 jarda corresponde a 3 pés e 1 jarda corresponde a 36 polegadas. 

Devemos multiplicar o valor lido por 3 e obteremos a quantidade de pés. 

Também, multiplicar o valor lido por 36 e obteremos a quantidade de polegadas. 

Pergunta: Tem mais algum calculo para fazer? 


Saída de dados 

Pergunta: Depois de calcular a conversão o que devemos fazer? 

Resposta: Apresentar os valores convertidos. 

Pergunta: Tem mais alguma coisa para apresentar? 


Podemos então encerrar o programa. 

Estas são algumas considerações importantes, mas gostaria de ressaltar o seguinte: 

“Se todos os programadores fizessem o algoritmo do programa, antes de começar a codificar o programa, 

muitas dores de cabeça e tempo perdidos seriam eliminados, pois encontrar um erro de sintaxe da linguagem é 

fácil, mas encontrar um erro de lógica no programa é 10 vezes mais difícil”. 

Se você é um programador experiente, antes de codificar o programa, você faz o algoritmo, e ao fazelo 

você estará identificando, automaticamente os elementos do processamento de dados, que é a entrada o 

processamento e a saída.


exercícios de Fixação 

Desenvolva os exercícios abaixo: 

1. Faça um programa que leia e armazene em variáveis dois números inteiros quaisquer. Calcular e apresentar 

a soma entre eles. 

2. Faça um programa que leia e armazene em variáveis dois números em ponto flutuantes. Calcular e 

apresentar a diferença entre eles. 

3. Faça um programa que leia e armazene dois números quaisquer. Calcular e apresentar o produto entre 

eles. 

4. Faça um programa que leia e armazene em variáveis dois números inteiros quaisquer. Calcular e apresentar 

o resto da divisão de um pelo outro. 

5. Faça um programa que leia um número do tipo ponto flutuante e outro número inteiro. Calcular e apresentar 

a divisão do número do tipo ponto flutuante pelo número inteiro. 

6. Faça um programa que leia e armazene em variáveis quatro notas escolares (entre 0 e 10) de um aluno. 

Calcular e apresentar a média final do aluno. 

7. Faça um programa que leia e armazene em variáveis uma letra e um número. No final apresentar a letra 

e o número lido. 

8. Faça um programa que leia e armazene a idade de uma pessoa em anos. Calcular e apresentar a 

quantidade de dias, a quantidade de horas, a quantidade de minutos e de segundos desde o nascimento. 

9. Faça um programa que leia a receita e a despesa de uma empresa. Calcular e apresentar o seu lucro. 

10. Faça um programa que leia o número de identificação de um funcionário, o seu número de horas 

trabalhadas no mês, o valor que recebe por hora. Calcular o salário total deste funcionário, sabendo-se que ele 

é pago para trabalhar por hora. No final apresentar o salário total deste funcionário. 

exemplos de aula 

Na disciplina de lógica apresentamos alguns exemplos de aula que agora reproduzimos escritos em linguagem 

C para que você possa fazer uma comparação entre eles. 

Primeiro exemplo 

Desenvolver um programa que efetue o cálculo da área de uma circunferência, apresentando a área 

calculada. 

algoritmo 

Para efetuar o cálculo da área de uma circunferência é necessário conhecer a fórmula que executa este 

cálculo sendo esta: A = pR², em que A é a variável que conterá o resultado do cálculo da área, p é o valor de pi 

(3.14159), sendo uma constante na fórmula) e R o valor do raio. Sendo assim, basta estabelecer: 

1 – Ler um valor para o raio, no caso a variável R; 

2 – Estabelecer que PI possui o valor 3,14159; 

3 – Efetuar o cálculo da área, elevando ao quadrado o valor de R e multiplicando por PI; 

4 – Apresentar o valor da variável A. 

A fórmula para o cálculo da área passará a ser escrita como: A 3.14159 * R h 2 ou se você preferir poderá 

escrever da seguinte forma: A 3.14159 * R * R. 

18

Codificação em Linguagem C 

main( ) 

{ 

float A,R; 

clrscr( ); 

printf ( “digite o raio da circunferência: “ ); 

scanf ( “%f”, &r ); 

a = 3.14159 * r * r; 

printf ( “a área da circunferência e: %f”, a ); 

getch( ); 

} 

19 


segundo exemplo 

Construir um programa que efetue o cálculo do salário líquido de um professor. Para fazer este programa, você 

deverá possuir alguns dados, tais como: valor da hora aula, número de horas trabalhadas no mês e percentual de 

desconto do INSS. Em primeiro lugar, deve-se estabelecer qual será o seu salário bruto para efetuar o desconto 

e ter o valor do salário líquido. 

algoritmo 

1 – Estabelecer a leitura da variável HT (Horas trabalhadas no mês); 

2 – Estabelecer a leitura da variável VH (valor hora aula); 

3 – Estabelecer a leitura da variável PD (Percentual de desconto de INSS); 

4 – Calcular o salário bruto (SB), sendo este a multiplicação das variáveis HT e VH; 

5 – Calcular o total de desconto (TD) com base no valor de PD dividido por 100; 

6 – Calcular o salário líquido (SL), deduzindo o desconto do salário bruto; 

7 – Apresentar os valores dos salários bruto e líquido: SB e SL. 


main( ) 

{ 

int Ht; 

float VH, PD, TD, SB, SL; 

clrscr( ); 

printf(“digite a quantidade de horas trabalhadas no mes: “); 

scanf(“%d”, &Ht); 

printf(“digite o valor da hora aula: “); 

scanf(“%f”, &VH); 

printf(“digite o percentual de desconto do Inss: “); 

scanf(“%f”, &Pd); 

sB = Ht * VH; 

td = (Pd/100) * sB;


sL = sB - td; 

printf(“o valor do salario bruto e.....: %12.2f\n”, sB); 

printf(“o valor do salario liquido e...: %12.2f\n”, sL); 

getch( ); 

} 

exercícios de aula 

Abaixo são apresentados exercícios, sugiro que você os faça sem ver a solução pronta do mesmo, utilize a 

solução para verificar se você fez corretamente. 

Primeiro exercício 

Desenvolver um programa que leia dois valores numéricos e apresente o resultado da soma dos quadrados 

dos valores lidos. 

algoritmo 

1 – Ler um valor para a variável A e outro para a variável B; 

2 – Efetuar o cálculo do quadrado dos valores lidos, atribuindo os resultados as variáveis QA e QB; 

3 – Somar o quadrado dos valores lidos atribuindo o resultado a variável R; 

4 – Apresentar o valor da variável R. 


main( ) 

{ 

int a, B, Qa, QB, r; 

clrscr( ); 

printf(“digite um numero..................: “); 

scanf(“%d”, &a); 

printf(“digite outro numero..............: “); 

scanf(“%d”, &B); 

Qa = a * a; 

QB = B * B; 

r = Qa + QB; 

printf(“a soma dos quadrados e.....: %d”, r); 

getch( ); 

} 

segundo exercício 

Desenvolver um programa que apresente o resultado do cálculo da área de um trapézio. 

Algoritmo 

O cálculo da área do trapézio é: área = ( bMaior + bMenor * altura ) / 2, então: 

20


1 – Ler um valor para a base maior atribuindo a variável bMaior; 

2 – Ler um valor para a base menor atribuindo a variável bMenor; 

3 – Ler um valor para a altura atribuindo a variável altura; 

4 – Efetuar o cálculo da área atribuindo a variável area; 

5 – Apresentar o valor da variável area. 


main( ) 

{ 

float area, bMaior, bMenor, altura; 

clrscr( ); 

printf(“digite o valor da base maior...: “); 

scanf(“%f”, &bmaior); 

printf(“digite o valor da base menor...: “); 

scanf(“%f”, &bmenor); 

printf(“digite o valor da altura.......: “); 

scanf(“%f”, &altura); 

area = ((bmaior + bmenor) * altura) / 2; 

printf(“a area do trapezio e...........: %5.2f”, area); 

getch( ); 

} 

detalhes adicionais da Linguagem C 

Veremos agora alguns detalhes interessantes da Linguagem C. 

Operadores 

Já tínhamos visto os operadores aritméticos e de atribuição. Vamos agora complementar o assunto vendo os 

operadores de incremento e decremento, os operadores aritméticos de atribuição e os operadores relacionais. 

Operadores de incremento (+ +) e decremento (--) 

O operador de incremento (+ +) incrementa de um seu operando, ou seja, ele obtém o valor do operando e 

acrescenta um a este valor, é o somar mais um. 

Em um primeiro instante isto parece uma coisa difícil de se entender, mas analise o programa abaixo e verás 

que é muito fácil. 

main( ) 

{ 

int num; 

num = 2; 

printf(“Valor inicial = %d \n” , num); 

num = num + 1; 

printf(“novo valor = %d \n” , num); 

} 

21



• Na declaração int num; estamos declarando a variável inteira num. Na linha seguinte num = 2; estamos 

inicializando a variável com o número inteiro 2. 

• Na próxima linha printf(“Valor inicial = %d \n” , num); está sendo apresentado o valor inicial da variável 

num. 

• Na linha num = num + 1; estamos somando um ao valor inicial da variável num, e é isto que chamamos 

de incrementar (somar um), e então na última linha apresentamos o valor final de num que deverá ser: “três” 

Agora veja o mesmo programa, mas utilizando o operador de incremento. 

main( ) 

{ 

int num; 

num = 2; 

printf(“Valor inicial = %d \n” , num); 

num++; 


} 


• A única diferença deste programa para o anterior é a linha num++; onde estamos somando um ao valor 

inicial da variável num. 

Mas, haveria uma outra forma de escrever o mesmo programa, veja as alterações a seguir: 

main( ) 

{ 

int num; 

num = 2; 

printf(“Valor inicial = %d \n” , num++ ); 


} 

encontrou as diferenças? 

• Neste programa apagamos a linha num++; porque colocamos o incremento na linha anterior printf(“Valor 

inicial = %d \n” , num++ ); onde você deve notar que ao final da printf estamos usando o incremento do num++. 

Você deve estar se perguntando: “Mas não seria apresentado o valor 3 já na primeira printf?” E a resposta é: 

“Não, estamos usando a regra de precedência, neste programa primeiro ele apresenta o valor de num para 

depois incrementa-lo”. 

Este operador trabalha de dois modos. O primeiro modo é chamado pré-fixado e o operador aparece antes do 

nome da variável. O segundo modo é o pós-fixado em que o operador aparece seguindo o nome da variável. 

Em ambos os casos, a variável é incrementada. Porém quando ++num é usado numa instrução, num e 

incrementada antes de seu valor ser usado, e quando num++ estiver numa instrução, num é incrementada 

depois de seu valor ser usado. Veja o exemplo a seguir. 

22

main( ) 

{ 

int n,x; 

n = 5; 

x = n++; 

printf(“Valor de x = %d \n” , x); 

printf(“Valor de n = %d \n” , n); 

} 

23 


Veja o que aconteceu neste programa: 

• Na linha n = 5; atribuímos o valor 5 a variável n 

• Na linha seguinte x = n++; o valor de n é atribuído a x e depois n é incrementada de 1, tornando seu valor 

6. 

• Na primeira printf a saída será: Valor de x = 5 e na outra vai ser: Valor de n = 6 comprovando que quando 

o operador é pós-fixado ele incrementa o valor da variável depois de seu valor ser usado. 

Vejamos o mesmo exemplo utilizando agora o operador de incremento sendo utilizado pré-fixado. 

main( ) 

{ 

int n,x; 

n = 5; 

x = ++n; 

printf(“Valor de x = %d \n” , x); 

printf(“Valor de n = %d \n” , n); 

} 

Veja o que aconteceu neste programa: 

• Na linha n = 5; atribuímos o valor 5 a variável n 

• Na linha seguinte x = ++n; o valor de n é incrementada de 1 tornando seu valor 6, e atribuído a x. 

• Na primeira printf a saída será: Valor de x = 6 e na outra vai ser: Valor de n = 6 comprovando que quando 

o operador é pré-fixado ele incrementado de um e depois o seu valor ser usado. 

Operadores aritméticos de atribuição +=, -=, *=, /=, %= 

Nestes operadores é usado um nome de variável a sua esquerda e uma expressão a sua direita. A operação 

consiste em atribuir um novo valor a variável que dependerá do operador e da expressão à direita. 

Se n é uma variável, exp uma expressão e op um operador aritmético, então: 

n op= exp; 

Equivale a 

n = (n) op (exp);


Exemplos: 

i + = 2; equivale a i = i + 2; 

x *= y+1; equivale a x = x * (y+1); 

t /= 2.5; equivale a t = t / 2.5; 

p %= 5; equivale a p = p % 5; 

d -= 3; equivale a d = d - 3; 

Uma expressão com estes operadores são mais compactos e normalmente produzem um código de máquina 

mais eficiente. 

Exercícios de Fixação 

1. Analise o programa abaixo e informe os valores apresentados na tela: 

main( ) 

{ 

int a=1, b=2, c=3, d; 

d = a; 

printf(“%d \n” , d); /* valor de d: _________ */ 

d = b++; 


d = ++c; 


a += b; 

printf(“%d \n” , a); /* valor de a: _________ */ 

c *= b; 

printf(“%d \n” , c); 

} 

/* valor de c: _________ */ 

2. Assuma que todas as variáveis são do tipo int. Encontre o valor de cada uma delas e escreva um programa 

que as imprima para verificar os resultados: 

a) x = ( 2 + 1 ) * 6; 

b) y = ( 5 + 1 ) / 2 * 3; 

c) i = j = ( 2 + 3 ) / 4; 

d) a = 3 + 2 * ( b = 7 / 2 ); 

e) c = 5 + 10 % 4 / 2; 

3. Reescreva as seguintes instruções usando os operadores de incremento e decremento: 

num = num + 1; 

num = num – 1; 

24


4. Reescreva as seguintes instruções usando os operadores aritméticos de atribuição: 

num1 = num1 + num2; 

num2 = num2 – num1; 


main( ) 

{ 

int num=0; 

printf(“%d \n” , num); /* valor de num: _________ */ 

printf(“%d \n” , num++); /* valor de num: _________ */ 

printf(“%d \n” , num); 

} 

/* valor de num: _________ */ 


main( ) 

{ 

int num=0; 


printf(“%d \n” , ++num); /* valor de num: _________ */ 


} 



main( ) 

{ 

int num=0; 


printf(“%d \n” , - -num); /* valor de num: _________ */ 


} 


25



main( ) 

{ 

int num=0; 


printf(“%d \n” , num- -); /* valor de num: _________ */ 


} 



main( ) 

{ 

int num=0; 

num += 10; 


num += 10; 


} 


strings – um tipo especial de caracteres 

Em nosso primeiro programa colocamos na tela do computador, através da função printf uma seqüência de 

caracteres entre aspas “Meu primeiro programa”, lembra ? 

Havia escrito que podemos chamá-la de “cadeia de caracteres” ou de “String”. Usaremos, a partir deste 

momento, apenas “String”. 

String é uma das mais importantes formas de dados em C e é usada para armazenar e manipular textos como 

palavras, nomes e sentenças. 

String é um vetor unidimensional do tipo char terminada pelo caractere null. 

Composta de uma série de caracteres, a definição de string como sendo um vetor do tipo char é bastante 

razoável. 

Cada caractere de uma string pode ser acessado como um elemento do vetor o que proporciona uma grande 

flexibilidade aos programas que processam textos. 

Na string a seguir: “Alcides Maya” cada caractere ocupa um byte de memória e o último caractere é sempre 

‘\0´(null). Veja uma representação de como é uma string no computador: 

A l c I d e s M a y a \0 

No exemplo acima temos uma série de elementos do vetor de caracteres, sendo que o primeiro elemento, 

onde está a letra “A” é o elemento 0 (zero) do vetor. O segundo elemento, onde está a letra “l” é o elemento 1 (um) 

do vetor. O terceiro elemento, onde está a letra “c” é o elemento 2 (dois) do vetor e assim sucessivamente. 

A l c I d e s M a y a \0 

0 1 2 3 4 5 6 7 8 9 10 11 12 

26


Variáveis que armazenam uma string 

Uma das maneiras de receber uma string do teclado é através da função scanf( ) pelo formato %s. 

main( ) 

{ 

char nome[16]; 

printf(“digite seu nome: “); 

scanf(“%s” , &nome[0]); 

printf(“olá, %s, tudo bem?” , nome); 

} 


• Na declaração: char nome[16]; declaramos a variável nome do tipo char que tem um tamanho de 16 

caracteres, reservando o último elemento da string para o caracter \0 (null). 

• Na linha printf(“Digite seu nome: “); você encontra uma string entre as aspas 

• Na próxima linha scanf(“%s” , &nome[0]); temos a função scanf() que vai ler uma string e armazenar na 

variável nome. Você deve ter notado que usamos o operador & precedendo o segundo argumento de scanf() e 

também que estamos fazendo referência ao primeiro elemento do vetor [0]. Visto que o nome de um vetor é o 

seu endereço inicial poderíamos usar a scanf() da seguinte forma: scanf(“%s” , nome); que o resultado seria o 

mesmo. 

• Na última linha printf(“Olá, %s, tudo bem?” , nome); estamos apresentando o conteúdo do vetor. 

Lendo strings com a Função scanf() 

Ler uma string consiste em dois passos: reservar espaço de memória para armazená-la e usar alguma função 

que permita a sua entrada. 

O primeiro passo é declarar a string especificando o seu tamanho, sempre com um espaço a mais para o 

caracter \0 (null). 


Uma vez reservado o espaço necessário você pode usar a função scanf() para receber a string. A função 

scanf() é bastante limitada para a leitura de strings. 

Por exemplo, considere a seguinte execução do Exercício 26. 

Digite seu nome: Alcides Maya 

Olá, Alcides, tudo bem? 

O programa subitamente eliminou o último nome. 

Lembre-se de que scanf() usa qualquer espaço em branco para terminar a entrada. O resultado é que não 

existe uma forma de digitar um texto de múltiplas palavras numa única variável usando scanf(). 

A função scanf() é usada, principalmente para ler uma mistura de tipos de dados numa mesma instrução. 

Por exemplo, se em cada linha de entrada quisermos ler o nome de um material do estoque, o seu número do 

estoque e o seu preço, scanf() se adaptam perfeitamente. 

Lendo strings com a Função gets() 

A função gets() é bastante conveniente para a leitura de strings. 

O seu propósito é ler uma string da sua entrada padrão, que por “default” é o teclado. 

Visto que uma string não tem um tamanho predeterminado, gets( ) Iê caracteres até encontrar o de nova linha 

(´\n’) que é gerado pressionando-se a tecla [Enter]. Todos os caracteres anteriores ao ‘\n’ são armazenados na 

string e é então incluído o caractere ´\0´. 

Caracteres brancos como espaços e tabulações são perfeitamente aceitáveis como parte da string. Eis um 

27


exemplo simples: 

main( ) 

{ 


printf(“Digite seu nome: “); 

gets(nome); 

printf(“Olá, %s, tudo bem?” , nome); 

) 


• No programa anterior usamos scanf(“%s” , &nome[0]); mas agora, utilizamos gets(nome); que poderá ler 

mais de uma palavra separada por espaço em branco. A função gets( ) é exatamente o que procurávamos: agora 

o programa lembrará todo o nome. 

Agora ao digitarmos duas ou mais palavras, será armazenado o nome completo. 

Se forem digitadas as palavras “Alcides Maya”, teremos o resultado apresentado como no exemplo abaixo: 

Digite seu nome: Alcides Maya 

Olá, Alcides Maya, tudo bem? 

OBSERVAÇÃO: Se você digitar um nome maior que o espaço reservado para o string, (15 caracteres no 

programa acima) o programa segue armazenando os dados na memória do computador, sem fazer qualquer 

consistência em relação ao tamanho do string, podendo armazenar em cima da área de programa, que está na 

memória do computador. 

Experimente rodar o programa acima digitando as seguintes palavras: “Escola Técnica Alcides Maya”, e veja 

o que poderá acontecer. 

Inicializando strings 

O compilador oferece uma forma de inicialização de strings consideravelmente mais simples: 

char nome[ ] = “Ana”; 

Enquanto os caracteres simples são colocados entre aspas simples, a string é colocada entre aspas duplas. 

O uso da segunda forma causa a inclusão automática do caractere ‘\0´, ou seja teremos a seguinte string na 

memória. 

A n a \0 

0 1 2 3 

main( ) 

{ 

char nome[ ] = “alcides maya”; 

printf(“olá, %s, tudo bem?” , nome); 

} 

28



• Na linha char nome[ ] = “Alcides Maya”; estamos declarando a variável nome que é do tipo vetor de 

caracteres e já está sendo inicializada com o valor “Alcides Maya”, ele terá um tamanho de 13 caracteres, já 

contando o lugar reservado para o \0 (null). 


1. Faça um programa que leia o nome de 2 pessoas e armazene os nomes lidos (use a função scanf para ler 

os nomes). Depois escreva na tela os nomes lidos. 

2. Faça um programa que leia o nome de 2 pessoas e armazene os nomes lidos (use a função gets para ler 

os nomes). Depois escreva na tela os nomes lidos. 

3. Faça um programa que leia três frases. As frases deverão ser armazenadas e depois ser apresentadas na 

tela. 

4. Faça um programa que declare uma string de 80 caracteres de espaço em branco. Depois escrever 25 

printf´s que imprimam esta string na tela. O que acontece? 

5. Faça um programa que leia o teu nome, o nome da tua mãe e escreva na tela o teu nome e o nome da tua 

mãe, cada um em uma linha da tela. 

6. Quais das declarações de string está correta? 

( ) string nome[80]; 

( ) char nome(80); 

( ) char nome[80]; 

( ) char nome = 80; 

( ) Nenhuma alternativa acima 

7. Qual das funções é mais apropriada para ler uma string composta por várias palavras? 

( ) scanf 

( ) printf 

( ) puts 

( ) gets 


8. Assuma a seguinte inicialização: 

char nome[] = “Escola Alcides Maya”; 

Como você se refere à string “Maya” (as últimas 4 letras da string)? 

9. Qual é o erro da instrução abaixo? 

nome = “Alcides Maya”; 

29


10. Qual é o último caractere de uma string? 

( ) \n 

( ) \t 

( ) \s 

( ) \0 


4 estruturas de ControLe – a tomada de deCIsões 

Foi visto anteriormente como trabalhar com entrada, processamento e saída utilizando funções, variáveis e 

operadores. Apesar de já se conseguir solucionar problemas e transforma-los em programas, os recursos até 

aqui estudados são limitados, pois haverá momentos em que um determinado valor dentro de um programa 

necessitará ser tratado para se efetuar um processamento mais adequado. 

Imagine a seguinte situação: um programa que apresente a média escolar de um aluno. Até aqui, muito 

simples, mas além de calcular a média, o programa deve apresentar se ele está aprovado ou reprovado segundo 

a análise de sua média. 

Observe que aqui será necessário verificar a média do aluno para então tomar uma decisão no sentido de 

apresentar a sua real situação: aprovado ou reprovado. 

Tomar esta decisão implica em comparar a média com um valor numérico, e para realizar esta comparação 

utilizamos operadores relacionais que veremos a seguir. 

Operadores relacionais 

Os operadores relacionais são usados para fazer comparações. São eles: 

Operador Ação Exemplo Resultado 

> maior do que 5 > 2 V 

>= maior ou igual 5 >= 7 F 

< menor do que 5 < 7 V 

valor2) ); 

printf(“valor1 < valor2 é %d \n” , (valor1 < valor2) ); 

printf(“valor1 >= valor2 é %d \n” , (valor1 >= valor2) ); 

30

printf(“valor1 0) estamos testando o número digitado para saber se o mesmo é maior do que zero. Se 

o resultado desta expressão for verdadeira a linha printf (“O número digitado é positivo”); será executada. 

• Repare que o comando abaixo do if foi colocado alguns espaços mais para dentro da linha, este processo 

de codificação é chamado de “edentação”. Isto facilita a leitura de um programa em qualquer linguagem. Para 

o compilador não é necessário a edentar, mas para os programadores, quando estão depurando erros de 

programação, é extremamente útil.


exemplo de aula 


Desenvolver um programa que leia dois valores numéricos. Efetuar a adição e apresentar o seu resultado 

caso o valor somado seja maior que 10. 

algoritmo 

1 – Ler um valor para a variável A e outro valor para a variável B; 

2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X; 

3 – Apresentar o valor da soma contido na variável X, caso o valor de X seja maior que 10. 


main( ) 

{ 

int a,B,x; 

clrscr( ); 

printf ( “digite um número: “ ); 

scanf ( “%d”, &a ); 

printf ( “digite outro número: “ ); 

scanf ( “%d”, &B ); 

x = a + B; 

if ( x > 10 ) 

printf ( “a soma dos números ée: %d “, x ); 

getch( ); 

} 

desvio Condicional Composto 

O comando if-else, onde o if significa “se” e o else significa “senão” é utilizado para fazer um “Desvio 

Condicional Composto”. 

Sua forma geral é: 

if (expressão) 

comando_1; 

else 

comando_2; 

Onde a expressão é avaliada; se for verdadeira (isto é, se a expressão tiver um valor diferente de zero), o 

comando_1 é executado. Se for falsa (isto é, se a expressão tiver um valor igual a zero) e se houver uma parte 

else, o comando_2 é executado. 

Continuaremos o estudo do “if-else” com um programa simples, que lê um número do teclado e escreve na 

tela de seu computador se o número digitado é positivo ou se é negativo. 

32

main( ) 

{ 

int num; 

printf (“digite um número: “ ); 

scanf (“%d” , &num); 

33 


if (num > 0) 

printf (“o número digitado é positivo”); 

else 

printf (“o número digitado é negativo”); 

} 


• Declaramos uma variável numérica do tipo inteiro e pedimos para o usuário digitar um número. 

• Na linha if (num > 0) estamos testando o número digitado para saber se o mesmo é maior do que zero. Se 

o resultado desta expressão for verdadeira a linha printf (“O número digitado é positivo”); será executada. 

• Na linha else (senão for um número maior do que zero) estamos indicando para o programa executar a 

linha printf (“O número digitado é negativo”); 

exemplo de aula 


Desenvolver um programa que ler dois valores numéricos e efetuar a adição. Caso o valor somado seja maior 

ou igual a 10, deverá ser apresentado somando a ele mais 5; caso o valor somado não seja maior ou igual a 10, 

este deverá ser apresentado subtraindo 7. 

algoritmo 

1 – Ler um valor para a variável A e outro valor para a variável B; 

2 – Efetuar a soma dos valores incógnitos A e B, atribuindo o valor da soma na variável X; 

3 – Verificar se X é maior ou igual a 10; caso seja verdadeiro, calcule R x + 5. Senão calcule R X – 7. 


main( ) 

{ 

int a,B,x,r; 

clrscr( ); 

printf ( “digite um numero: “ ); 

scanf ( “%d”, &a ); 

printf ( “digite outro numero: “ ); 

scanf ( “%d”, &B ); 

x = a + B; 

if ( x >= 10 ) 

r = x + 5;


else 

r = x - 7; 

printf ( “o resultado do calculo e: %d “, r ); 

getch( ); 

} 

múltiplos comandos dentro de um if 

Quando desejamos agrupar comandos, criando um bloco de comandos, utilizamos o abre chaves “{“ e fecha 

chaves “}” para encapsular estes comandos. 

No if é a mesma coisa, caso vários comandos sejam necessários no corpo do comando if, eles devem estar 

entre chaves. 

Sua forma geral é: 

if (expressão) 

{ 

comando_11; 

comando_12; 

comando_13; 

} 

else 

{ 

comando_21; 

comando_22; 

} 

Onde a expressão é avaliada; se for verdadeira os comando_11, comando_12 e o comando_13 são 

executados. Se for falsa o comando_21 e o comando_22 são executados. 

O programa abaixo dá um exemplo de como encapsulamos comandos. 

main( ) 

{ 

int num; 

printf (“digite um número: “ ); 

scanf (“%d” , &num); 

if (num > 0) 

{ 

printf (“o número “); 

printf (“digitado é “); 

printf (“positivo”); 

} 

34

else 

{ 

printf (“o número digitado é “); 

printf (“negativo”); 

} 

} 


Vamos fazer alguns exercícios 

35 


1. FUP que leia dois números quaisquer, e escreva o maior deles. 

2. FUP que leia dois números quaisquer, e escreva o menor deles. 

3. FAÇA UM PROGRAMA que leia dois números quaisquer, e escreva o resultado do cálculo do maior 

dividido pelo menor. 

4. FAÇA UM PROGRAMA que leia a receita e a despesa de uma empresa e apresente se ela está com 

LUCRO ou com PREJUÍZO. 

5. FAÇA UM PROGRAMA que leia 4 notas escolares de um aluno. Calcule e apresente a média. Sabendo-se 

que a média de aprovação da escola é 7, apresente a informação se o aluno foi APROVADO ou REPROVADO. 

6. FAÇA UM PROGRAMA que leia dois números e apresente o sinal do produto entre eles. Considere que 

somente números diferentes de zero serão digitados. 

7. FAÇA UM PROGRAMA que leia um número e escreva “maior do que 100”, se o número digitado for maior 

que 100 e escreva “menor do que 100”, se o número for menor do que 100. 

8. FAÇA UM PROGRAMA que leia um código:1 – sinal vermelho, 2 – sinal verde. Baseado no código digitado 

diga para o pedestre que está esperando no sinal:“SIGA” ou “ESPERE” 

9. FAÇA UM PROGRAMA que leia a quantidade de vitórias e a quantidade de derrotas de um time de futebol. 

Escrever BOM se o número de vitórias for maior que o número de derrotas, caso contrário escrever RUIM. 

desvio Condicional encadeado 

Existem casos em que é necessário estabelecer verificação de condições sucessivas, em que uma determinada 

ação poderá ser executada se um conjunto anterior de instruções ou condições for satisfeito. Sendo a ação 

executada, ela poderá ainda estabelecer novas condições. Isto significa utilizar uma condição dentro de outra 

condição. Este tipo de estrutura poderá possuir diversos níveis de condição, sendo chamadas de aninhamentos 

ou encadeamentos. 



Desenvolver a lógica para um programa que efetue o cálculo do reajuste de salário de um funcionário. 

Considere que o funcionário deverá receber um reajuste de 15% caso seu salário seja menor que 500. Se o 

salário for maior ou igual a 500, mas menor ou igual a 1000, seu reajuste será de 10%; caso seja ainda maior 

que 1000, o reajuste deverá ser de 5%”. 

algoritmo 

Perceba que o problema em questão estabelece três condições para calcular o reajuste do salário do 

funcionário, sendo: 

• Salário 500, mas 1000, reajuste será de 5% 

Estas condições deverão ser encadeadas, pois todas as possibilidades de reajuste deverão ser cercadas. 

Sendo assim, observe o algoritmo abaixo:


1 – Definir uma variável para o salário reajustado: novo_salario; 

2 – Ler um valor para a variável salário; 

3 – Verificar se o valor de salario


3 - FAÇA UM PROGRAMA que leia o código de uma mercadoria e que escreva o nome do produto conforme 

tabela abaixo: 

1 – Sabão 

2 – Vassoura 

3 – Detergente 

4 - FAÇA UM PROGRAMA que leia dois números e o código de uma operação matemática (+, -, *, /) e que 

apresente o resultado da operação. Por exemplo: se forem digitados os números [2] e [5] e a operação [-], será 

apresentado o resultado [-3]. 

Operadores Lógicos 

Os operadores lógicos, como o próprio nome diz, avaliam uma expressão lógica e retornam valores também 

lógicos, ou seja, verdadeiro ou falso. 

Em várias ocasiões na tomada de decisões temos que usar os operadores lógicos. 

Os operadores lógicos mais comuns são: .e., .ou., .não., representados em português estruturado, mas que 

em linguagem C são respectivamente &&, ||, !. 

A tabela seguinte apresenta todos os operadores lógicos da linguagem C: 

Operador Representação Descrição 

&& .e. 

verdadeiro. 

Efetua a operação lógica E. Se ambas as expressões forem verdadeiras, então o resultado será 

|| .ou. Efetua a operação OU. Se uma das expressões (ou ambas) for verdadeira, então o resultado 

será verdadeiro. 

! .não. Efetua a operação lógica NÃO. Inverte o estado lógico de uma expressão; se ela for verdadeira, 

tona-a falsa e vice-versa. 

Para entender melhor como funcionam os operadores lógicos, vamos analisar cada um deles. 

O Operador Lógico && 

O operador lógico && (.E.) pode ser visto como um conector lógico. Imagine que você possua dois fios ligados 

a uma lâmpada e a uma bateria. A lâmpada somente acenderá se você tiver ligado ambos os fios aos pólos da 

bateria. Acompanhe esse exemplo no seguinte diagrama: 

Fio vermelho ligado Frio preto ligado Lâmpada acende 

Falso Falso Falso 

Verdadeiro Falso Falso 

Falso Verdadeiro Falso 

Verdadeiro Verdadeiro Verdadeiro 

Exemplos de Aula 


Desenvolver um programa que leia um número. Informar se o número digitado está na faixa de 20 a 90. 

Algoritmo 

1 – Ler um valor para a variável num; 

2 – Se o valor digitado estiver na faixa de 20 a 90 apresentar uma mensagem informando. 

37



main( ) 

{ 

int num; 

clrscr( ); 

printf ( “Digite um número: “ ); 

scanf ( “%d”, &num ); 

if (num >= 20 && num 0 e < 90, se for verdade: “ângulo está no primeiro quadrante” 

3 – Verificar se o ângulo digitado é > 90 e < 180, se for verdade: “ângulo está no segundo quadrante” 

4 – Verificar se o ângulo digitado é > 180 e < 270, se for verdade: “ângulo está no terceiro quadrante” 

5 – Verificar se o ângulo digitado é > 270 e < 360, se for verdade: “ângulo está no quarto quadrante” 


main( ) 

{ 

int angulo; 

clrscr( ); 

printf ( “Digite um angulo: “ ); 

scanf ( “%d”, &angulo ); 

if (angulo > 0 && angulo < 90) 

printf ( “Angulo no primeiro quadrante” ); 

else 


printf ( “Angulo no segundo quadrante” ); 

else 


printf ( “Angulo no terceiro quadrante” ); 

else 

38


printf ( “Angulo no quarto quadrante” ); 

getch( ); 

} 

39 


Operador Lógico: .ou. 

O operador do tipo .ou. é utilizado quando pelo menos um dos relacionamentos lógicos (quando houver mais 

de um relacionamento) de uma condição necessita ser verdadeiro. Abaixo, é apresentada a tabela de decisão 

para este tipo de operador: 

Condição 1 Condição 2 Resultado 

Falsa Falsa Falso 

Verdadeira Falsa Verdadeiro 

Falsa Verdadeira Verdadeiro 

Verdadeira Verdadeira Verdadeiro 

Considere agora, como exemplo, que você deseja escrever uma carta. Se você tiver uma máquina de escrever 

ou (OR) um microcomputador, pode tranqüilamente satisfazer seu desejo. Acompanhe o diagrama em seguida: 

Exemplos de Aula 

Tem máquina Tem computador Pode escrever 

Falso Falso Falso 

Verdadeiro Falso Verdadeiro 

Falso Verdadeiro Verdadeiro 

Verdadeiro Verdadeiro Verdadeiro 


Desenvolver um programa que leia o código relativo ao sexo (masculino=1 ou feminino=2). Se for digitado um 

código correto informar que o código é válido, caso contrário informar que o código é inválido. 

Algoritmo 

1 – Ler um código numérico para a variável codigo; 

2 – Se o código digitado for igual a 1 ou igual a 2 apresentar uma mensagem informando que o código é válido 

caso contrário informar que o código é inválido.



main( ) 

{ 

int codigo; 

clrscr( ); 

printf( “digite 1 - para sexo masculino\n” ); 

printf( “digite 2 - para sexo feminino: “ ); 

scanf( “%d”, &codigo ); 

if ( codigo == 1 || codigo == 2 ) 

printf ( “o código do sexo e válido” ); 

else 

printf ( “o código do sexo e inválido” ); 

getch( ); 

} 

o operador lógico .ou. é escrito em C através do operador | | (barra,barra). 

operador Lógico: .não. 

O operador do tipo .não. é utilizado quando houver necessidade de estabelecer a inversão do resultado 

lógico de uma determinada condição. Se a condição for verdadeira, será considerada falsa. Se a condição for 

falsa, será considerada verdadeira. Abaixo, é apresentada a tabela de decisão para este tipo de operador: 

Condição Resultado 

Falsa Verdadeiro 

Falsa Verdadeiro 

Considere agora, como exemplo, que se você possui um carro e o pneu está furado, você não (NOT) pode 

viajar. É o que mostra a tabela abaixo: 



Pneu está furado Pode viajar 

Falso Verdadeiro 

Verdadeiro Falso 

Desenvolver a lógica para um programa que somente efetue o cálculo de C (A + B) * X, se o valor da 

variável X não for maior que 5. Qualquer valor de 5 para baixo efetuará o cálculo C (A + B) * X. 

Se forem informados os valores 5, 1 e 2, respectivamente, para as variáveis A, B e X, resultará para a 

variável C o valor 12, pois o valor 2 da variável X é controlado pela instrução se .não. (X > 5) então, como 

sendo verdadeiro, uma vez que não é maior que 5. Sendo assim, os valores 5 e 1 são somados resultando 6 e 

multiplicados por 2 resultando 12. 

Mas se forem informados os valores 5, 1 e 6, respectivamente, para as variáveis A, B e X, resultará para a 

variável C o valor 24, pois o valor 6 da variável X é controlado pela instrução se. não. (X > 5) então, como sendo 

falso. Sendo assim, os valores 5 e 1 são subtraídos resultando 4 e multiplicados por 6 resultando 24. 

40


algoritmo 

1 – Ler um valor numérico para a variável A ,B, X; 

2 – Se .não. (X > 5) então calcular: C (A + B) * X caso contrário calcular: C (A – B) * X 

3 - Apresentar o valor do resultado do cálculo. 


main( ) 

{ 

int A, B, C, X; 

clrscr( ); 

printf( “\nDigite um numero qualquer.....: “); 

scanf ( “%d”,&A ); 

printf( “\nDigite outro numero qualquer..: “); 

scanf ( “%d”,&B ); 

printf( “\nDigite mais um numero qualquer: “); 

scanf ( “%d”,&X ); 

if ( !(X > 5) ) 

C = (A + B) * X; 

else 

C = (A - B) * X; 

printf ( “O resultado do calculo e: %d”, C ); 

getch( ); 

} 

O operador lógico .não. é escrito em C através do operador ! (exclamação). 


Primeiro exercício 

Ler três valores para os lados de um triângulo, considerando lados como: A, B e C. Verificar se os lados 

fornecidos formam realmente um triângulo, e se for esta condição verdadeira, deverá ser indicado qual tipo de 

triângulo foi formado: isósceles, escaleno ou eqüilátero. 

algoritmo 

Para estabelecer este algoritmo, é necessário em primeiro lugar saber o que realmente é um triângulo. Se 

você não souber o que é um triângulo, conseqüentemente não conseguirá resolver o problema. 

Triângulo é uma forma geométrica (polígono) composta por três lados, sendo que cada lado é menor que 

a soma dos outros dois lados. Perceba que isto é uma regra (uma condição) e deverá ser considerada. É um 

triângulo quando A


Se não, verificar se A=B ou A=C ou B=C, sendo verdade o triângulo é isósceles; caso contrário, o triângulo 

é escaleno. 

3 – Caso os lados fornecidos não caracterizem um triângulo, avisar a ocorrência. 


main( ) 

{ 

float A, B, C; 

clrscr( ); 

printf( “Digite um lado do triangulo.....: “ ); 

scanf (“%f”,&A ); 

printf( “Digite outro lado do triangulo..: “ ); 

scanf (“%f”,&B ); 

printf( “Digite o outro lado do triangulo: “ ); 

scanf (“%f”,&C ); 

if ( A 

if ( A == B && B == C ) 

printf (“Triangulo eqüilátero”); 

else 

if ( A == B || A == C || C == B ) 

printf (“Triangulo Isósceles”); 

else 

printf (“Triangulo Escaleno”); 

else 

printf( “As medidas não formam um triangulo” ); 

getch( ); 

} 


1 - FAÇA UM PROGRAMA que leia as coordenadas de um ponto no plano (x,y) e escreva o quadrante ao 

qual pertence o ponto no plano. No primeiro quadrante x e y são positivos. No segundo quadrante y é positivo. 

No terceiro quadrante nem x nem y é positivo. No quarto quadrante x é positivo. 

2 - FAÇA UM PROGRAMA que leia o QI de uma pessoa e escreva uma mensagem baseada na tabela abaixo. 

Observe que os colchetes identificam um intervalo fechado e os parênteses identificam um intervalo aberto. 

[ 000, 030 ) - Ameba 

[ 030, 050 ) - Débil Mental 

[ 050, 070 ) - Regular 

[ 070, 100 ) - Normal 

[ 100, 150 ] - Gênio 

Outros - QI inválido 

42


3 - FAÇA UM PROGRAMA que leia três notas de uma pessoa. Calcular a média e apresentar um conceito 

conforme a tabela abaixo: 

[ 10, 09 ] - A 

( 09, 07 ] - B 

( 07, 04 ] - C 

( 04, 00 ] - D 

4 - A empresa XYZ & Cia Ltda decidiu conceder um aumento de salários a seus funcionários de acordo com 

a tabela abaixo: 

saLárIo atuaL índICe de aumento 

De 0 até 400 15% 

Acima de 400 até 700 12% 




Acima de 2500 0% 

FAÇA UM PROGRAMA que leia o número do funcionário, o seu salário atual. Calcular e apresentar o valor 

do salário já corrigido. 

5 estruturas de ControLe – Laços de rePetIção 

Como já foi visto na disciplina de Lógica de Programação, existem ocasiões em que é necessário efetuar 

a repetição de um trecho de programa um determinado número de vezes. Neste caso, poderá ser criado um 

looping que efetue o processamento de um determinado trecho, tantas vezes quantas forem necessárias. Os 

loopings também são chamados de laços de repetição. 

Vamos agora implementar estas estruturas em linguagem C. 

Por exemplo, imagine um programa que peça a leitura de um valor para a variável num, multiplique esse valor 

por 3, colocando a resposta na variável result e apresente o valor obtido, repetindo esta seqüência por cinco 

vezes, conforme mostrado abaixo: 


main( ) 

{ 

int num, result; 

printf(“\nDigite um número: “); 


result = num * 3; 

printf(“\nO número multiplicado por 3 é: %d” , result); 





43













printf(“\nO valor digitado multiplicado por 3 é: %d” , result); 

} 

Para estes casos existem comandos apropriados para efetuar a repetição de determinados trechos de 

programas o número de vezes que for necessário. A principal vantagem deste recurso é que o programa passa 

ater um tamanho menor, podendo sua amplitude de processamento ser aumentada sem alterar o tamanho do 

código de programação. Desta forma, pode-se determinar repetições com números variados de vezes. 

repetição do tipo: teste Lógico no início do looping 

Caracteriza-se por uma estrutura que efetua um teste lógico no início de um looping, verificando se é permitido 

executar o trecho de instruções subordinado a esse looping. A estrutura em questão é denominada de enquanto, 

sendo conseguida com a utilização do conjunto de instruções enquanto...faça...fim_enquanto. 

A estrutura enquanto...faça...fim_enquanto tem o seu funcionamento controlado por decisão. Sendo assim, 

poderá executar um determinado conjunto de instruções enquanto a condição verificada for Verdadeira. No 

momento em que esta condição se torna Falsa, o processamento da rotina é desviado para fora do looping. Se 

a condição for Falsa logo de início, as instruções contidas no looping são ignoradas. 

No início desta aula fizemos um programa que fazia a leitura de um valor para a variável num, multiplicava 

esse valor por 3, colocando a resposta na variável result e apresentava o valor obtido, repetindo esta seqüência 

por cinco vezes, porque não conhecíamos a estrutura enquanto...faça...fim_enquanto, agora vamos fazer o 

mesmo exemplo utilizando a estrutura para o controle do laço de repetição. 



Desenvolver um programa que faça a leitura de um valor para a variável num, multiplique esse valor por 3, 

colocando a resposta na variável result e apresentar o valor obtido, repetindo esta seqüência por cinco vezes. 

algoritmo 

1 – Criar uma variável para servir de contador com valor inicial 1; 

2 – Enquanto o valor do contador for menor ou igual a 5, processar os passos 3, 4, 5 e 6 


4 – Efetuar a multiplicação do valor de num por 3, atribuindo o resultado em result; 

5 – Apresentar o valor calculado contido na variável result; 

6 – Acrescentar +1 a variável do tipo contador, definida no passo 1; 

7 – Quando contador for maior que 5, encerrar o processamento do looping. 

44


main( ) 

{ 

int num, result, cont; 

clrscr( ); 

cont = 1; 

while ( cont



main( ) 

{ 

int num,result; 

char resp; 

clrscr( ); 

resp = ‘S’; 

while( resp == ‘S’ ) 

{ 

printf ( “\nDigite um numero: “ ); 



printf ( “O numero multiplicado por 3 e: %d \n”, result ); 

printf ( “Deseja continuar? “ ); 

resp = getch( ); 

} 

} 


Utilizando a estrutura while os exercícios abaixo: 

1. FAÇA UM PROGRAMA que escreva na tela os números de 0 até 20. 

2. FAÇA UM PROGRAMA que escreva na tela os números pares de 0 até 20. 

3. FAÇA UM PROGRAMA que escreva na tela os números de 20 até 0 

4. FAÇA UM PROGRAMA que leia 10 valores inteiros e escreva no final a soma dos valores lidos. 

5. FAÇA UM PROGRAMA que leia 10 valores inteiros e escreva no final a média dos valores lidos. 

6. FAÇA UM PROGRAMA que leia 20 valores e escreva no final a soma dos valores positivos e a média dos 

negativos. 

7. FAÇA UM PROGRAMA que leia números até que o usuário não queira mais digitar os números. No final 

escrever a soma dos valores positivos e a soma dos valores negativos. 

Repetição do tipo: Teste Lógico no fim do looping 

A estrutura em questão é denominada de repita, sendo conseguida com a utilização do conjunto de instruções 

repita...até_que. 

A estrutura repita...até_que tem o seu funcionamento controlado por decisão. Porém, irá efetuar a execução de 

um conjunto de instruções pelo menos uma vez antes de verificar a validade da condição estabelecida. Diferente 

da estrutura enquanto que executa somente um conjunto de instruções, enquanto a condição é verdadeira. 

Desta forma repita tem seu funcionamento em sentido contrário a enquanto, pois sempre irá processar um 

conjunto de instruções no mínimo uma vez até que a condição se torne verdadeira. Para a estrutura repita um 

conjunto de instruções é executado enquanto a condição se mantém Falsa até que ela seja Verdadeira. 





É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação entre as 

estruturas. 

46


algoritmo 

1 – Criar uma variável para servir de contador com valor inicial 1; 




5 – Acrescentar +1 a variável do tipo contador, definida no passo 1; 

6 – Repita os passos 2, 3, 4 e 5 até que o contador seja maior que 5. 


main( ) 

{ 


int cont; 

clrscr( ); 

cont = 1; 

do 

{ 

printf ( “\ndigite um numero: “ ); 



printf ( “o numero multiplicado por 3 e: %d \n”, result ); 

cont = cont + 1; 

} 

while ( cont



main( ) 

{ 


char resp; 

clrscr( ); 

do 

{ 

printf ( “\nDigite um numero: “ ); 



printf ( “O numero multiplicado por 3 e: %d \n”, result ); 

printf ( “Deseja continuar? “ ); 

resp = getch( ); 

} 

while( resp == ‘S’ ); 

} 


Vamos fazer alguns exercícios 


escrever a soma dos valores lidos. 


escrever a média dos valores lidos. 


escrever a soma dos valores positivos e a soma dos valores negativos. 


escrever a soma dos valores positivos e a média dos valores negativos. 

repetição do tipo: Variável de Controle 

Anteriormente, foram vistas duas formas de elaborar looping. Uma usando o conceito enquanto e a outra 

usando o conceito repita. Foi visto também como elaborar rotinas que efetuaram a execução de um looping um 

determinado número de vezes com a utilização de um contador (por meio de uma variável de controle). 

Porém, existe uma possibilidade de facilitar o uso de contadores finitos sem fazer uso das duas estruturas 

anteriores, deixando-as para utilização de loopings em que não se conhece de antemão o número de vezes que 

uma determinada seqüência de instruções deverá ser executada. Os loopings que possuem um número finito de 

execuções poderão ser processador por meio de estrutura de laços contados do tipo para, sendo conseguida 

com a utilização do conjunto de instruções para...de...até...passo...faça...fim_para. 

A estrutura para...de...até...passo...faça...fim_para tem o seu funcionamento controlado por uma variável 

denominada contador. Sendo assim, poderá executar um determinado conjunto de instruções um determinado 

número de vezes. 





É o mesmo exemplo utilizado na estrutura enquanto para que você possa fazer uma comparação entre as 

estruturas. 

48


algoritmo 

1 – Definir um contador, variando de 1 a 5; 




5 – Repitir os passos 2, 3, 4 e 5 até que o contador seja encerrado. 


main( ) 

{ 


int cont; 

clrscr( ); 

for( cont=1; cont


terceiro exemplo 

Desenvolver um programa que escreva na tela os números de 10 até 1. 

Repare que estamos desejando escrever os números na seguinte seqüência: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1. 

Algoritmo 

1 – Definir um contador, variando de 10 a 1; 

2 – Apresentar o valor contido na variável contador; 

5 – Repitir o passo 2 até que o contador seja encerrado. 


main( ) 

{ 

int cont; 

clrscr( ); 

for( cont=10; cont


Neste programa o usuário é quem vai determinar o fim da leitura das notas, ou seja, você deverá perguntar 

ao usuário se ele deseja continuar digitando notas. 

10 - FAÇA UM PROGRAMA que leia códigos e execute tarefas, conforme tabela abaixo: 

0 – Encerra o programa 

1 – Inclui uma unidade no estoque 

2 – Exclui uma unidade no estoque 

3 – Mostra o total disponível no estoque 

4 – Mostra o total de entradas no estoque 

5 – Mostra o total de saídas no estoque 

Outro código escrever: “Código Inválido” 

11 - FAÇA UM PROGRAMA para controlar o acesso de pessoas a um restaurante. O restaurante possui uma 

capacidade de 40 vagas, que não poderá ser ultrapassada. O controle se dará através de códigos, conforme a 

tabela: 

0 – FIM 

1 – ENTRA UMA PESSOA (escrever: “Entrou”) 

2 – SAI UMA PESSOA (escrever: “Saiu”) 

3 – MOSTRAR QUANTOS LUGARES ESTÃO DISPONÍVEIS 

4 – MOSTRAR O TOTAL DE PESSOAS QUE ENTRARAM 

5 – MOSTRAR O TOTAL DE PESSOAS QUE SAÍRAM 

Outro código escrever: “Código Inválido” 

12 - FAÇA UM PROGRAMA que calcule o desconto do imposto de renda. O programa deverá perguntar 

quando a pessoa deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). O programa deve pedir 

o valor do salário, calcular e apresentar o valor do desconto baseado na seguinte informação: 

Salário até R$ 900,00 é isento (Não paga imposto de renda) 

Salário acima de R$ 900,00 até R$ 1.800,00 para 15% de imposto de renda 

Salário acima de R$ 1.800,00 para 27% de imposto de renda 

13 - FAÇA UM PROGRAMA que leia o peso das pessoas que querem entrar em um elevador. A capacidade 

máxima do elevador é de 15 pessoas ou 800 Kg, o que ocorrer primeiro. O programa deve ler o peso da pessoa 

que deseja entrar, se a sua entrada não fizer com que seja ultrapassado qualquer um dos limites, deverá escrever: 

“PODE ENTRAR”, caso contrário, ou seja, ultrapassando os limites, deverá escrever: “NÃO PODE ENTRAR: 

ELEVADOR LOTADO” e encerrar o programa, mostrando o número de pessoas transportadas e o peso total 

transportado. 

14 - FAÇA UM PROGRAMA que leia dois números e a operação desejada ( + , - , * , / ) e que escreva na 

tela o resultado da operação. O programa depois de apresentar o resultado deverá perguntar quando a pessoa 

deseja encerrar o programa (“Deseja fazer outro cálculo? (S/N)”). Se a reposta for S deverá pedir outros 

números e a operação desejada, se a resposta for N deverá encerrar o programa. 

15 - Em uma fábrica de chocolates, foi designado ao programador, fazer um programa que calcule o desconto 

de INSS dos funcionários. Este programa deve ler o nome do funcionário e o valor do salário bruto. Calcular o 

desconto do INSS levando em consideração o seguinte: 

f) Para salários até R$ 500,00 a alíquota de INSS será de 8% 

g) Para salários acima de R$ 500,00 até R$ 1.000,00 a alíquota de INSS será de 10% 

h) Para salários acima de R$ 1.000,00 a alíquota de INSS será de 12% 

Para cada funcionário deverá ser apresentado na tela: 

a) Nome do Funcionário 

b) Salário Bruto 

c) Taxa de INSS 

d) Valor de INSS 

e) Salário Líquido 

Após estas apresentações o programa deverá fazer uma pergunta: “Deseja fazer mais algum cálculo? (S/N)”, 

se a resposta for afirmativa o programa deverá continuar com os dados do próximo funcionário, caso contrário 

51


deverá ser terminado. 

16 - FAÇA UM PROGRAMA que possibilite calcular a área total de uma residência (sala, cozinha, banheiro, 

quartos, área de serviço, quintal, garagem, etc). O programa deve solicitar a entrada do nome, a largura e 

o comprimento de um determinado cômodo. Em seguida, deve apresentar a área do cômodo lido e também 

uma mensagem solicitando do usuário a confirmação de continuar calculando novos cômodos. Caso o usuário 

responda que “NÃO”, o programa deve apresentar o valor total acumulado da área residencial. 

6 estruturas de dados Homogêneas I 

Durante os pontos estudados em Desvios condicionais e Estruturas de repetição, percebeu-se que o poder de 

programação tornou-se maior, antes limitado somente ao que foi estudado em técnicas básicas de programação. 

Porém, tendo o domínio das técnicas anteriores, ainda correr-se-á o risco de não conseguir resolver alguns tipos 

de problemas, pois foram trabalhadas até aqui apenas variáveis simples que somente armazenam um valor por 

vez. 

Vamos agora apresentar uma técnica de programação que permitirá trabalhar como o agrupamento de várias 

informações dentro de uma mesma variável, sendo sempre do mesmo tipo de dado, e por esta razão é chamado 

de estrutura de dados homogênea. 

A utilização deste tipo de estrutura de dados recebe diversos nomes, como: variáveis indexadas, variáveis 

compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou arrays (do inglês). São 

vários os nomes encontrados, a que nós iremos tratar por matrizes. 

matrizes de uma dimensão ou vetores 

Este tipo de estrutura é conhecida como matrizes unidimensionais ou também de vetor. Caracteriza-se por 

ser definida uma única variável dimensionada com um determinado tamanho. A dimensão de uma matriz é 

constituída por uma constante inteira positiva. Os nomes dados às matrizes seguem as mesmas regras de 

nomes utilizados para identificar as variáveis simples. 

Para ter uma idéia de como utilizar matrizes em uma determinada situação considere o seguinte problema: 

“Em uma Escola Técnica de Informática, há um professor que faz 6 avaliações durante o semestre. Gostaríamos 

de fazer um programa que leia as 6 notas de um aluno. No final calcular e apresentar a média do aluno”. 

Desta forma será necessário somar as 6 notas de cada aluno e calcular a sua média. A tabela a seguir 

apresenta um aluno, suas notas bimestrais e a coluna da média do aluno que deverá ser calculada. 

Aluno Nota 1 Nota 2 Nota 3 Nota 4 Nota 5 Nota 6 Média 

1 4.0 6.0 5.0 3.0 7.5 4.0 ? 

Agora basta escrever um programa para efetuar o cálculo da média de cada aluno. 

Vamos começar pelo cálculo da média de cada aluno, iremos representar as notas de cada aluno pelas 

variáveis: nota1, nota2, nota3, nota4, nota5, nota6, e para o cálculo da média a variável media, todas do tipo 

real. 

algoritmo 

1 – Ler as notas do aluno para as variáveis nota1, nota2, nota3, nota4, nota5, nota6; 

2 – Efetuar a soma das notas e a divisão delas por 6, atribuindo o seu resultado para a variável media; 

3 – Apresentar o valor da variável media após a operação de soma e divisão dos valores fornecidos. 

Com o conhecimento adquirido até este momento, seria então elaborado um programa que efetuaria a leitura 

de cada nota, a soma delas e a divisão do valor da soma por 6, obtendo-se desta forma a média do aluno. 

52


main( ) 

{ 

float nota1; 

float nota2; 

float nota3; 

float nota4; 

float nota5; 

float nota6; 

float soma; 

float media; 

printf( “Digite a nota 1: “ ); 

scanf( “%f” , &nota1 ); 











soma = nota1 + nota2 + nota3 + nota4 + nota5 + nota6; 

media = soma / 6; 

printf ( “A média do aluno foi: %f \n” , media ); 

} 

53 


Perceba que para receber as notas foram utilizadas 6 variáveis. Com a técnica de matrizes poderia ter sido 

utilizada apenas uma variável com a capacidade de armazenar 6 valores. 

operações básicas com matrizes de uma dimensão 

Uma matriz de uma dimensão ou vetor será representada por seu nome e seu tamanho (dimensão) entre 

colchetes. Desta forma seria uma matriz nota[6], sendo seu nome nota, possuindo um tamanho de 6. 

Isto significa que poderão ser armazenados em nota até 6 elementos. Perceba que na utilização de variáveis 

simples existe uma regra: uma variável somente pode conter um valor por vez. No caso das matrizes, poderão 

armazenar mais de um valor por vez, pois são dimensionadas exatamente para este fim. Desta forma poderse-á 

manipular uma quantidade maior de informação com pouco trabalho de processamento. Deve-se apenas 

considerar que com relação à manipulação dos elementos de uma matriz, eles ocorrerão de forma individualizada, 

pois não é possível efetuar a manipulação de todos os elementos do conjunto ao mesmo tempo. 

No caso do exemplo do cálculo da média do aluno, ter-se-ia então uma única variável indexada (a matriz) 

contendo todos os valores das 8 notas. Isto seria representado da seguinte forma:


nota[0] = 4.0 

nota[1] = 6.0 

nota[2] = 5.0 

nota[3] = 3.0 

nota[4] = 7.5 

nota[5] = 4.0 

Observe que o nome é um só. O que muda é a informação indicada dentro dos colchetes. 

A esta informação dá-se o nome de índice, sendo este o endereço em que o elemento está armazenado. É 

necessário que fique bem claro que o elemento é o conteúdo da matriz, neste caso os valores das notas. No caso 

de nota[0] = 4.0, o número 0 é o índice; o endereço onde cujo elemento é 4.0 está armazenado. 

atribuição de uma matriz 

Anteriormente, foram utilizadas várias instruções para poder definir e montar um programa. No caso da 

utilização de matrizes, será definida a instrução conjunto que indicará em português estruturado a utilização 

de uma matriz, tendo como sintaxe: conjunto[] de , sendo que será a 

indicação dos valores inicial e final do tamanho do vetor e se o vetor em questão utilizar valores 

reais, inteiros, lógicos ou caracteres. 

Leitura de dados de uma matriz 

A leitura de uma matriz é processada passo a passo, um elemento por vez. A instrução de leitura é leia seguida 

da variável mais o índice. A seguir, são apresentados o fluxograma e a codificação em português estruturado da 

leitura das notas dos alunos, cálculo da média e a sua apresentação. 


main( ) 

{ 

float nota[6]; 

float soma; 

float media; 

int indice; 

clrscr( ); 

soma = 0; 

for( indice = 0; indice < 6; indice++ ) 

{ 

printf ( “digite a nota %d do aluno: “, indice+1 ); 

scanf ( “%f”, &nota[indice] ); 

soma = soma + nota[indice]; 

} 


printf ( “a media do aluno e: %4.1f”, media ); 

getch( ); 

} 

Observe que na linguagem C o índice começa com o valor zero, pois o endereço do primeiro elemento da 

matriz em C é zero, o endereço do segundo elemento da matriz em C é um e assim sucessivamente. 

54


A tabela a seguir, mostra como ficarão os valores armazenados na matriz em linguagem C: 

matriz: nota 

índice elemento 

0 4.0 

1 6.0 

2 5.0 

3 3.0 

4 7.5 

5 4.0 

esCrIta dos dados de uma matrIz 

O processo de escrita de uma matriz é bastante parecido com o processo de leitura de seus elementos. Para 

esta ocorrência deverá ser utilizada a instrução escreva seguida da indicação da variável e seu índice. 

Supondo que após a leitura das 6 notas, houvesse a necessidade de apresenta-las antes da apresentação 

do valor da média. Abaixo são apresentados o fluxograma e a codificação em português estruturado da escrita 

das 6 notas antes de ser apresentado o cálculo da média. 


main( ) 

{ 

float nota[6]; 

float soma; 

float media; 

int indice; 

clrscr( ); 

soma = 0; 


{ 

printf ( “digite a nota %d do aluno: “, indice+1 ); 

scanf ( “%f”, &nota[indice] ); 

soma = soma + nota[indice]; 

} 



printf ( “a nota %d do aluno e: %4.1f \n”, indice+1, nota[índice] ); 

printf ( “a media do aluno e: %4.1f”, media ); 

getch( ); 

} 


Para demonstrar a utilização de uma matriz em um exemplo um pouco maior, considere como problemas os 

exemplos apresentados em seguida: 

55



Desenvolver um programa que efetue a leitura de dez elementos de uma matriz A tipo vetor. Construir uma 

matriz B de mesmo tipo, observando a seguinte lei de formação: se o valor do índice for par, o valor deverá ser 

multiplicado por 5, sendo ímpar, deverá ser somado com 5. Ao final mostrar o conteúdo da matriz A e B 

algoritmo 

Este exemplo de resolução estará mostrando como fazer o tratamento da condição do índice. 

1 – Iniciar o contador de índice, variável índice como 1 em um contador até 10; 

2 – Ler os 10 valores, um a um; 

3 – Verificar se o índice é par se sim multiplica por 5, se não soma 5. Criar a matriz B; 

4 – Apresentar o conteúdo das duas matrizes. 

Deverá ser verificado se o valor do índice em um determinado momento é par (ele será par quando dividido 

por 2 obtiver resto igual a zero). Sendo a condição verdadeira, será atribuído na matriz B[índice] a multiplicação 

do elemento da matriz A[índice] por 5. Caso o valor do índice seja ímpar, será atribuído na matriz B[índice] a 

soma do elemento da matriz A[índice] por 5. 


main( ) 

{ 

int matriza[10]; 

int matrizB[10]; 

int indice; 

int resp; 

clrscr( ); 


{ 

printf ( “digite um valor numerico inteiro: “ ); 

scanf ( “%d”, &matriza[indice] ); 

} 


{ 

resp = indice %; 

if ( resp == 0 ) 

matrizB[indice] = matriza[indice] * 5; 

else 

matrizB[indice] = matriza[indice] + 5; 

} 


printf ( “\nConteudo da matriz a indice %d = %d”, indice, matriza[indice] ); 


printf ( “\nConteudo da matriz B indice %d = %d”, indice, matrizB[indice] ); 

getch( ); 

} 

56

segundo exemplo 

57 


Desenvolver um programa que efetue a leitura de dez elementos de uma matriz A do tipo vetor. No final, 

apresente o total da soma de todos os elementos que sejam ímpares. 

algoritmo 

Perceba que em relação ao primeiro exemplo, este apresenta uma diferença: o primeiro pedia para verificar 

se o índice era par ou ímpar. Neste exemplo, está sendo solicitado que analise a condição do elemento e não 

do índice. Já foi alertado anteriormente para se tomar cuidado para não confundir elemento com índice. Vamos 

a solução: 

1 – Iniciar o contador de índice, variável índice como 1 em um contador até 10; 

2 – Ler os 10 valores, um a um; 

3 – Verificar se o elemento é ímpar; se sim efetuar a soma dos elementos; 

4 – Apresentar o total somado de todos os elementos ímpares da matriz. 

Observe que quando se faz menção ao índice indica-se a variável que controla o contador de índice, e no 

caso do exemplo anterior, a variável índice. Quando se faz menção ao elemento, indica-se matrizA[índice] pois 

desta forma está se pegando o valor armazenado e não a sua posição de endereço. 


main( ) 

{ 

int matriza[10]; 

int indice; 

int resp; 

int soma; 

clrscr( ); 

soma = 0; 


{ 

printf ( “digite um valor numerico inteiro: “ ); 

scanf ( “%d”, &matriza[indice] ); 

} 


{ 

resp = matriza[indice] % 2; 

if ( resp == 1 ) 

soma = soma + matriza[indice]; 

} 

printf ( “\na soma dos elementos ímpares é: %d” , soma ); 

getch( ); 

}



1 – Desenvolva os algoritmos, seus respectivos fluxogramas e proceda a codificação em português estruturado 

os seguintes programas: 

2. Faça um programa para ler 10 elementos de uma matriz tipo vetor e apresenta-los 

3. Faça um programa para ler 8 elementos em uma matriz A tipo vetor. Construir uma matriz B de mesma 

dimensão com os elementos da matriz A multiplicados por 3. O elemento B[1] deverá ser atribuído pelo elemento 

A[1] * 3, o elemento B[2] atribuído pelo elemento A[2] * 3 e assim por diante, até 8. Apresentar a matriz B. 

4. Faça um programa para ler duas matrizes A e B com 20 elementos. Construir uma matriz C, onde cada 

elemento de C é a soma do elemento correspondente de A com B. Apresentar a matriz C. 

5. Faça um programa que leia 15 elementos de uma matriz A do tipo vetor. Construir uma matriz B de mesmo 

tipo, observando a seguinte lei de formação: “Todo elemento de B deverá ser o quadrado do elemento de A 

correspondente”. Apresentar as matrizes A e B. 

6. Faça um programa para ler uma matriz A do tipo vetor com 15 elementos. Construir uma matriz B de 

mesmo tipo, sendo que cada elemento da matriz B seja o fatorial do elemento correspondente da matriz A . 

Apresentar as matrizes A e B. 

7. Faça um programa para ler duas matrizes A e B com 15 elementos cada. Construir uma matriz C, sendo 

esta a junção das duas outras matrizes. Desta forma C deverá ter o dobro de elementos, ou seja 30. Apresentar 

a matriz C. 

8. Faça um programa para ler duas matrizes do tipo vetor, sendo A com 20 elementos e B com 30 elementos. 

Construir uma matriz C, sendo esta a junção das duas outras matrizes. Desta forma C deverá ter a capacidade 

de armazenar 50 elementos. Apresentar a matriz C. 

9. Faça um programa para ler 20 elementos de uma matriz A tipo vetor e construir uma matriz B de mesma 

dimensão com os mesmos elementos da matriz A, sendo que deverão estar invertidos. Ou seja, o primeiro 

elemento de A passa a ser o último de B, o segundo elemento de A passa a ser o penúltimo de B e assim por 

diante. Apresentar as matrizes A e B. 

10. Faça um programa para ler três matrizes (A, B e C) de uma dimensão com 5 elementos cada. Construir 

uma matriz D, sendo esta a junção das três outras matrizes. Desta forma D deverá ter o triplo de elementos, ou 

seja 15. Apresentar os elementos da matriz D. 

11. Faça um programa para ler uma matriz A do tipo vetor com 20 elementos. Construir uma matriz B do 

mesmo tipo da matriz A, sendo que cada elemento de B seja o somatório do elemento correspondente da matriz 

A . Se o valor do elemento de A[1] for 5, B[1] deverá ser 10, se o valor do elemento de A[2] for 7, B[2] deverá ser 

14 e assim por diante. 

12. Faça um programa para ler uma matriz A do tipo vetor com 10 elementos. Construir uma matriz B do 

mesmo tipo da matriz A, sendo que cada elemento de B deverá ser o valor negativo do elemento correspondente 

da matriz A . Desta forma, se o valor do elemento de A[1] for 8, B[1] deverá ser -8, se o valor do elemento de A[2] 

for 3, B[2] deverá ser -3 e assim por diante. 

13. Faça um programa para ler uma matriz A tipo vetor com 10 elementos. Construir uma matriz B de mesmo 

tipo, sendo que cada elemento de B deverá ser a metade de cada elemento de A . Apresentar os elementos das 

matrizes A e B. 

14. Faça um programa que efetue o cálculo de uma tabuada de um número qualquer e armazene os resultados 

em uma matriz A de uma dimensão para 10 elementos. Apresentar os valores armazenados na matriz. 

15. Ler 20 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão 

do tipo vetor. O programa deverá apresentar a menor, a maior e a média das temperaturas lidas. 

16. Ler 25 elementos (valores reais) para temperaturas em graus Celsius em uma matriz A de uma dimensão 

do tipo vetor. Construir uma matriz B de mesmo tipo e dimensão, em que cada elemento da matriz B deverá 

ser a conversão da temperatura em graus Fahrenheit do elemento correspondente da matriz A . Apresentar os 

elementos das matrizes A e B. 

17. Ler 12 elementos inteiros para uma matriz A de uma dimensão do tipo vetor. Construir uma matriz B de 

mesmo tipo e dimensão, observando a seguinte lei de formação: “Todo elemento da matriz A que for ímpar deverá 

ser multiplicado por 2 e armazenado na matriz B; caso contrário, o elemento da matriz A deverá ser armazenado 

na matriz B sem nenhum cálculo”. Apresentar os elementos das matrizes A e B. 

18. Ler 15 elementos reais para uma matriz A de uma dimensão do tipo vetor. Construir uma matriz B de 

mesmo tipo e dimensão, observando a seguinte lei de formação: “Todo elemento da matriz A que possuir índice 

par deverá ter seu elemento dividido por 2; caso contrário, o elemento da matriz A deverá ser multiplicado por 

1.5”. Apresentar os elementos das matrizes A e B. 

58


19. Faça um programa que leia uma matriz numérica de 10 elementos. No final apresentar quantos números 

são positivos e quantos são negativos 

20. Faça um programa que leia uma matriz numérica de 10 elementos. No final encontrar nesta matriz o 

maior valor lido, apresentando a sua posição na matriz e o seu valor. 


menor valor lido, apresentando a sua posição na matriz e o seu valor. 


maior valor lido e o menor valor lido 

23. Faça um programa que leia uma matriz numérica chamada notas de 10 elementos. Ler valores para o 

vetor e, após ter lido, determinar a media dos valores contidos no vetor 

24. Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa que leia 

as notas destas provas para um vetor notas. No final calcular e apresentar a média do aluno e o resultado obtido 

conforme a tabela a seguir: 

[00,05) - Reprovado 

[05,07) - Recuperação 

[07,09) - Satisfatório 

[09,10] - Ótimo 

7 estruturas de dados Homogêneas II 

No capítulo anterior trabalhamos com o agrupamento de várias informações dentro de uma mesma variável, 

de mesmo tipo de dado, chamada de estrutura de dados homogênea, ou seja, matrizes, do tipo vetor. Agora 

iremos trabalhar com uma estrutura um pouco mais complexa, também chamada de matrizes, mas de mais de 

uma dimensão. 

matrizes com mais de uma dimensão 

Anteriormente, houve contato com o uso de uma única variável indexada com apenas uma dimensão (uma 

coluna e várias linhas), quando foi utilizado o exemplo para efetuar o cálculo da média do aluno. A partir deste 

ponto, serão apresentadas tabelas com mais colunas, sendo assim, teremos variáveis no sentido horizontal e 

vertical. 

Com o conhecimento adquirido até este ponto, você tem condições suficientes para elaborar um programa 

que leia as notas dos alunos, calcule a média de cada aluno e no final apresente a média de toda a turma, 

utilizando-se de matrizes bidimensionais. 

Porém, cuidado, é necessário manter um controle de cada índice em cada matriz para um mesmo aluno. 

Para facilitar o trabalho com estruturas deste porte é que serão utilizadas matrizes com mais dimensões. A 

mais comum é a matriz de duas dimensões por se relacionar diretamente com a utilização de tabelas. 

Matrizes com mais de duas dimensões são utilizadas com menos freqüência, mas poderão ocorrer em 

momentos em que se necessite trabalhar com um número maior de dimensões, porém estas são fáceis de 

utilizar, se estivermos dominando bem a utilização de uma matriz com duas dimensões. 

É importante considerar que na manipulação de uma matriz unidimensional é utilizada uma única instrução 

de looping. No caso de matrizes com mais dimensões, deverão ser utilizadas o número de loopings relativo ao 

tamanho de sua dimensão. Desta forma, uma matriz de duas dimensões deverá ser controlada com dois loopings 

de três dimensões deverá ser controlada por três loopings e assim por diante. 

Em matrizes de mais de uma dimensão os seus elementos são também manipulados de forma individualizada, 

sendo a referência feita sempre por meio de dois índices; o primeiro para indicar a linha e o segundo para indicar 

a coluna. 

Para você ter uma idéia de como utilizar matrizes de duas dimensões vamos utilizar o mesmo exemplo 

que usamos no capítulo anterior, mas agora com um número maior de alunos: “Em uma Escola Técnica de 

Informática, há um professor que faz 4 avaliações durante o semestre. Gostaríamos de fazer um programa que 

leia as 4 notas de cada aluno da turma (turma com 8 alunos), calcule e apresente a média de cada aluno.”. 

59


Veja como ficaria nossa tabela com as notas e as médias de cada aluno: 

aluno nota 1 nota 2 nota 3 nota 4 

1 4.0 6.0 5.0 3.0 

2 6.0 7.0 5.0 8.0 

3 9.0 8.0 9.0 6.0 

4 3.0 5.0 4.0 2.0 

5 4.0 6.0 6.0 8.0 

6 7.0 7.0 7.0 7.0 

7 8.0 7.0 6.0 5.0 

8 6.0 7.0 2.0 9.0 

Operações básicas com matrizes de duas dimensões 

Uma matriz de duas dimensões está sempre fazendo referência a linhas e a colunas e é representada por 

seu nome e seu tamanho (dimensão) entre colchetes. 

Desta forma é uma matriz de duas dimensões nota[8][4] , onde seu nome é nota, possuindo um tamanho de 

8 linhas e 4 colunas, ou seja, é uma matriz de 8 por 4 (8 x 4). Isto significa que podem ser armazenados em nota 

até 32 elementos. 

Para armazenar as 4 notas do primeiro aluno deveríamos fazer algo como visto abaixo: 

nota[0] [0] = 4.0 

nota[0] [1] = 6.0 

nota[0] [2] = 5.0 

nota[0] [3] = 3.0 

Observe que o nome é um só. O que muda é a informação indicada dentro dos colchetes. No primeiro 

colchete está a informação da linha e no segundo colchete está a informação da coluna. 

Para armazenar as 4 notas do segundo aluno deveríamos fazer o seguinte: 

nota[1] [0] = 6.0 

nota[1] [1] = 7.0 

nota[1] [2] = 5.0 

nota[1] [3] = 8.0 

Para armazenar as 4 notas do terceiro aluno deveríamos fazer o seguinte: 

nota[2] [0] = 9.0 

nota[2] [1] = 8.0 

nota[2] [2] = 9.0 

nota[2] [3] = 6.0 

E assim sucessivamente até que se armazene as notas de todos os oito alunos. 

Atribuição de uma Matriz 

Uma matriz de duas dimensões é atribuída pela instrução conjunto já utilizada para definir o uso de uma 

matriz de uma dimensão, sendo bastante parecidas em sua referência. 

A sintaxe é: variável : conjunto[:] de , sendo que e 

são a indicação do tamanho da tabela e o tipo da matriz, que poderá ser formada 

por valores reais, inteiros, lógicos ou caracteres. 

60


Leitura de dados de uma matriz 

A leitura de uma matriz de duas dimensões, assim como das matrizes de uma dimensão é processado passo 

a passo, um elemento por vez. A instrução de leitura é leia seguida da variável mais os seus índices. A seguir, 

são apresentados o fluxograma e a codificação em português estruturado da leitura das notas dos alunos, cálculo 

da média e a sua apresentação. 

Observe que está sendo considerada a leitura de 4 notas de 8 alunos. Assim sendo, a tabela em questão 

armazena 32 elementos. Um detalhe a ser considerado é a utilização de duas variáveis para controlar os dois 

índices de posicionamento de dados na tabela. Anteriormente, utilizamos a variável índice para controlar as 

posições dos elementos dentro da matriz, ou seja, a posição em nível de linha. Neste exemplo a variável índice 

passa a ser tratada como lin, controlando a posição da linha, e a segunda variável será tratada como col, 

controlando a posição da coluna. Muitos programadores utilizam i no lugar de lin e utilizam j no lugar de col. 

Analisando o fluxograma, temos a inicialização das variáveis lin e col como 1, ou seja, a leitura será efetuada 

na primeira linha da primeira coluna. Em seguida é iniciado em primeiro lugar o looping da variável lin para 

controlar a posição em relação às linhas e depois é iniciado o looping da variável col para controlar a posição em 

relação às colunas. 

Veja que, ao serem iniciados os valores para o preenchimento da tabela, eles são colocados na posição 

nota[1,1], lembrando que o primeiro valor dentro dos colchetes representa a linha e o segundo representa a 

coluna. 

Será digitado então, para o primeiro aluno a primeira nota. Depois é incrementado mais 1 em relação à 

coluna, sendo colocada para a entrada a posição nota[1,2], linha 1 coluna 2. Desta forma, será digitado para o 

primeiro aluno a segunda nota. 

Quando o contador de coluna atingir o valor 4, ele será encerrado e será efetuado o cálculo e a apresentação 

da média. Em seguida o contador da variável lin será incrementado com mais 1, tornando-se 2. Será então 

inicializado novamente o contador col em 1, permitindo que seja digitado um novo dado na posição nota[2,1]. 

O mecanismo de preenchimento estender-se-á até que o contador de linhas atinja o seu último valor, no 

caso 8. Esse looping é o principal, tendo a função de controlar o posicionamento na tabela por aluno. O segundo 

looping, mais interno, controla o posicionamento das notas. 


main( ) 

{ 

float nota[8][4]; 

float soma, media, valor; 

int lin, col; 

clrscr( ); 

for( lin = 0; lin < 8; lin++ ) 

{ 

soma = 0; 

for( col = 0; col < 4; col++ ) 

{ 

printf ( “digite a nota %d do aluno %d : “, col+1, lin+1 ); 

scanf ( “%f”, &valor ); 

nota[lin][col] = valor; 

soma = soma + nota[lin][col]; 

} 

61



printf ( “a media do aluno e: %4.1f \n”, media ); 

} 

getch( ); 

} 


Para demonstrar a utilização de uma matriz de duas dimensões, considere os exemplos apresentado sem 

seguida: 


Desenvolver um programa que efetue a leitura das receitas e despesas dos primeiros 6 meses de uma 

empresa. Calcular e armazenar o resultado mensal da empresa. 

Algoritmo 

1 – Ler as receitas de cada mês 

2 – Ler as despesas de cada mês 

3 – Calcular o resultado de cada mês subtraindo a receita da despesa 

4 – Apresentar as receitas, as despesas e o resultados de cada mês 

Pela característica do programa a ser desenvolvido, seria ideal utilizarmos uma matriz 3 x 6, para armazenar 

estes dados. Nas colunas teremos os meses, nas linhas teremos respectivamente receitas, despesas e resultados, 

veja o desenho a seguir: 

Receitas 

Despesas 

Resultados 

Janeiro Fevereiro Março Abril Maio Junho 


main( ) 

{ 

float caixa[3][6]; 

float valor; 

int lin, col; 

clrscr( ); 

lin = 0; 

for( col = 0; col < 6; col++ ) 

{ 

printf ( “digite a receita do mes %d: “, col+1 ); 


caixa[lin][col] = valor; 

} 

lin = 1; 

for( col = 0; col < 6; col++ ) 

62

{ 

printf ( “digite a despesa do mes %d: “, col+1 ); 


caixa[lin][col] = valor; 

} 

for( col = 0; col < 6; col++ ) 

caixa[2][col] = caixa[0][col] - caixa[1][col]; 

for( col = 0; col < 6; col++ ) 

{ 

printf ( “a receita do mes %d e: %.2f \n”, col+1, caixa[0][col] ); 

printf ( “a despesa do mes %d e: %.2f \n”, col+1, caixa[1][col] ); 

printf ( “o resultado do mes %d e: %.2f \n”, col+1, caixa[2][col] ); 

} 

getch( ); 

} 



1 – Desenvolva os algoritmos, seus respectivos fluxogramas e proceda a codificação em português estruturado 

os seguintes programas: 

1. Faça um programa para ler duas matrizes A e B, cada uma de duas dimensões com 5 linhas e 3 colunas. 

Construir uma matriz C de mesma dimensão, que é formada pela soma dos elementos da matriz A com os 

elementos da matriz B. Apresentar a matriz C. 

2. Faça um programa para ler duas matrizes A e B, cada uma com 7 elementos. Construir uma matriz C, de 

duas dimensões, em que a primeira coluna deverá ser formada pelos elementos da matriz A e a segunda coluna 

deverá ser formada pelos elementos da matriz B. Apresentar a matriz C. 

3. Faça um programa para ler 20 elementos para uma matriz qualquer, considerando que ela tenha o tamanho 

de 4 linhas por 5 colunas, em seguida apresentar a matriz. 

4. Faça um programa para ler uma matriz A de uma dimensão com 10 elementos. Construir uma matriz 

C de duas dimensões com três colunas, em que a primeira coluna da matriz C é formada pelos elementos da 

matriz A somados com mais 5, a segunda coluna é formada pelo valor do cálculo da fatorial de cada elemento 

correspondente da matriz A e a terceira e última coluna deverá ser formada pelos quadrados dos elementos 

correspondentes da matriz A . Apresentar a matriz C. 

5. Faça um programa para ler duas matrizes A e B, cada uma com uma dimensão pra 12 elementos. Construir 

uma matriz C de duas dimensões, sendo que a primeira coluna da matriz C deverá ser formada pelos elementos 

da matriz A multiplicados por 2 e a segunda coluna deverá ser formada pelos elementos da matriz B subtraídos 

de 5. Apresentar a matriz C. 

6. Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 4 colunas. Construir uma matriz 

B de mesma dimensão, onde cada elemento da matriz B deverá ser o fatorial de cada elemento correspondente 

da matriz A . Apresentar ao final as matrizes A e B. 

7. Faça um programa para ler uma matriz A de duas dimensões com 4 linhas e 5 colunas, armazenando 

nessa matriz os valores das temperaturas em graus Celsius. Construir uma matriz B de mesma dimensão, 

sendo que cada elemento da matriz B deverá ser o valor da temperatura em graus Fahrenheit de cada elemento 

correspondente da matriz A . Apresentar ao final as matrizes A e B. 

8. Faça um programa para ler uma matriz A de duas dimensões com 5 linhas e 5 colunas. Construir uma 

matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o dobro de cada elemento 

correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[2,2], 

B[3,3], B[4,4] e B[5.5] ) os quais deverão ser o triplo de cada elemento correspondente da matriz A . Apresentar 

63


ao final a matriz B. 


matriz B de mesma dimensão, sendo que cada elemento da matriz B deverá ser o somatório de cada elemento 

correspondente da matriz A, com exceção para os valores situados na diagonal principal (posições B[1,1], B[3,3], 

B[5.5] e B[7,7] ) os quais deverão ser o fatorial de cada elemento correspondente da matriz A . Apresentar ao final 

a matriz B. 


matriz B de mesma dimensão, que deverá ser formada do seguinte modo: para cada elemento par da matriz A 

deverá ser somado 5 e para cada elemento ímpar da matriz A deverá ser subtraído 4. Apresentar ao final a matriz 

A e B. 

11. Faça um programa para ler uma matriz A de duas dimensões com 4 linhas e 4 colunas. Apresentar o 

somatório dos elementos situados na diagonal principal (posições A[1,1], A[2,2], A[3,3], A[4.4] ) da referida 

matriz. 

12. Faça um programa que leia uma matriz A de duas dimensões com 15 linhas e 15 colunas. Apresentar o 

somatório dos elementos pares situados na diagonal principal da referida matriz. 

13. Faça um programa que leia uma matriz A de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar 

o total de elementos pares existentes dentro da matriz. 

14. Faça um programa que leia uma matriz de duas dimensões com 7 linhas e 7 colunas. Ao final apresentar 

o total de elementos positivos, o total de elementos negativos e o total de elementos cujo valor é zero. 

15. Faça um programa que leia uma matriz numérica de duas dimensões de 5 linhas e 8 colunas. No final 

encontrar e apresentar desta matriz o maior valor lido e o menor valor lido. 

16. Faça um programa que leia uma matriz de duas dimensões com 5 linhas e 5 colunas. Apresentar o 

somatório dos elementos positivos situados na diagonal principal da referida matriz. 

8. PRogRAMAção ESTRuTuRADA 

Funções I 

A partir desta aula serão estudados a aplicação e o uso de Funções. 

Quando aprendemos conceitos de sub-rotinas em algoritmos, também falávamos sobre Funções. 

Estas sub-rotinas também são conhecidas pela denominação de módulos, sub-programas, ou subalgoritmos. 

Na linguagem C as sub-rotinas são tratadas como FUNÇÕES. 

Na realidade, não importa como são chamadas, o que importa é a forma como funcionam e como devem ser 

aplicadas em um programa, e é isto que iremos aprender a partir deste momento. 

Iremos rever o conceito de criação estruturada de programas, pois para escrever um programa de computador 

necessita-se de estudo (levantamento de todas as necessidades e detalhes do que deverá ser feito) e metodologia 

(regras básicas que deverão ser seguidas). 

Sem a aplicação de métodos não será possível resolver grandes problemas; quando muito, pequenos 

problemas. 

as sub-rotinas 

No geral, problemas complexos exigem algoritmos complexos. Mas sempre é possível dividir um problema 

grande em problemas menores. Desta forma, cada parte menor tem um algoritmo mais simples, e é esse trecho 

menor que é chamado de sub-rotina. Uma sub-rotina é na verdade um programa, e sendo um programa poderá 

efetuar diversas operações computacionais (entrada, processamento e saída) e deverá ser tratada como foram 

os programas projetados até este momento. As sub-rotinas são utilizadas na divisão de algoritmos complexos, 

permitindo assim possuir a modularização de um determinado problema, considerado grande e de difícil 

solução. 

Quando trabalhamos com esta técnica, pode-se deparar com a necessidade de dividir uma sub-rotina em 

outras tantas quantas forem necessárias, buscando uma solução mais simples de uma parte do problema maior. 

O processo de dividir sub-rotinas em outras é denominado Método de Refinamento Sucessivo. 

64


o método top-down 

Desde muito tempo este é um dos processos mais simples e mais utilizados pelos programadores. 

O processo de programar um computador torna-se bastante simples quando aplicado o método de utilização 

de sub-rotinas (módulos de programas). Porém, a utilização dessas sub-rotinas deverá ser feita com aplicação 

do método top down. 

Um método bastante adequado para a programação de um computador é trabalhar com o conceito de 

programação estruturada, pois a maior parte das linguagens de programação utilizadas atualmente também é, o 

que facilita a aplicação deste processo de trabalho. 

O método mais adequado para a programação estruturada é o Top-Down (De cima para baixo) o qual se 

caracteriza basicamente por: 

• Antes de iniciar a construção do programa, o programador deverá ter em mente as tarefas principais que 

este deverá executar. Não é necessário saber como funcionarão, somente saber quantas são. 

• Conhecidas todas as tarefas a serem executadas, tem-se em mente como deverá ser o programa principal, 

o qual vai controlar todas as outras tarefas distribuídas em suas sub-rotinas. 

• Tendo definido o programa principal, é iniciado o processo de detalhamento para cada sub-rotina. Desta 

forma são definidos vários algoritmos, um para cada rotina em separado, para que se tenha uma visão do que 

deverá ser executado em cada módulo de programa. Existem programadores que estabelecem o número máximo 

de linhas de programa que uma rotina deverá possuir. Se o número de linhas ultrapassa o limite preestabelecido, 

a rotina em desenvolvimento é dividida em outra sub-rotina (é neste ponto que se aplica o método de refinamento 

sucessivo). 

o método top-down faz com que o programa tenha uma estrutura semelhante a um organograma. 

A utilização do método “de cima para baixo” permite que seja efetuado cada módulo de programa em 

separado. Desta forma, cada um pode ser testado separadamente garantindo que o programa completo esteja 

sem erro ao seu término. 

Outro detalhe a ser considerado é que muitas vezes existem em um programa trechos de códigos que são 

repetidos várias vezes. Esses trechos poderão ser utilizados como sub-rotinas, proporcionando um programa 

menor e mais fácil de ser alterado num futuro próximo. 

A utilização de sub-rotinas e o uso do método Top-Down na programação permitem ao programador elaborar 

rotinas exclusivas. Por exemplo, uma rotina somente para entrada, outra para a parte de processamento e outra 

para saída dos dados. 

aplicação prática do uso de sub-rotinas 

As sub-rotinas podem ser subdivididas em dois tipos: Procedimentos e Funções. Entre estes dois tipos de 

sub-rotinas existem algumas diferenças, mas o conceito é o mesmo para ambas. 

Um Procedimento é um bloco de programa contendo início e fim e será identificado por um nome, por meio 

do qual será referenciado em qualquer parte do programa principal ou do programa chamador da rotina. 

Quando uma sub-rotina é chamada por um programa, ela é executada e ao seu término o controle de 

processamento retorna automaticamente para a primeira linha de instrução após a linha que efetuou a chamada 

de sub-rotina. 

Uma função também é um bloco de programa, como são os procedimentos, contendo inicio e fim e sendo 

identificada por um nome, por meio do qual também será referenciada em qualquer parte do programa principal. 

Uma sub-rotina de função é na verdade muito parecida com uma sub-rotina de procedimento. A sua principal 

diferença está no fato de uma função retornar um determinado valor. 

As funções formam o alicerce da programação em C. Você faz toda a programação C dentro de uma função, 

porque todos os programas devem incluir main, que é uma função. 

Em outras linguagens como Pascal, são utilizados procedimentos e funções, FORTRAN utiliza somente 

funções e a linguagem Assembly utiliza somente procedimentos. 

A linguagem C utiliza somente funções com e sem retorno de valores, tornando-se um pouco diferente na 

qualificação de sub-rotinas e funções, conforme a lógica de programação. 

Mas, não se preocupe, isto não irá mudar a forma como você vai trabalhar na linguagem C. 

Exercício de Aula 

65


Vamos criar um programa de calculadora que apresente um menu de seleções no programa principal. Esse 

menu deverá dar ao usuário a possibilidade de escolher uma entre quatro operações aritméticas. Escolhida a 

opção desejada, deverá ser solicitada à entrada de dois números e depois de processada a operação, deverá 

ser exibido o resultado. 

Este programa deverá ser um conjunto de cinco rotinas, sendo uma principal e quatro secundárias. A rotina 

principal efetuará o controle das quatro rotinas secundárias que, por sua vez, pedirão a leitura de dois valores, 

farão a operação e apresentarão o resultado obtido. A figura a seguir apresenta um organograma com a idéia de 

hierarquização das rotinas do programa. A quinta opção não se caracteriza por ser uma rotina, apenas a opção 

que vai encerrar o looping de controle do menu. 

Tendo uma idéia da estrutura geral do programa, será escrito em separado cada algoritmo com os seus 

detalhes de operação. Primeiro o programa principal e depois as outras rotinas, de preferência na mesma ordem 

em que estão mencionadas no organograma. 

É ideal que você codifique o programa aos poucos, como por exemplo: na definição do programa acima, 

primeiro vamos testar o menu e ver se a interação entre as partes funciona. 

Veja no programa a seguir: 

main( ) 

{ /* chave incial da main */ 

char opcao; 

while(opcao != ‘5’) 

{ /* chave inicial do laço while */ 

clrscr( ); 

printf(“1 - adicao\n”); 

printf(“2 - subtracao\n”); 

printf(“3 - multiplicacao\n”); 

printf(“4 - divisao\n”); 

printf(“5 - Fim do programa\n”); 

printf(“escolha uma opcao: “); 

opcao = getch( ); 

switch(opcao) 

{ /* chave inicial do switch */ 

case ‘1’: 

somar( ); 

break; 

case ‘2’: 

subtrair( ); 

break; 

case ‘3’: 

multiplicar( ); 

break; 

case ‘4’: 

dividir( ); 

break; 

case ‘5’: 

printf(“\nencerrando o programa”); 

break; 

default: 

66


printf(“\nopcao invalida”); 

} /* chave final do switch */ 

printf(“\nPressione uma tecla para continuar”); 

getch( ); 

} /* chave final do laço while */ 

} /* chave final da main */ 

somar( ) 

{ 

printf(“\nFuncao de soma”); 

} 

subtrair( ) 

{ 

printf(“\nFuncao de subtracao”); 

} 

multiplicar( ) 

{ 

printf(“\nFuncao de multiplicacao”); 

} 

dividir( ) 

{ 

printf(“\nFuncao de Divisao”); 

} 

agora algumas considerações sobre o programa anterior: 

• Na linha char opcao; declaramos a variável do tipo char para armazenar a opção de menu escolhida pelo 

usuário. 

• Na linha seguinte while(opcao != ‘5’) é o controle do laço de repetição: “Faça enquanto opção diferente de 

5”. 

• Logo após limpamos a tela e colocamos as opções do menu. 

• Para ver a opção do usuário codificamos: opcao = getch( ); 

• Para verificar qual opção digitada pelo usuário foi escolhida a estrutura switch que é a mais adequada 

quanto temos várias opções de um menu. 

• No tratamento do primeiro caso, ou seja, se o usuário digitou 1 é para fazer a soma. Colocamos neste 

case a linha: somar( ); que é a chamada para a função somar. 

• No tratamento dos demais casos utilizamos a chamada para a função 

subtrair( ); , multiplicar( ); e dividir( ); 

• Depois da chave final da função main( ) colocamos a declaração da funções 

Se tudo funcionou corretamente nos comandos da função main, vamos agora fazer as modificações 

necessárias em cada uma das funções. Devemos, então codificar os comandos para a execução das tarefas de 

67


cada uma das funções. 

Veja como ficou a parte do programa relativa as funções somar, subtrair, multiplicar e dividir: 

somar( ) 

{ 

float valorA, valorB, result; 

printf(“\nrotina de soma\n”); 

printf(“digite um valor para a: “); 

scanf(“%f”,&valora); 

printf(“digite um valor para B: “); 

scanf(“%f”,&valorB); 

result = valora + valorB; 

printf(“a soma de a com B e: %5.2f\n”,result); 

} 

subtrair( ) 

{ 


printf(“\nrotina de subtracao\n”); 





result = valora - valorB; 

printf(“a subtracao de a com B e: %5.2f\n”,result); 

} 


{ 


printf(“\nrotina de multiplicacao\n”); 





result = valora * valorB; 

printf(“a multiplicacao de a com B e: %5.2f\n”,result); 

} 

dividir( ) 

{ 


printf(“\nrotina de divisao\n”); 



68



result = valora / valorB; 

printf(“a divisao de a com B e: %5.2f\n”,result); 

} 

Novas considerações sobre o programa:: 

69 


• Na linha float valorA, valorB, result; declaramos as variáveis para ler os valores de A, de B e para armazenar 

o resultado da operação matemática. 

• Nas linhas seguintes pedidos para o usuário entrar com os dados relativos aos valores de A e de B 

• Efetuamos o processamento (cálculo da operação matemática) 

• Apresentamos os resultado do cálculo 

Funções II 

Funções dividem grandes tarefas de computação em tarefas menores. Funções apropriadas podem 

freqüentemente esconder detalhes de operação de partes de programa que não necessitam conhecê-las, 

esclarecendo o todo, e facilitando mudanças. Você usou a printf( ) sem conhecer detalhes de sua programação. 

Provavelmente a principal razão da existência de funções é impedir que o programador tenha de escrever o 

mesmo código repetidas vezes. 

Funções simples 

Vamos recordar como fazemos uma função de maneira bem simples analisando o programa abaixo: 

main( ) 

{ 

clrscr( ); 

poemsg( ); 

printf(“Pressione uma tecla”); 

getch( ); 

} 

poemsg( ) 

{ 

printf(“Função que põe uma a mensagem na tela\n”); 

} 


• A função principal é sempre a função main( ), é a partir dela que chamamos a função poemsg( ). 

• Os comandos da função main( ) estão encapsuladas entre as chaves ({...}) 

• Os comandos da função poemsg( ) também estão encapsuladas entre as chaves ({...}) 

• Na primeira linha de comando da função main( ) temos: clrscr( ); onde estamos chamando a função que 

limpa a tela 

• Na segunda linha de comando da função main( ) temos: poemsg( ); onde estamos chamando a função 

que põe uma mensagem na tela. 

• Repare que quando chamamos uma função ela vem acompanhada de ponto-e-vírgula (;) 

• Após a chave final da função main( ) vem a declaração da função poemsg( ) 

• Repare que quando declaramos uma função ela não vem acompanhada de ponto-e-vírgula (;)


Considerações importantes 

Como você pode ver, a estrutura de uma função C é bastante semelhante a da função main( ). A única 

diferença é que main( ) possui um nome especial, e é a função que dá inicio ao seu programa. 

Todo programa em C começa com a função main( ). 

Todas as funções em C começam com um nome seguido de parênteses e, após isto, chaves que envolvem 

o corpo da função. 

Do mesmo modo que chamamos uma função de biblioteca C (printf( ), getch( ), etc.) chamamos nossas 

próprias funções como em poemsg( ). 

Os parênteses que seguem o nome são necessários para que o compilador possa diferenciar a chamada a 

uma função de uma variável que você esqueceu de declarar. 

A chamada a uma função constitui uma instrução de programa, deve ser encerrada por ponto-e-vlrgula. 

Entretanto, na definição de uma função, o ponto-e-vírgula não pode ser usado. 

Variáveis locais 

Cada função pode chamar outras funções. As variáveis que são declaradas dentro de uma função são 

chamadas variáveis locais e são conhecidas somente dentro de seu próprio bloco. 

Um bloco começa quando o computador encontra uma chave de abertura ({) e termina quando o computador 

encontra uma chave de fechamento (}). 

Um dos aspectos mais importantes que você deve entender sobre as variáveis locais é que elas existem 

apenas durante a execução do bloco de código onde estão declaradas; isto é, uma variável local é criada quando 

se entra em seu bloco e destruída na saída. 

Vejamos o programa a seguir: 

main( ) { 

char nome[ ]=”Escola Tecnica Alcides Maya”; 

printf(“%s \n”,nome); 

poemsg( ); 


} 

poemsg( ) 

{ 

char nome[ ]=”Possui professores dedicados e competentes\n”; 

printf(“%s \n”,nome); 

} 

Agora algumas considerações sobre o programa: 

• A variável do tipo string declarada na função main( ), não tem nada a ver com a variável declarada dentro 

da função poemsg( ), são duas variáveis distintas entre si, e internas a cada função, por isto que não ocorre erro 

ou conflito entre elas, apesar de possuírem os mesmos nomes. 

Vejamos mais um exemplo para ficar bem claro estas informações: 

main( ) { 

char nome1[ ]=”Fred”; 

char nome2[ ]=”Vilma”; 

printf(“%s e %s são casados\n”, nome1, nome2); 

poemsg( ); 

70

printf(“%s e %s se amam\n”, nome1, nome2); 


} 

poemsg( ) 

{ 

char nome1[ ]=”Barney”; 

char nome2[ ]=”Bety”; 

printf(“%s e %s são casados\n”, nome1, nome2); 

} 

71 



• Veja que as variáveis nome1 e nome2 da função main( ), permanecem com as mesmas informações antes 

e depois da chamada da função poemsg( ). 

Variáveis globais 

Nos programas utilizados até agora foram utilizadas variáveis declaradas dentro das funções, ou seja, dentro 

de seu próprio bloco, consideradas, portanto privadas ao bloco onde foram declarada e nenhuma outra função 

tem acesso direto a elas. O mesmo é verdadeiro para variáveis de outras funções. 

Cada variável local numa rotina passa a existir somente quando a função é chamada e deixa de existir 

quando a função termina. 

Devido às variáveis locais virem e irem com a ativação da função, elas não retêm seus valores de uma 

chamada para outra, e devem ser explicitamente inicializadas a cada ativação. Se elas não forem inicializadas, 

conterão lixo. 

Como uma alternativa, é possível definir variáveis que sejam externas a todas as funções, isto é, variáveis 

globais que possam ser acessadas pelo nome por qualquer função que assim o desejar. 

Visto que as variáveis externas sejam globalmente acessíveis, podem ser usadas, ao invés de listas de 

argumentos, para comunicar dados entre funções. Além do mais, devido às variáveis externas existirem 

permanentemente, ao invés de aparecerem com a ativação e desativação de funções, elas retêm seus valores 

mesmo quando as funções que as acessam deixam de existir. 

Uma variável externa deve ser definida fora de qualquer função; isso aloca armazenamento para as mesmas. 

A variável deve também ser declarada em cada função que desejar acessa-la; isso pode ser feito por uma 

declaração explícita extern ou implicitamente pelo contexto. 

Vamos ver um pequeno programa que possa exemplificar o uso de variáveis externas. 



main( ) 

{ 

extern char nome1[ ]; 


printf(“%s e %s sao casados\n”, nome1, nome2); 

poemsg( ); 

printf(“%s e %s se amam\n”, nome1, nome2);



getch( ); 

} 

poemsg( ) 

{ 




} 


• Veja que a declaração das variáveis nome1 e nome2 antes da função main( ), isto identifica estas variáveis 

como sendo variáveis globais, ou seja, externas. 

• No inicio da função main( ) e também da função poemsg( ), declaramos o uso das variáveis globais com a 

declaração: extern char nome1[ ]; e extern char nome2[ ]; com isto estamos informando ao programa que vamos 

usar as variáveis globais declaradas antes de main( ). 

Considerações importantes 

As variáveis globais costumam ser chamadas de variáveis externas na linguagem C. 

Em main( ), as variáveis externas nome1 e nome2 são definidas nas primeiras linhas do exemplo acima, que 

definem seus tipos e alocam área de armazenamento para as mesmas. 

Sintaticamente definições externas são iguais às declarações que já usamos anteriormente, mas, como 

ocorrem fora das funções, as variáveis são externas. 

Antes de uma função usar uma variável externa, o nome da mesma deve ser conhecido pela função. Uma 

maneira de fazer isso é escrever uma declaração extern na função; a declaração é igual à anterior, exceto que é 

precedida da palavra-chave extern 

Em certas circunstâncias, a declaração extern pode ser omitida. Se a definição externa de uma variável ocorrer 

no arquivo fonte antes de seu uso numa função particular, então não há a necessidade de uma declaração extern 

na função. As declarações extern em main( ) e poemsg( ) são, portanto, redundantes. 

De fato, a prática comum é colocar a definição de todas as variáveis externas no início do arquivo fonte e, 

então, omitir todas as declarações extern. 

Se o programa está em vários arquivos fonte, e uma variável é definida em, digamos, arquivo1 e usada 

em arquivo2, então uma declaração extern é necessária no arquivo2 para conectar as duas ocorrências da 

variável. 

Baseado nisto o programa anterior poderia ter sido escrito da seguinte forma: 



main( ) 

{ 

clrscr( ); 


poemsg( ); 

printf(“%s e %s se amam\n”, nome1, nome2); 

72


getch( ); 

} 

poemsg( ) 

{ 


} 

73 


Você deve observar que estamos usando as palavras declaração e definição cuidadosamente quando nos 

referimos a variáveis externas nessa seção. “Definição” refere-se ao local onde a variável está sendo criada ou 

à qual é atribuída uma área de armazenamento; “declaração” refere-se ao local onde a natureza da variável é 

dada, sem alocação de área de armazenamento. 

A propósito, há uma tendência de se fazer com que tudo em vista seja uma variável extern porque simplifica 

aparentemente a comunicação – listas de argumentos são curtas e as variáveis estão sempre onde você as quer. 

Mas variáveis externas estão sempre lá, mesmo quando você não as quer. 

Este estilo de codificação é cheio de perigos porque leva a programas cujas conexões de dados não são 

óbvias – variáveis podem ser mudadas de modo inesperado e inadvertidamente, e o programa é difícil de 

modificar se o for necessário. 

Nós ainda não tratamos funções com passagem de argumentos, mas logo vamos ver como isto funciona, e 

ai então, poderemos identificar melhor o uso destas variáveis. 

Refinamento Sucessivo 

O refinamento sucessivo é uma técnica de programação que possibilita dividir uma função em outras funções. 

Deve ser aplicado com muito critério para que o programa a ser construído não se torne desestruturado e difícil 

de ser compreendido por você ou por outras pessoas. 

Na aula anterior vimos um programa que utilizava um menu na rotina principal e 4 funções para efetuar 

cálculos básicos (soma, subtração, multiplicação e divisão). 

Neste programa podemos aplicar esta técnica, aliada a declaração de variáveis externas. 

Por exemplo: a entrada e a saída são efetuadas com as mesmas variáveis. Observe que as variáveis valorA, 

valorB e result são definidas quatro vezes, uma em cada função. 

A solução é definir as variáveis valorA, valorB e result como externas e construir mais duas funções, uma para 

a entrada e a outra para a saída. As quatro funções atuais serão diminuídas em números de linhas, pois tudo o 

que se repete nas funções será retirado. 

Veja no programa a seguir a definição das variáveis externas e a definição das duas novas funções de 

entrada e de saída. Perceba nas funções estão sendo declaradas as variáveis que serão utilizadas pela função, 

fazendo uso do conceito de variáveis externas. 


main( ) 

{ 

char opcao=0; 

while(opcao != ‘5’) 

{ 

clrscr( ); 

printf(“1 - adicao\n”);


printf(“2 - subtracao\n”); 

printf(“3 - multiplicacao\n”); 

printf(“4 - divisao\n”); 

printf(“5 - Fim do programa\n”); 

printf(“escolha uma opcao: “); 

opcao = getch( ); 

switch(opcao) 

{ 

case ‘1’: 

somar( ); 

break; 

case ‘2’: 

subtrair( ); 

break; 

case ‘3’: 

multiplicar( ); 

break; 

case ‘4’: 

dividir( ); 

break; 

case ‘5’: 

printf(“\nencerrando o programa”); 

break; 

default: 

printf(“\nopcao invalida”); 

} 


getch( ); 

} 

} 

somar( ) 

{ 


entrada( ); 


saida( ); 

} 

subtrair( ) 

{ 

printf(“\nrotina de subtracao\n”); 

entrada( ); 

result = valora - valorB; 

saida( ); 

} 

74


{ 

printf(“\nrotina de multiplicacao\n”); 

entrada( ); 

result = valora * valorB; 

saida(); 

} 

dividir( ) 

{ 

printf(“\nrotina de divisao\n”); 

entrada( ); 

result = valora / valorB; 

saida( ); 

} 

entrada( ) 

{ 





} 

saida( ) 

{ 

printf(“o resultado de a com B e: %5.2f\n”,result); 

} 


75 


• Antes da função main( ), definimos as variáveis externas: float valorA, valorB, result; 

• Nas funções de cálculo declaramos as variáveis externas: extern float valorA, valorB, result; 

• Também nas funções de cálculo fizemos a chamada da função de entrada de dados: entrada( ); 

• E conseqüentemente a chamada da função de saída de dados: saida( ); 

• Na nova função de entrada declaramos as variáveis externas: extern float valorA, valorB; 

• Na nova função de saída declaramos a variável externa: extern float result; 

Funções III 

As funções formam o alicerce da programação. Conforme você aumentar a sua prática em programação, 

seus programas tomarão uma aparência modular quando você começar a programação com funções. 

Estilos e Protótipos das Funções 

As funções em C foram grandemente modificadas durante o processo de padronização ANSI. Este novo 

padrão de C é grandemente baseado no protótipo de funções usado em C++. Conforme você lê vários artigos, 

livros, e revistas sobre C, verá diversas variações usadas para descrever as funções.


Prevendo a necessidade que você vai encontrar em definir o tipo de função a ser utilizada vamos introduzir 

aqui o conhecimento sobre protótipo de funções. 

Protótipos de Funções 

As declarações de função começam com o protótipo da função C. O protótipo da função é simples e é incluído 

no início do código do programa para notificar o compilador do tipo e do número de argumentos que uma função 

utilizará. 

Embora outras variações sejam legais, sempre que possível você deve utilizar a forma do protótipo de função 

que é uma réplica da linha de declaração da função. Vamos fazer isto através de exemplos, então nos próximos 

exemplos você terá uma noção mais aprofundada sobre os protótipos das funções. 

Funções que não retornam um valor e não recebem argumentos 

O programa a seguir exemplifica um programa que não recebe nenhum argumento e não retorna nenhum 

valor. A declaração void foi batizada pelo comitê ANSI para a função que não retornam nada e não recebem 

nada. 

void somar(void); 

main( ) 

{ 

somar( ); 


} 

void somar(void) 

{ 

int valora, valorB, result; 



scanf(“%d”,&valora); 


scanf(“%d”,&valorB); 


printf(“a soma de a com B e: %d\n”,result); 

} 

agora algumas considerações sobre o programa anterior: 

• Antes da função main( ), declaramos o protótipo da função somar: void somar(void); onde o primeiro void 

está identificando que a função somar não retorna nenhuma informação para a função chamadora. O segundo 

void que está entre parênteses informa que a função chamadora não vai passar nenhum argumento para a 

função chamada. 

• Após a chave final do main (}) é definida a função somar: void somar(void) que deve ser coerente com o 

seu protótipo antes da função main. 

Funções que retornam um valor 

O programa a seguir exemplifica o retorno de uma informação da função chamada. 

int somar(void); 

76

main( ) 

{ 

int soma; 

soma = somar( ); 

printf(“a soma de a com B e: %d\n”, soma); 


} 

int somar(void) 

{ 

int valora, valorB, result; 



scanf(“%d”,&valora); 


scanf(“%d”,&valorB); 


77 


return(result); 

} 


• Antes da função main( ), declaramos o protótipo da função somar: int somar(void); onde identificamos que 

a função somar vai retornar um valor inteiro. 

• Dentro do main( ) declaramos a variável soma para receber o valor retornado int soma; 

• Ainda dentro do main( ) armazenamos o resultado retornado da função somar na variável soma através 

da linha de comando: soma = somar( ); 

• No início da função somar ela está definida da seguinte forma: int somar(void) 

• Dentro da função somar temos o retorno de um valor inteiro através linha de comando: return(result); 

O comando return 

Nos programas anteriores mostramos funções que retornam ao programa que chamou quando encontram a 

chave ( } ) que termina a função. Não há necessidade de uma instrução return. 

O comando return causa a atribuição de qualquer expressão entre parênteses a função que chamadora. 

Então quando somar( ) é chamada por main( ) a variável soma adquire o valor do calculado pela função somar. 

A variável soma é local a main( ), mas o valor de result é mandado para main( ) pelo comando return. Este 

valor pode, então, ser atribuído a uma variável ou fazer parte de alguma expressão. 

O comando return tem dois usos importantes: 

Primeiro: você pode usar return( ) para devolver um valor e retornar, imediatamente, para a próxima instrução 

do código de chamada. 

Segundo: você pode usá-lo, sem os parênteses, para causar uma saída imediata da função na qual ele se 

encontra; isto é, return fará com que a execução do programa volte para o código de chamada assim que o 

computador encontrar este comando, o que ocorre, em geral, antes da última instrução da função. 

Você pode colocar mais de um comando return em suas funções. 

Uma das limitações do comando return( ) é que ele pode retornar somente um único valor à função que 

chama.


Funções que recebem argumentos e retornam um valor 

O programa a seguir é uma variação do programa anterior, que exemplifica a passagem de informações entre 

a função chamadora e a função chamada. 

int somar(int valorA, int valorB); 

main( ) 

{ 

int soma, vala, valB; 

clrscr( ); 


scanf(“%d”, &vala); 


scanf(“%d”, &valB); 

soma = somar(vala, valB); 

printf(“a soma de a com B e: %d\n”, soma); 


getch( ); 

} 

int somar(int valora, int valorB) 

{ 

int result; 



return(result); 

} 


• Antes da função main( ), declaramos o protótipo da função somar: int somar(int valorA, int valorB); onde 

identificamos que a função somar vai retornar um valor inteiro e vai receber como argumento dois valores inteiros 

valorA e valorB. 

• Dentro do main( ) declaramos a variável soma para receber o valor retornado int soma,valA,valB; e também 

as variáveis que onde serão digitados os valores a serem passados como argumentos para a função somar. 

• Ainda dentro do main( ) armazenamos o resultado retornado da função somar na variável soma através 

da linha de comando: soma = somar(valA, valB); 

• No início da função somar ela está definida da seguinte forma: int somar(void) 

• Dentro da função somar temos o retorno de um valor inteiro através linha de comando: return(result); 

78


Funções IV 

As funções podem ser utilizadas da forma mais simples possível, como as que não recebem nenhuma 

informação e também não retornam nenhuma informação. Mas podem ser um pouco mais sofisticadas podendo 

receber informações de quem as chamou e se for necessário retornar uma informação para a função que a 

chamou. 

Vamos rever estes conceitos, com maiores detalhes, para que você não tenha dúvidas. 

Protótipos de Funções 

Na aula anterior estudamos que as declarações de uma função começam com o protótipo da função C. O 

protótipo da função é simples e é incluído no início do código do programa para notificar o compilador do tipo e 

do número de argumentos que uma função utilizará. Veja a sintaxe deste protótipo: 

tipo_de_ retorno nome_da_função( tipo(s)_argum nome(s)_argum ); 

Veja o significado desta sintaxe: 

• A função pode ser do tipo void, int, float e assim por diante, específicado em tipo_de_retorno. 

• O nome_da_função é um nome significativo para descrever a função. 

• Se for passado alguma informação para a função, devemos fornecer um tipo_argum seguido por um 

nome_argum. 

Os tipos de argumentos também podem ser do tipo void, int, float, etc. Podemos passar muitos valores para 

a função repetindo o tipo de argumento e nome separados por uma vírgula. 

A própria função é um pedaço de código encapsulado que segue a definição da função main . 

A função têm a seguinte sintaxe: 

tipo_de_retorno nome_da_função( tipo(s)_argum nome(s)_argum ) 

{ 

. 

. 

(declaração de dados e corpo da função) 

. 

. 

return( ); 

} 

Notamos que a primeira linha da função é idêntica (exceto pela ausência do ponto-e-vírgula (;)) à do protótipo 

que é listado no início de um programa. 

Vejamos um exemplo de um programa utilizando uma função. 

int somar( int x, int y ); /* protótipo da função */ 

main( ) 

{ 

int a,b,c; 

a=5; 

b=93; 

c = somar( a, b ); /* chamada da função */ 

79


printf(“%d + %d = %d\n”, a, b, c); 

} 

int somar( int x, int y ) /* declaração da função */ 

{ 

int z; 

z = x + y; 

return(z); 

} 

/* tipo de retorno da função */ 

Veja algumas considerações sobre o programa acima: 

• Antes da função main( ), declaramos o protótipo da função somar: int somar( int x, int y ); onde o protótipo 

explica que a função aceitará dois argumentos int e retorna um valor tipo int. Na verdade, o padrão ANSI sugere 

que toda a função seja prototipada num arquivo de cabeçalho separado. Como podemos presumir, é assim que 

os arquivos de cabeçalho são associados às suas bibliotecas C apropriadas. Para programas simples, você pode 

incluir o protótipo da função dentro do corpo do programa 

• Na chamada da função: c = somar( a, b ); estamos atribuindo o valor de retorno da função a uma 

variável 

• Logo após a chave final da função main temos a declaração da função: int somar( int x, int y ) , que não 

tem ponto-e-vírgula. 

• E finalmente, antes da chave final da função: return(z); retornamos para a função chamadora o resultado 

do cálculo. 

Chamada por valor 

No programa anterior, os argumentos foram passados por valor para a função somar. 

Quando variáveis são passadas dessa maneira, uma cópia do valor da variável é passada para a função. 

Como uma cópia é passada, a variável no programa de chamada não é alterada. 

Chamar uma função por valor é um meio popular de passar informações para uma função e é o método 

padrão em C. 

A limitação desta técnica (“chamada por valor”) é que somente um valor é retornado pela função. 

Chamada por referência 

Em uma chamada por referência, o endereço do argumento, e não seu valor, é passado para a função. Esta 

passagem exige menos memória pelo programa do que a chamado por valor. 

Quando usamos uma chamada por referência, as variáveis na chamada do programa podem ser alteradas. 

A vantagem desta técnica (“chamada por referência”) é que mais de um valor pode ser retornado pela 

função. 

Vejamos o programa anterior utilizando esta técnica: 

int somar( int *x, int *y ); 

main( ) 

{ 

int a,b,c; 

a=5; 

b=93; 

80

c = somar( &a, &b ); 


} 

int somar( int *x, int *y ) 

{ 

int z; 

z = *x + *y; 

return(z); 

} 

Veja algumas considerações sobre o programa acima: 

81 


• Antes da função main( ), declaramos o protótipo da função somar: int somar( int *x, int *y ); onde o protótipo 

informa que a função aceitará dois argumentos int passados como uma chamada por referência. 

• Na chamada da função: c = somar( &a, &b ); estamos passando os endereços de memória das variáveis 

a e b, permitindo que se possa alterar o conteúdo destas variáveis dentro da função chamada, o que não ocorre 

no exemplo acima. (No próximo programa vamos ver um exemplo onde isto é realizado) 

• Após a função main temos a declaração da função: int somar( int *x, int *y ) 

• No comando: z = *x + *y; podemos lê-lo da seguinte forma: “O conteúdo apontado pela variável x será 

somado ao conteúdo apontado pela variável y e atribuído a variável z”. 

• E na linha: return(z); retornamos para a função chamadora o resultado do cálculo. 

Vejamos um exemplo, que utiliza melhor esta técnica: 

void somar( int *x, int *y, int *z ); 

main( ) 

{ 

int a,b,c; 

a = 5; 

b = 93; 

somar( &a, &b, &c ); 


} 

void somar( int *x, int *y, int *z ) 

{ 

*x = 10; 

*y = 20; 

*z = *x + *y; 

} 

Veja algumas considerações sobre o programa acima:


• Na declaração do protótipo da função somar: void somar( int *x, int *y, int *z ); informamos que esta função 

não irá retornar nenhum informação (void), e que a função aceitará três argumentos int passados como uma 

chamada por referência. 

• Note que na função main, antes da chamada da função somar, estamos atribuindo um valor para a variável 

a: a = 5; e outro para a variável b: b = 93; 

• Na chamada da função: somar( &a, &b, &c ); estamos passando os endereços de memória das variáveis 

a, b e c, permitindo que se possa alterar o conteúdo destas variáveis dentro da função chamada. Nesta função 

não estamos atribuíndo um valor de retorno a nenhuma variável, porque a função foi declarada como void 

• Após a função main temos a declaração da função: void somar( int *x, int *y, int *z ) 

• Dentro desta função estamos alterando o conteúdo das variáveis a e b, através dos comandos de 

atribuição: *x = 10; (Lê-se: “O conteúdo apontado pela variável x recebe o valor 10”, significando que o conteúdo 

da variável a será alterado após esta atribuição), o mesmo ocorrendo com a variável b na atribuição: *y = 20; 

Neste momento o conteúdo inicial da variável a e b é substituído pelos novos valores atribuidos através da 

variáveis que apontam para seus endereços ( *x e *y ). 

• No comando: *z = *x + *y; podemos lê-lo da seguinte forma: “O conteúdo apontado pela variável x será 

somado ao conteúdo apontado pela variável y e atribuído ao conteúdo apontado pela variável z”. 

• E não temos comando de return nesta função. 

Funções V 

Nesta aula vamos tratar dos Argumentos das Funções, que são parâmetros passados para as funções, ou 

seja, informações que são levadas da função chamadora para a função chamada. 

Estes argumentos são opcionais, algumas funções podem não receber argumentos enquanto outras podem 

receber diversos argumentos. 

Os argumentos podem ser misturados, ou seja, podemos utilizar diversos tipos de dados. 

Argumentos de Função Formais e Reais 

A definição de uma função contém uma lista de argumentos (ou parâmetros) chamada lista de argumentos 

formais. A lista pode estar vazia ou pode conter qualquer combinação de tipos, como inteiro, ponto flutuante ou 

caracteres. 

Quando a função é realmente chamada de dentro do corpo do programa, uma lista de argumentos passa 

para a função. Esta lista é chamada de lista de argumentos reais. 

Função sem argumentos - void 

Na ausência de argumentos da função, podemos usar o void. Usar void é adequado, mas não necessário. 

O programa a seguir tem uma função simples chamada poemsg que não recebe argumentos e não retorna 

um valor. A função main chama a função poemsg. Quando poemsg completa a sua tarefa, o controle retorna para 

a função main. 

void poemsg (void); 

main( ) 

{ 

printf(“este programa apresenta a soma de dois números\n”); 

poemsg( ); 

} 

void poemsg (void) 

{ 

int a = 4; 

int b = 7; 

int c = 0; 

c = a + b; 

82

printf (“%d + %d = %d” , a, b, c); 

} 

Algumas considerações sobre o programa acima: 

Função com argumento de inteiros - int 

83 


• Na declaração do protótipo da função poemsg: void poemsg (void); informamos que esta função não 

requer nenhum argumento de entrada e não irá retornar nenhuma informação (void) 

Função com argumento de caracteres - char 

Caracteres podem ser passados para uma função. No exemplo a seguir, um caractere será esperado do 

teclado na função main e passado para a função poechar. A função getch será utilizada para ler um caracter do 

teclado e retornar o valor do caractere digitado, sem apresentá-lo na tela. 

Nós estamos acostumados a usar esta função para esperar uma tecla qualquer e seguir na execução do 

programa, ou em um menu de escolha, para saber qual a opção teclada pelo usuário. 

Na biblioteca padrão da linguagem C, estas outras funções de caractere estão relacionadas com getch: getc, 

getchar e getche. 

void poechar (char c); 

main( ) 

{ 

char caracter; 

printf(“Pressione uma tecla qualquer\n”); 

caracter = getch( ); 

poechar(caracter); 

} 

void poechar (char c) 

{ 

printf (“o caracter digitado foi..........................: %c\n” ,c); 

printf (“o código asCII do caracter digitado é: %d\n” ,c); 

} 


• Na declaração do protótipo da função poechar: void poechar (char c); informamos que esta função requer 

um dado do tipo char e que não irá retornar nenhuma informação (void) 

• Na linha: caracter = getch( ); é lido o valor do caracter digitado 

• Na linha: poechar(caracter); é passado para a função poechar o caracter digitado 

• Na primeira linha da função poechar é apresentado o caracter digitado com o comando: printf (“O 

caracter digitado foi..........................: %c\n” ,c); 

• E aproveitando apresentamos o valor ASCII do caracter digitado utilizando o parâmetro %d do caracter 

digitado com o comando: printf (“O código ASCII do caracter digitado é: %d\n” ,c);


Neste programa, um único int será lido do teclado com a função scanf. Esse int será passado para a função 

raio. A função raio utiliza o raio fornecido para calcular e escrever a área de um círculo, o volume da esfera e a 

área da superfície da esfera. 

void raio (int r); 

main( ) 

{ 

int vlraio; 

printf(“Informe o raio, como um valor inteiro: “); 

scanf(“%d”, &vlraio); 

raio(vlraio); 

} 

void raio (int r) 

{ 

float area, volume, superficie; 

area = 3.14159 * (float) (r*r); 

superficie = 3.14159 * 4.0 * (float) (r*r); 

volume = 3.14159 * 4.0 / 3.0 * (float) (r*r*r); 

printf (“o raio ‚......................: %d\n” ,r); 

printf (“a área do círculo....: %f\n” ,area); 

printf (“A área da esfera .....: %f\n” ,superficie); 

printf (“o volume da esfera..: %f\n” ,volume); 

} 


• Na declaração do protótipo da função raio: void raio (int r); informamos que esta função requer um dado 

do tipo int e que não irá retornar nenhuma informação (void) 

• Na função main vamos ler o valor do raio e chamar a função que faz os cálculos passando como argumento 

o valor do raio na linha: raio(vlraio); 

• Note que dentro da função raio, estamos recebendo como parâmetro a variável r que possui o raio. 

• Veja também que nos cálculos estamos fazendo o uso de um cast (float) na frente da linha que utiliza o 

parâmetro r, que é inteiro, forçando o cálculo para ser convertido para float, é isto que significa o cast. 

Função com argumento em ponto flutuante - float 

Os números em ponto flutuante são tão simples de ser passados como argumentos quanto os inteiros. No 

exemplo a seguir vamos ler o salário bruto de uma pessoa e a taxa de INSS para o desconto da previdência 

social. A função que calcula o salário líquido vai receber estes dois parâmetros, calcular e apresentar o valor do 

salário líquido. 

84

void calc_sal ( float sb, float tx ); 

main( ) 

{ 

float salbruto, txinss; 

printf(“digite o valor do salário bruto: “); 

scanf(“%f”, &salbruto); 

printf(“digite a taxa de desconto do Inss: “); 

scanf(“%f”, &txinss); 

calc_sal (salbruto, txinss); 

} 

float calc_sal ( float sb, float tx ) 

{ 

float saliq; 

saliq = sb - (sb * tx / 100); 

printf(“o valor do salário líquido é: %12.2f\n”, saliq); 

} 


85 


• Na declaração do protótipo da função calc_sal: void calc_sal ( float sb, float tx ); informamos que esta 

função requer dois dados do tipo float e que não irá retornar nenhuma informação. 

• Na função main vamos ler o valor do salário bruto e a taxa de desconto do inss chamamos a função 

calc_sal, que calcula e apresenta o salário líquido. 

Funções VI 

Nesta aula vamos tratar dos inúmeros tipos de funções. Um tipo de função é o tipo de valor retornado pela 

função. Na aula anterior os nossos exemplos não retornavam nenhum valor e, portanto elas eram do tipo void. 

Agora iremos trabalhar com várias funções que retornam tipos de dados diferentes. 

Função do tipo void 

Nós já trabalhamos com os tipos de função void, de modo que o próximo exemplo será um pouco mais 

elaborado. Na linguagem C a informação numérica pode ser formatada em hexadecimal, decimal e octal, mas 

não em binário. A especificação de dados no formato binário é útil quando você estiver usando aritmética binária 

ou desenvolvendo máscaras de bits. 

A função binario converte um número decimal informado pelo teclado para uma representação binária. Os 

dígitos binários são armazenados individualmente numa matriz. Para visualizar o número binário, você precisa 

escrever o conteúdo da matriz.


void binario ( int numero ); 

main( ) 

{ 

int numero; 

printf(“digite um numero decimal: “); 

scanf(“%d”, &numero); 

printf(“este numero em binario e: “); 

binario(numero); 

} 

void binario ( int numero ) 

{ 

int i=0; 

int matriz[40]; 

matriz[0]=0; 

if(numero) 

{ 

while(numero != 0) 

{ 

matriz[i] = (numero % 2); 

numero /= 2; 

i++; 

} 

--i; 

} 

for( ; i >= 0; i-- ) 

printf(“%d”, matriz[i]); 

} 


• Na declaração do protótipo da função binario: void binario ( int numero ); informamos que esta função 

requer um argumento do tipo inteiro e que a função não irá retornar nenhuma informação; 

• A função binario está convertendo o número para binário fazendo divisões sucessivas por dois. O número 

na base dez será o quociente da divisão anterior. O resto, após cada divisão, será um ou zero. O resto será o 

dígito binário. 

86


Função do tipo char 

A função maiuscula aceita um argumento char e retorna um argumento também char. 

char maiuscula ( char letra ); 

main( ) { 

char letramai, letramin; 

printf(“digite uma letra minúscula: “); 

scanf( “%c”, &letramin); 

letramai = maiuscula ( letramin ); 

printf( “a letra digitada em maiúsculo é: %c “, letramai); 

} 

char maiuscula ( char letra ) 

{ 

if (letra >= ‘a’ && letra = ‘a’ && letra



• Na declaração do protótipo da função cubo: int cubo ( int numero ); informamos que esta função requer um 

argumento do tipo int e que a função não irá retornar um argumento também do tipo int; 

• Na função o cálculo é realizado dentro do próprio retorno: return(numero * numero * numero); 


1. Faça um programa que efetue o cálculo de uma prestação em atraso. Para tanto, utilize a fórmula PREST 

= VALOR + (VALOR * (TAXA / 100) * TEMPO). O programa deverá chamar uma função que faça a entrada 

dos dados e o cálculo da prestação e retorne o valor deste cálculo para a função principal (main). Finalmente 

apresentar o valor da prestação. 

2. Faça um programa que possua uma função que efetue e permita apresentar o somatório dos N primeiros 

números inteiros. (1+2+3+4+5+6+...+N). Esta função deverá receber da função principal (main) o número N e 

no final esta mesma função deverá retornar o valor do somatório, que deverá ser apresentado ao usuário pela 

função principal (main). 

3. Faça um programa que possua uma função para calcular e apresentar o valor de uma potência de um 

número qualquer. Ou seja, ao informar para a função o número e sua potência, deverá ser apresentado o 

seu resultado. Por exemplo, se for mencionado no programa principal a função POTENCIA(2,3), deverá ser 

apresentado o valor 8. 

4. Faça um programa que possua uma função para calcular e apresentar a série de Fibonacci de N termos. 

A série de Fibonacci é formada pela seqüência: 1, 1, 2, 3, 5, 8, 13, 21, 34,...etc. Está série caracteriza-se pela 

soma de um termo posterior com o seu anterior subseqüente. A função main deve apenas chamar a função que 

calcula a série de Fibonacci. 

5. Faça um programa que efetua a leitura de um número inteiro e apresente uma mensagem informando se 

o número é par ou ímpar. Usar uma função que identifique se o número é par ou ímpar. 

6. Faça um programa que apresente um menu com as seguintes opções de cálculos: 

• Calcular a área do quadrado 

• Calcular a área do retângulo 

• Calcular a área do circulo 

• Encerrar o programa 

Estes cálculos devem ser realizados em funções, ou seja, deverá ter uma função para cada tipo de cálculo. 

Cada função deverá ter entrada de dados (digitação dos dados para o cálculo), processamento dos dados 

(cálculos propriamente ditos) e a saída de dados (apresentação dos resultados dos cálculos). 

7. Faça um programa que apresente um menu com as seguintes opções e efetue os respectivos cálculos 

através de funções: 

• Calcular o volume de uma lata de óleo 

• Calcular o volume de uma caixa 


8. Em uma Escola Técnica de Informática, há um professor que faz 6 provas. Faça um programa para 

calcular a média dos alunos de uma escola. O programa deverá ter um menu com as seguintes informações: 

• Calcular a média 


O cálculo da média deverá ser realizado em uma função onde deverá ser solicitado o valor das 6 notas 

escolares, efetuar o cálculo da média e apresentar no final o resultado obtido conforme a tabela a seguir: 

[00,05) - Reprovado 

[05,07) - Recuperação 

[07,09) - Satisfatório 

[09,10] - Ótimo 

9. Faça um programa para ler uma temperatura em graus Celsius. Criar uma função que converte a 

temperatura de Celsius para Fahrenheit. A fórmula de conversão é F ( 9 * C + 160 ) / 5, sendo F a temperatura 

em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados 

a temperatura em Celsius em tipo de dado float, fazer a conversão e retornar o valor convertido em graus 

Fahrenheit. 

88


10. Faça um programa para ler uma temperatura em graus Fahrenheit. Criar uma função que converte a 

temperatura de Fahrenheit para Celsius. A fórmula de conversão é C ( F – 32 ) * ( 5 / 9 ), sendo F a temperatura 

em Fahrenheit e C a temperatura em Celsius. A função de conversão deve receber como entrada de dados a 

temperatura em Fahrenheit em tipo de dado float, fazer a conversão e retornar o valor convertido em graus 

Celsius. 

11. Faça um programa que leia um caracter do teclado. Criar uma função que irá converter esta letra para uma 

letra minúscula e retorna-la. 

12. Faça um programa que leia dois números. Criar uma função chamada potencia que eleva o primeiro 

número a uma potência inteira do segundo número e retorna o valor calculado. Por exemplo, se for lido os 

números 2 e 3, a função irá calcular 2³ ou seja 2 * 2 * 2 

13. Faça um programa que leia e calcule a área de um retângulo. O programa deverá ter uma função que 

leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na 

função main. Fórmula: Área do retângulo = base * altura. 

14. Faça um programa que leia e calcule a área de um triângulo. O programa deverá ter uma função que 

leia a base e a altura do retângulo, calcule a área e retorne o valor do resultado que deverá ser apresentada na 

função main. Fórmula: Área do triângulo = (base * altura) / 2. 

15. Faça um programa que leia e calcule a área de um trapézio. O programa deverá ter uma função que leia 

a base maior, a base menor e a altura do trapézio, calcule a área e retorne o valor do resultado que deverá ser 

apresentada na função main. Fórmula: Área do trapézio = ((base maior + base menor) /2) * altura. 

16. Faça um programa que leia e calcule a área de um círculo. O programa deverá ter uma função que 

leia o raio do círculo, calcule a área e retorne o valor do resultado que deverá ser apresentada na função main. 

Fórmula: Área do círculo = PI * r². 

Bibliografia utilizada: 

1. MANZANO, JOSÉ AUGUSTO N. G. – Algoritmos: Lógica para Desenvolvimento de Programação, Editora 

Érica, São Paulo, 2000. 

2. MANZANO, JOSÉ AUGUSTO N. G. – Lógica estruturada para Programação, Editora Érica, São Paulo, 

2001. 

3. BOHI, MARILYN – Guia para programadores, Editora Campus, Rio de Janeiro, 1988. 

4. ALCIDES MAYA - Polígrafo Técnicas de Programação – Porto Alegre, 2001 

5. ALCIDES MAYA - Polígrafo Algoritmo – Porto Alegre, 2001 

6. REIS, ANTONIO – Manual Básico de Linguagem C, Porto Alegre, 2000. 

7. Outras fontes – Internet, Revistas e Periódicos. 

89

Fundamentos de Programação 1 - Alcides Maya Tecnologia

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?