Cap tulo 3: Programando com Fun co es

Waldemar Celes e Roberto Ierusalimschy 29 de Fevereiro de 2012

Organiza c ao de c odigos

Um programa de computador representa a implementa c ao de uma solu c ao de um determinado problema. O processo de desenvolvimento de programas de computador envolve diversas etapas. Logicamente, a primeira etapa e entender o problema que se deseja resolver. Em seguida, podemos fazer uma an alise do problema na tentativa de identicar poss veis solu c oes. Por exemplo, podemos considerar solu c oes feitas para outros problemas que possam ser adaptadas para o problema em quest ao. Ap os a identica c ao de poss veis solu c oes, podemos desenvolver o projeto do software em si. Devemos pensar em como organizaremos nosso programa, que recursos iremos usar, que poss veis c odigos j a implementados podemos utilizar ou adaptar etc. Por m, implementamos nosso projeto, codicando a solu c ao usando uma linguagem de programa c ao. Na pr atica, estas etapas n ao s ao t ao bem denidas. Trata-se de um processo din amico onde a realiza c ao de uma etapa inuencia as outras. Muitas vezes, por exemplo, mudamos o problema a medida que construimos uma solu c ao. Isto pode acontecer por diversas raz oes. O problema original pode, por exemplo, n ao ter solu c ao, ou o tempo de computa c ao da solu c ao existente pode ser inaceit avel. Por outro lado, a solu c ao encontrada para um determinado problema pode ser facilmente estendida para atender outras situa c oes n ao previstas no problema original. Por se tratar de um processo din amico, estamos constantemente revendo c odigos j a escritos, seja para corrigir eventuais erros encontrados, seja para usar como modelo para resolver um outro problema. Por isso, e fundamental que nosso programa seja escrito de forma organizada, a m de facilitar a manuten c ao, o re-uso, a adapta c ao do c odigo, durante o processo de desenvolvimento ou no futuro. Neste cap tulo, iremos discutir como programar com fun c oes. Fun c oes em C s ao procedimentos que podem ser executados por outros c odigos (outras fun c oes). Em C, as fun c oes representam o mecanismo pelo qual podemos estender a linguagem. Nos c odigos deste texto, por exemplo, utilizamos fun c oes auxiliares para capturar valores fornecidos pelo usu ario via teclado e fun c oes auxiliares para exibir informa c oes na tela. De certa forma, estas fun c oes previamente codicadas representam uma extens ao da linguagem. Os c odigos que escrevemos nos exemplos aqui mostra atrav dos usam estas fun c oes, como se elas zessem parte da pr opria linguagem. E es deste tipo de mecanismo de extens ao que programadores usam a linguagem C para diversas nalidades. Por exemplo, podemos tra car gr acos na tela do computador se tivermos a nossa disposi c ao uma biblioteca que implementa fun c oes para fazer o tra cado dos gr acos. De forma an aloga, podemos criar sosticadas interfaces com menus, bot oes e listas, desde que tenhamos uma biblioteca com fun c oes para esta nalidade. Em geral, podemos usar a linguagem C para fazer qualquer programa, mas muitas vezes ser a necess ario ter dispon vel uma biblioteca que estende a linguagem, oferecendo fun c oes relacionadas com o programa que queremos desenvolver.

Cria c ao de novas fun co es

Conforme mencionado no cap tulo anterior, um programa em C e dividido em pequenas fun c oes. Bons programas em geral s ao compostos por diversas pequenas fun c oes. Como agrupar o c odigo 1

em fun c oes e um dos desaos que devemos enfrentar. Como o pr oprio nome diz, uma fun c ao implementa uma funcionalidade. A divis ao de um programa em fun c oes ajuda na obten c ao de c odigos estruturados. Fica mais f acil entender o c odigo, mais f acil manter, mais f acil atualizar e mais f acil re-usar. Em C, a codica c ao de uma fun c ao segue a sintaxe mostrada abaixo:
tipo do retorno { corpo da fun c ao ... } nome da fun c ao ( lista de par ametros da func ao )

Para cada fun c ao que criamos, escolhemos um nome. O nome identica a fun c ao e um programa em C n ao pode ter duas fun c oes com o mesmo nome. Uma fun c ao pode receber dados de entrada, que s ao os par ametros da fun c ao, especicados entre os par enteses que seguem o nome da fun c ao. Se uma fun c ao n ao recebe par ametros, colocamos a palavra void entre os par enteses. Uma fun c ao tamb em pode ter um valor de retorno associado. Antes do nome da fun c ao, identicamos o tipo do valor de retorno. Se a fun c ao n ao tem valor de retorno associado, usamos a palavra void. Entre o abre e fecha chaves, codicamos o corpo da fun c ao, que consiste no bloco de comandos que comp oem a fun c ao. Para ilustrar, vamos considerar novamente o programa que converte uma temperatura dada em graus Celsius para graus Fahrenheit. No cap tulo anterior, implementamos este programa codicando tudo dentro da fun c ao main. Para este exemplo, e f acil identicar uma solu c ao mais estruturada. Podemos dividir nosso programa em duas fun c oes. Uma primeira fun c ao ca respons avel por fazer a convers ao de unidades, enquanto a fun c ao main ca respons avel por capturar o valor fornecido pelo usu ario, chamar a fun c ao auxiliar que faz a convers ao e exibir o valor convertido na tela. Desta forma, identicamos uma funcionalidade bem denida convers ao de Celsius para Fahrenheit e a codicamos em uma fun c ao em separado. Um c odigo que implementa uma fun c ao que faz esta convers ao e ilustrado a seguir:
f l o a t c e l s i u s f a h r e n h e i t ( f l o a t tc ) { float t f ; t f = 1.8 tc + 32; return t f ; }

Uma grande vantagem de dividir o programa em fun c oes e aumentar seu potencial de re-uso. No caso, ap os certicarmos que a fun c ao est a correta, podemos usar esta mesma fun c ao em qualquer outro programa que precise converter temperatura em graus Celsius para Fahrenheit. Com o aux lio desta fun c ao, o c odigo da fun c ao main ca mais simples, facilitando seu entendimento, pois o detalhe de como a convers ao e feita est a codicado dentro da fun c ao auxiliar.
i n t main ( void ) { float cels ; float fahr ; p r i n t f (Entre com temperatura em C e l s i u s : ) ; scanf (%f , &c e l s ) ; fahr = c e l s i u s f a h r e n h e i t ( cels ) ;

p r i n t f (Temperatura em Fahrenheit : %f , f a h r ) ; return 0 ; }

A convers ao de graus Celsius para Fahrenheit e muito simples, mas e f acil imaginar que esta fun c ao main n ao seria alterada se a convers ao estivesse baseada em computa c oes sosticadas, pois na fun c ao main tudo o que nos interessa e o valor resultante da chamada da fun c ao. O programa completo e mostrado a seguir:
#include < s t d i o . h> f l o a t c e l s i u s f a h r e n h e i t ( f l o a t tc ) { float t f ; t f = 1.8 tc + 32; return t f ; } i n t main ( void ) { float cels ; float fahr ; p r i n t f (Entre com temperatura em C e l s i u s : ) ; scanf (%f , &c e l s ) ; fahr = c e l s i u s f a h r e n h e i t ( cels ) ; p r i n t f (Temperatura em Fahrenheit : %f , f a h r ) ; return 0 ; }

/ 06 / / 07 / / 08 /

/ 01 / / 02 / / 03 / / 04 / / 05 / / 09 / / 10 /

No c odigo, as fun c oes devem ser escritas antes de serem usadas. Assim, como a fun c ao 1 auxiliar e usada (invocada) pela fun c ao main, ela deve aparecer antes no c odigo . E importante saber que a execu c ao do programa sempre se inicia com o c odigo da fun c ao main, independente da ordem em que escrevemos as fun c oes no nosso c odigo. Os n umeros acrescidos a direita do c ` odigo, em forma de coment arios de C, ilustram a ordem de avalia c ao dos comandos quando o programa e executado. Quando invocamos uma fun c ao, como no comando fahr = celsius_fahrenheit(cels);, a CPU passa a executar os comandos da fun c ao chamada (celsius_fahrenheit, no caso). Quando a fun c ao chamada retorna, a CPU prossegue a execu c ao dos comandos da fun c ao que chama (main, no caso). Isso tamb em ocorre quando se chama uma fun c ao de uma biblioteca externa.

Par ametros e valor de retorno

Uma fun c ao deve ter sua interface bem denida, tanto do ponto de vista sem antico como do ponto de vista sint atico. Do ponto de vista sem antico, quando projetamos uma fun c ao, identicamos sua funcionalidade e com isso denimos que dados de entrada s ao recebidos e qual o resultado (dado de sa da) e produzido pela fun c ao. Do ponto de vista sint atico, os tipos dos dados de entrada e sa da s ao especicados no cabe calho da fun c ao. Uma fun c ao pode receber zero
A rigor, esta restri ca o pode ser contornada com o uso de prot otipos, mas vamos deixar esta discuss ao para depois
1

ou mais valores de entrada, chamados par ametros da fun c ao, e pode resultar em zero ou um valor, chamado valor de retorno da fun c ao. Os par ametros de uma fun c ao s ao listados entre os par enteses que seguem o nome da fun c ao. Assim, a fun c ao celsius_fahrenheit do programa anterior, cujo prot otipo foi denido por:
f l o a t c e l s i u s f a h r e n h e i t ( f l o a t tc ) ;

s o recebe um u nico par ametro do tipo float, ao qual foi associado o nome tc. Esta fun c ao tem como retorno um valor do tipo float, indicado pelo tipo que precede o nome da fun c ao. Note o cabe calho da fun c ao main. Main e uma fun c ao que tem como valor de retorno um inteiro e n ao recebe par ametros, indicado pela palavra void entre os par enteses: int main (void). Existem ainda fun c oes que recebem par ametros mas n ao t em valor de retorno associado. Por exemplo, vamos supor uma fun c ao respons avel apenas pela impress ao de uma temperatura qualquer (no nosso caso, vamos utiliz a-la para imprimir a nova temperatura dada em Fahrenheit). Esta fun c ao, que chamamos de print_temp recebe como par ametro a temperatura que ser a exibida, mas n ao retorna um valor para quem a chamou. O prot otipo desta fun c ao e dado por:
void print temp ( f l o a t t f ) ;

Como pode ser visto pelo programa completo listado abaixo, a nossa fun c ao print_temp foi implementada para exibir o valor de uma nova temperatura utilizando apenas 2 casas decimais. O programa completo caria assim:
#include < s t d i o . h> void print temp ( f l o a t t f ) { p r i n t f (%.2 f , t f ) ; return ; } f l o a t c e l s i u s f a h r e n h e i t ( f l o a t tc ) { float t f ; t f = 1.8 tc + 32; return t f ; } i n t main ( void ) { float cels ; float fahr ; p r i n t f (Entre com temperatura em C e l s i u s : ) ; scanf (%f , &c e l s ) ; fahr = c e l s i u s f a h r e n h e i t ( cels ) ; p r i n t f (Temperatura em Fahrenheit : ) ; print temp ( f a h r ) ; return 0 ; }

/ 11 / / 12 /

/ 06 / / 07 / / 08 /

/ 01 / / 02 / / 03 / / 04 / / 05 / / 09 / / 10 / / 13 /

Outras fun c ao recebem mais do que um par ametro. Para ilustrar, considere uma fun c ao que calcule o volume de um cilindro de raio r e altura h. Sabe-se que o volume de um cilindro e 2 dado por r h. Uma fun c ao para calcular o volume de um cilindro deve receber os valores do raio e da altura como par ametros e ter como retorno o valor do volume calculado. Uma poss vel implementa c ao desta fun c ao e mostrada a seguir:
#define PI 3.14159

f l o a t v o l u m e c i l i n d r o ( f l o a t r , f l o a t h) { float v ; v = PI r r h ; return v ; }

Para testar esta fun c ao, podemos escrever uma fun c ao main. Nesta fun c ao, os valores do raio e da altura s ao capturados do teclado e o volume computado e exibido na tela. Esta fun c ao main e muito similar ` a fun c ao main do exemplo de convers ao de temperaturas: captura-se valores fornecidos via teclado, invoca-se a fun c ao que far a a computa c ao desejada e, ent ao, exibe-se os resultados.
i n t main ( void ) { f l o a t r a i o , a l t u r a , volume ; p r i n t f (Entre com o v a l o r do r a i o : ) ; scanf (%f , &r a i o ) ; p r i n t f (Entre com o v a l o r da a l t u r a : ) ; scanf (%f , &a l t u r a ) ; volume = v o l u m e c i l i n d r o ( r a i o , a l t u r a ) ; p r i n t f (Volume do c i l i n d r o = %f , volume ) ; return 0 ; }

Note que os valores passados na chamada da fun c ao devem corresponder aos par ametros em n umero e tipo. No caso, a fun c ao volume_cilindro espera receber dois par ametros do tipo float. A chamada da fun c ao passa dois valores para a fun c ao: os valores armazenados nas vari aveis raio e altura, ambas do tipo float. O valor retornado pela fun c ao e armazenado na vari avel volume, tamb em do tipo float. Note ainda que a chamada de uma fun c ao que tem um valor de retorno associado e uma express ao que, quando avaliada, resulta no valor retornado. Assim, uma chamada de fun c ao pode aparecer dentro de uma express ao maior. Por exemplo, se quis essemos calcular o volume de metade do cilindro, poder amos ter escrito:
volume = v o l u m e c i l i n d r o ( r a i o , a l t u r a ) / 2 . 0 ;

Por m, e importante notar que, na chamada da fun c ao, passa-se valores para a fun c ao chamada. Assim, qualquer express ao pode ser usada, desde que resulte num valor do tipo esperado. Por exemplo, e v alido a chamada de fun c ao abaixo, que pede para calcular o volume do cilindro com altura dobrada em rela c ao ao valor entrado pelo usu ario:
volume = v o l u m e c i l i n d r o ( r a i o ,2 a l t u r a ) ;

Escopo de vari aveis

Conforme discutido, requisitamos espa cos de mem oria para o armazenamento de valores atrav es da declara c ao de vari aveis. Quando, durante a execu c ao do c odigo, e encontrada uma declara c ao de vari avel, o sistema reserva o espa co de mem oria correspondente. Este espa co de mem oria permanece dispon vel para o programa durante o tempo de vida da vari avel. Uma vari avel declarada dentro de uma fun c ao e chamada vari avel local. Uma vari avel local tem seu tempo de vida denido pela fun c ao que a declarou: a vari avel existe durante a execu c ao da fun c ao. Assim que a fun c ao retorna, os espa cos de mem oria reservados para suas vari aveis locais s ao liberados para outros usos, e o programa n ao pode mais acessar estes espa cos. Por esse motivo, as vari aveis locais s ao tamb em classicadas como vari aveis autom aticas. Note que uma fun c ao pode ser chamada diversas vezes. Para cada execu c ao da fun c ao, os espa cos das vari aveis locais s ao automaticamente reservados, sendo liberados ao nal da execu c ao. As vari aveis locais s ao vis veis (i.e., podem ser acessadas) apenas ap os sua declara c ao e dentro da fun c ao em que foi denida. Dizemos que o escopo da vari avel local e a fun c ao que a dene. Dentro de uma fun c ao n ao se tem acesso a vari aveis locais denidas em outras fun c oes. Os par ametros de uma fun c ao tamb em s ao vari aveis autom aticas com escopo dentro da fun c ao. Essas vari aveis s ao inicializadas com os valores passados na chamada da fun c ao. Como as vari aveis locais, os par ametros representam vari aveis que vivem enquanto a fun c ao esta sendo executada. importante frisar que as vari E aveis locais t em escopo dentro da fun c ao que as declaram. Para esclarecer, vamos re-escrever a fun c ao auxiliar, alterando os nomes das vari aveis autom aticas (par ametros e vari avel local).
#define PI 3.14159

float volume cilindro ( float raio , float altura ) { f l o a t volume ; volume = PI r a i o r a i o a l t u r a ; return volume ; }

Note que agora as vari aveis da fun c ao auxiliar t em os mesmos nomes que as vari aveis da fun c ao main. Isto, no entanto, em nada altera o funcionamento do programa. Apesar dos nomes iguais, s ao vari aveis distintas, alocadas em diferentes areas de mem oria. Cada vari avel est a dentro do contexto da fun c ao que a declara. Existem outros tipos de vari aveis na linguagem C. Uma vari avel pode ser declarada fora das fun c oes, no espa co denominado global. Uma vari avel global vive ao longo de toda a execu c ao do programa e e vis vel por todas as fun c oes subseq uentes. Dentro de uma fun c ao, uma vari avel tamb em pode ser denida como est atica. Uma vari avel est atica tamb em existe durante toda a execu c ao do programa mas s o e vis vel dentro da fun c ao que a declara. Por ora, n ao trabalharemos com vari aveis globais e est aticas.

4.1

Modelo de pilha

Esta se c ao explica os detalhes de como os valores s ao passados para uma fun c ao. Esta explica c ao pode ajudar o leitor a entender melhor a aloca c ao de vari aveis autom aticas durante a execu c ao de um programa. No entanto, ela pode ser omitida numa primeira leitura. A aloca c ao dos espa cos de mem oria dos par ametros e das vari aveis locais seguem um modelo de pilha. Podemos fazer uma analogia com uma pilha de pratos. Quando queremos adicionar um prato na pilha, este prato s o pode ser colocado no topo da pilha. Se quisermos tirar pratos da pilha, s o podemos tirar os pratos que est ao no topo da pilha. O sistema gerencia a mem oria das 6

vari aveis autom aticas da mesma maneira. Uma area da mem oria do computador e reservada para armazenar a pilha de execu c ao do programa. Quando a declara c ao de uma vari avel e encontrada, o espa co de mem oria no topo da pilha de execu c ao e associado ` a vari avel. Quando o tempo de vida da vari avel se extingue, o espa co correspondente do topo da pilha e liberado para ser usado por outra vari avel. Para ilustrar o modelo de pilha, vamos usar um esquema representativo da mem oria do computador usado para armazenar a pilha de execu c ao. A Figura 1 ilustra a aloca c ao de vari aveis autom aticas na pilha durante a execu c ao do programa que faz o c alculo do volume de um cilindro, reproduzido abaixo:
#include < s t d i o . h> #define PI 3.14159

f l o a t v o l u m e c i l i n d r o ( f l o a t r , f l o a t h) { float v ; v = PI r r h ; return v ; } i n t main ( void ) { f l o a t r a i o , a l t u r a , volume ; p r i n t f (Entre com o v a l o r do r a i o : ) ; scanf (%f , &r a i o ) ; p r i n t f (Entre com o v a l o r da a l t u r a : ) ; scanf (%f , &a l t u r a ) ; volume = v o l u m e c i l i n d r o ( r a i o , a l t u r a ) ; p r i n t f (Volume do c i l i n d r o = %f , volume ) ; return 0 ; }

Quando a execu c ao do programa se inicia, a fun c ao main come ca sua execu c ao. No nosso exemplo, no in cio da fun c ao, tr es vari aveis s ao declaradas (Figura 1(a)). As tr es vari aveis s ao ent ao alocadas no topo da pilha (inicialmente vazia). Como nenhum valor e atribu do ` as vari aveis, os espa cos de mem oria correspondente armazenam valores indenidos (lixos). Em seguida, o programa requisita que o usu ario dena os valores do raio e da altura do cilindro. Estes valores capturados s ao atribu dos ` as vari aveis correspondentes (Figura 1(b)). Ap os a captura dos valores, a fun c ao main invoca a fun c ao auxiliar para realizar o c alculo do volume. A chamada da fun c ao representa primeiramente uma transfer encia do uxo de execu c ao para a fun c ao. Os par ametros da fun c ao s ao alocadas na pilha e seus valores s ao inicializados com os valores passados na chamada da fun c ao (Figura 1(c)). Note que neste momento, como o controle da execu c ao foi transferido para a fun c ao auxiliar, n ao se tem acesso ` as vari aveis declaradas dentro da fun c ao main, apesar delas ainda estarem alocadas na base da pilha (a fun c ao main ainda n ao terminou, apenas teve a sua execu c ao suspensa). Em seguida, dentro da fun c ao auxiliar, uma vari avel local adicional e declarada, sendo alocada no topo da pilha de execu c ao, inicialmente com valor indenido (Figura 1(d)). A fun c ao auxiliar ent ao computa o valor do volume e atribui a vari ` avel local (Figura 1(e)). Este valor e ent ao retornado pela fun c ao. Neste momento, a fun c ao auxiliar termina sua execu c ao e o controle volta para a fun c ao main. Os par ametros e vari aveis locais da fun c ao auxiliar s ao desempilhadas e deixam de existir. Finalmente, j a no retorno do controle para a fun c ao main, o valor retornado pela fun c ao e atribu do ` a vari avel

volume (Figura 1(f)).

raio = readoat(); altura = readoat();

oat raio, altura, volume;

main

volume altura raio (a)

main

volume altura raio (b)

2 4

volume = volume_cilindro(raio,altura);

oat v;

volume_cilindro main

h r volume altura raio (c)

2 4 2 4

volume_cilindro main

v h r volume altura raio (d)

2 4 2 4

v = PI * r * r * h;

volume = volume_cilindro(raio,altura);

volume_cilindro main

v h r volume altura raio

100.48 2 4 2 4 (e)

main

volume altura raio

100.48 2 4 (f)

Figura 1: Pilha de vari aveis durante execu c ao de um programa. Este exemplo simples serve para ilustrar o funcionamento do modelo de pilha. Logicamente, programas reais s ao mais complexos. Em geral, um programa tem v arias fun c oes auxiliares. Fun c oes auxiliares podem evidentemente chamar outras fun c oes auxiliares, sempre seguindo o modelo de pilha. Ao t ermino da execu c ao de cada fun c ao, as vari aveis locais correspondentes s ao desempilhadas e o controle volta para a fun c ao que chamou.

Trabalhando com v arias fun co es

Para exemplicar a organiza c ao de programas em diferentes fun c oes, vamos considerar o problema de computar propriedades geom etricas de modelos obtidos por composi c ao. Para ilustrar, vamos considerar o projeto de uma nova pe ca mec anica. Para se projetar uma pe ca e necess ario 8

a exist encia de uma metodologia de modelagem. Um processo de modelagem muito usado e a cria c ao de modelos por composi c ao. Um novo objeto pode ser modelado atrav es de v arios objetos simples, combinados atrav es de opera c oes booleanas (uni ao, interse c ao e diferen ca). A Figura 2 ilustra um modelo de uma pe ca com furos em forma de L, obtida por uma uni ao de duas caixas (paralelogramas) e duas diferen cas de cilindros: a primeira caixa tem dimens ao b h e e a segunda tem dimens ao b (b e) e; os dois cilindros t em altura e e raio d . 2
e b

b-e b

Figura 2: Exemplo de objeto modelado por composi c ao. Vamos considerar o problema de calcular as propriedades geom etricas desta pe ca. Em particular, queremos calcular o volume e a area da superf cie externa. Em resumo, queremos construir um programa que capture as dimens oes da pe ca fornecidas via teclado (altura (h), base (b), espessura (e) e di ametro do furo (d)) e exiba o volume e a area da superf cie externa da pe ca na tela. Para tanto, podemos pensar em organizar nosso programa em pequenas fun c oes. Inicialmente, vamos pensar na codica c ao de fun c oes para o c alculo de propriedades f sicas de objetos simples. Para a pe ca em quest ao, identicamos a necessidade de computar as seguintes propriedades: volume de caixa (paralelogramo) volume de cilindro area externa de caixa area externa de cilindro area de ret angulo area de c rculo Uma fun c ao para computar o volume de uma caixa pode ser expressa por:
f l o a t volume caixa ( f l o a t a , f l o a t b , f l o a t c ) { float v ; v = a b c; return v ; }

onde a, b e c representam os lados da caixa. A mesma fun c ao pode ser escrita de forma mais concisa, por:
f l o a t volume caixa ( f l o a t a , f l o a t b , f l o a t c ) { return a b c ; }

As demais fun c oes podem ser codicadas de forma similar:

#define PI 3.14159

f l o a t v o l u m e c i l i n d r o ( f l o a t r , f l o a t h) { return PI r r h ; } float area caixa ( float a , float b , float c) { return 2 ( a b + b c + c a ) ; } f l o a t a r e a c i l i n d r o ( f l o a t r , f l o a t h) { return 2 PI r h ; } f l o a t a r e a r e t a n g u l o ( f l o a t a , f l o a t b) { return a b ; } float area circulo ( float r ) { return PI r r ; }

Com estas fun c oes, podemos construir nossa fun c ao principal. O volume da pe ca ilustrada na Figura 2 pode ser obtido somando os volumes das duas caixas e diminuindo o volume dos dois cilindros. A area da superf cie externa pode ser feito somando as areas das duas caixas e as areas dos dois cilindros, e diminuindo duas areas retangulares ( area de contato entre as duas caixas) e quatro areas de c rculos (tampos dos cilindros). A codica c ao desta fun c ao e ilustrada a seguir.
i n t main ( void ) { float h , b , e , d ; float v , s ;

/ dimens o es da pe c a / / volume e a rea da s u p e r f c i e /

/ c a p t u r a v a l o r e s f o r n e c i d o s v i a t e c l a d o /

p r i n t f (Entre com a a l t u r a : ) ; scanf (%f , &h ) ; p r i n t f (Entre com a base : ) ; scanf (%f , &b ) ;

10

p r i n t f (Entre com a espessura : ) ; scanf (%f , &e ) ; p r i n t f (Entre com o diametro dos f u r o s : ) ; scanf (%f ,&d ) ;
/ c a l c u l o do volume da pe c a /

v = volume caixa (b , h , e ) + volume caixa (be , b , e ) 2 v o l u m e c i l i n d r o (d/2 , e ) ;

/ c a l c u l o da a rea da s u p e r f c i e e x t e r n a /

s = a r e a c a i x a (b , h , e ) + a r e a c a i x a (b , be , e ) + 2 a r e a c i l i n d r o (d/2 , e ) 2 a r e a r e t a n g u l o (b , e ) 4 a r e a c i r c u l o (d /2);
/ e x i b e na t e l a os v a l o r e s computados /

p r i n t f (Volume = %f e Area = %f \ n , v , s ) ; return 0 ; }

11

Exerc cios
1. No programa para c alculo de volume e area da superf cie da pe ca em forma de L, crie duas fun c oes auxiliares adicionais para calcular o volume e a area, respectivamente, de uma caixa com um furo cil ndrico. As fun c oes devem receber como par ametros as dimens oes da caixa com furo: altura, base, espessura e di ametro do furo. 2. Usando as fun c oes do item anterior, re-escreva a fun c ao main para que ela utilize estas fun c oes. 3. Escreva um programa, estruturado em diversas fun c oes, para calcular o volume de uma pe ca formada por uma esfera com um furo cil ndrico, dados os valores de d e D conforme ilustrado na Figura 3. Sabe-se que o volume de uma calota esf erica de altura h e dada por 1 2 (3R h), onde R representa o raio da esfera. h 3
D d

Figura 3: Modelo de uma esfera com furo cil ndrico: vistas 3D e 2D.

12