Вы находитесь на странице: 1из 57

Cap.

5: Funes
Objetivos
Funes em C
Cabealho e corpo de uma funo
Parmetros
Passagem de parmetros de tipos bsicos
Valor de retorno (return)
O tipo void
Prottipos de funes
Variveis locais.
Introduo
Embora ainda sem saber como escrever uma funo, j
as temos utilizado ao longo dos nossos programas. So
exemplos as funes printf, scanf, putchar, etc., que
fazem parte da biblioteca standard de C e nos so
fornecidas quando adquirimos qualquer compilador de
C.
Nesta aula iremos aprender como escrever funes e
procedimentos, como passar parmetros e como
devolver algum valor como resultado de uma funo.
absolutamente indispensvel que um programador de
C domine completamente a escrita de programas de
forma modular, atravs de procedimentos e funes.
Problema: Escreva um programa que coloque na
tela a seguinte sada, escrevendo a linha de 20
asteriscos atravs de um lao for.
********************
Numeros entre 1 e 5
********************
1
2
3
4
5
********************
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
/* Escrita do cabealho */
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
puts("Numeros entre 1 e 5");
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
/*Escrita dos numeros*/
for(i=1;i<=5;i++)
printf("%d\n",i);
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
system("pause");
}
Como se pode observar, o conjunto de cdigo utilizado para
escrever uma linha de asteriscos na tela
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
aparece repetido trs vezes. O ideal seria escrever esse trecho
de cdigo apenas uma nica vez e invoc-lo sempre que
necessrio. A soluo dividir o programa em pequenos
fragmentos de cdigo , cada um dos quais responsvel
por uma determinada tarefa.
Problema: Escreva um programa que coloque uma linha com 20
asteriscos na tela.
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
system("pause");
}
O programa anterior coloca na tela uma linha com 20
asteriscos. Foi implementado como sendo a funo main.
Como a sua funo escrever uma linha, em vez de se
chamar main vamos cham-lo linha.
#include <stdio.h>
#include <stdlib.h>
linha()
{
int i;
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
system("pause");
}
Se tentarmos criar um executvel com esse cdigo vamos obter um
erro de linkagem, uma vez que a funo main no se encontra
presente no programa.
Nota:
Um programa em C tem que possuir SEMPRE a funo main escrita
no seu cdigo, independente do nmero e da variedade de
funes que o programa contenha.
Aquilo que fizemos foi escrever o cdigo
responsvel pela colocao de uma linha na tela.
O fato de esta funo existir no quer dizer que
ela venha a ser executada, do mesmo modo que
um funcionrio de um restaurante apenas serve
um determinado prato quando um cliente lhe
pede, embora ele exista no menu do restaurante.
a funo main() (ou outra qualquer invocada pela
funo main) que ter que solicitar os servios
dessa funo. Isso realizado escrevendo o nome
da funo com os respectivos parnteses, tal
como faramos para a funo getchar ou qualquer
outra.
linha();
Dessa forma o programa anterior poderia ser escrito
da seguinte forma:
#include <stdio.h>
#include <stdlib.h>
linha()
{
int i;
for(i=0;i<=20;i++)
putchar('*');
putchar('\n');
}
main()
{
int i;
linha();
puts("Numeros entre 1 e 5");
linha();
for(i=1;i<=5;i++)
printf("%d\n",i);
linha();
system("pause");
}
Pelo cdigo apresentado, o programa possui duas funes escritas no
mesmo arquivo. A funo main responsvel por iniciar o programa e
executar todas as instrues presentes no seu interior. A funo linha
responsvel por escrever uma linha na tela. Assim, sempre que
pretendermos escrever uma linha na tela bastar invocar a funo
linha(), evitando escrever sempre todo o cdigo que esta executa.
Esse tipo de abordagem tem muitas vantagens. Uma das principais
que se por algum motivo for necessrio alterar a linha da tela
(substituir o * por ou escrever 30 caracteres ao invs de 20),
bastar alterar apenas uma vez o cdigo respectivo na funo linha.
Caso no se utilizasse uma funo, seria necessrio alterar todas as
ocorrncias do lao responsvel pela escrita na tela.
Nota:
As variveis declaradas dentro de um bloco so locais a esse bloco, no
sendo conhecidas fora dele.
Notar que a varivel i (que declarada em ambas as funes) assim
local a cada uma das funes. Isso quer dizer que so variveis
diferentes que se encontram escritas na funo main e na funo
linha, embora o nome das variveis seja igual.
Caractersticas de uma
Funo
Cada funo tem que ter um nome nico, o qual serve para a sua
invocao em algum lugar no programa a que pertence.
Uma funo pode ser invocada a partir de outras funes.
Uma funo (como o nome indica) deve realizar UMA NICA
TAREFA bem definida.
Uma funo deve se comportar como uma caixa preta. No
interessa como funciona, o que interessa que o resultado final
seja o esperado, sem efeitos colaterais.
O cdigo de uma funo deve ser o mais independente possvel
do resto do programa, e deve ser to genrico quanto possvel,
para poder ser reutilizado em outros projetos.
Uma funo pode receber parmetros que alterem o seu
comportamento de forma a adaptar-se facilmente a situaes
distintas.
Uma funo pode retornar, para a entidade que a invocou, um
valor como resultado do seu trabalho.
Nome de uma funo
A escolha do nome de uma funo
obedece s regras apresentadas para a
designao de variveis.
O nome de uma funo deve ser nico
(no pode ser igual ao nome de outra
funo ou de uma varivel).
O nome de uma funo deve especificar
aquilo que a funo na realidade faz, e
deve ser de fcil leitura e interpretao.
Como funciona uma funo
O cdigo de uma funo s executado quando esta
invocada em alguma parte do programa a que est de
algum modo ligada.
Sempre que uma funo invocada, o programa que a
invoca suspenso temporariamente. Em seguida, so
executadas as instrues presentes no corpo da funo.
Uma vez terminada a funo, o controle de execuo do
programa volta ao local em que esta foi invocada.
O programa que invoca uma funo pode enviar
argumentos, que so recebidos pela funo. Estes so
recebidos e armazenados em variveis locais, que so
automaticamente iniciadas com os valores enviados. A
essas variveis d-se o nome de parmetros.
Depois de terminar o seu funcionamento, uma funo pode
devolver um valor para o programa que a invocou.
Problema: Escreva um programa que, recorrendo a trs
funes distintas, escreva na tela a seguinte sada:
***
*****
*******
*****
***
1: #include <stdio.h> 17: linha7x()
2: #include <stdlib.h> 18: {
3: linha3x() 19: int i;
4: { 20: for(i=1;i<=7;i++)
5: int i; 21: putchar('*');
6: for(i=1;i<=3;i++) 22: putchar('\n');
7: putchar('*'); 23: }
8: putchar('\n'); 24: main()
9: } 25: {
10: linha5x() 26: linha3x();
11: { 27: linha5x();
12: int i; 28: linha7x();
13: for(i=1;i<=5;i++) 29: linha5x();
14: putchar('*'); 30: linha3x();
15: putchar('\n'); 31: system("pause");
16: } 32: }
Para a realizao do programa escrevemos quatro funes:
linha3x: funo responsvel por escrever trs asteriscos
na tela
linha5x: funo responsvel por escrever trs asteriscos
na tela
linha7x: funo responsvel por escrever trs asteriscos
na tela
main: funo que invoca as funes.
Se olharmos com ateno para o cdigo das funes
verificaremos que em tudo igual, exceto nas seguintes
linhas:
6: for(i=1;i<=3;i++)
13: for(i=1;i<=5;i++)
20: for(i=1;i<=7;i++)
que correspondem ao nmero de asteriscos a serem
apresentados na tela.
O ideal seria escrever uma nica funo linha,
responsvel pela escrita de uma linha na tela, com
um nmero de asteriscos especfico em cada
chamada. Nesse caso interessa-nos indicar
funo qual o nmero de caracteres a serem
colocados na tela.
Se quisermos escrever trs asteriscos invocamos a
funo linha(3).
Se quisermos escrever cinco asteriscos invocamos a
funo linha(5).
Se quisermos escrever 123 asteriscos invocamos a
funo linha(123).
A funo sempre a mesma (funo linha), o que
muda o nmero de caracteres para serem
colocados na tela.
No programa anterior o nosso main passaria a ser:
24: main()
25: {
26: linha(3);
27: linha(5);
28: linha(7);
29: linha(5);
30: linha(3);
31: system("pause");
32: }
Como seria ento escrita a funo linha?
A funo linha recebe dentro de parnteses um valor do tipo
inteiro, o qual ter que ser colocado numa varivel.
Depois de armazenado o valor, o lao da funo linha ter que
executar o nmero de vezes que est armazenado nessa
varivel.
Qual o nome da funo a ser escrita?
linha()
Quantos parmetros vai receber?
1
Qual o tipo do parmetro?
inteiro
Escolha o nome para a varivel que vai armazenar
esse parmetro
num
O cabealho da funo ser assim
linha(int num) /* A funo recebe um inteiro que
armazena em num */
E o corpo da funo?
Bastar alterar a condio do controle do lao para
for (i=1; i<=num; i++)
Assim, o programa anterior poderia ser escrito da seguinte forma:

#include <stdio.h>
#include <stdlib.h>
linha(int num)
{
int i;
for(i=1;i<=num;i++)
putchar('*');
putchar('\n');
}

main()
{
linha(3);
linha(5);
linha(7);
linha(5);
linha(3);
system("pause");
}
Parmetros
A comunicao com uma funo se faz atravs dos
argumentos que lhe so enviados e dos
parmetros presentes na funo que os recebe.
O nmero de parmetros de uma funo pode ser
0, 1, 2, etc., dependendo apenas das
necessidades do programador.
Cada funo necessita, no entanto, saber qual o
tipo de cada um dos parmetros.
Nota:
Qualquer tipo de dado da linguagem pode ser
enviado como parmetro para uma funo,
mesmo os tipos de dados que venham a ser
definidos pelo programador.
Os parmetros de uma funo so separados por vrgula, e
absolutamente necessrio que para cada um deles seja
indicado o seu tipo.
funo(int x, char c, float k, double xpto)

O que foi referido anteriormente continua a ser verdade


para os parmetros de uma funo que sejam do mesmo
tipo.
funo(int x, int y, int k, int xpto) /* exemplo correto
*/
funo(int x,y,k,xpto) /*exemplo incorreto */

Nota:
Um parmetro no nada mais do que uma varivel local
funo a que pertence. Um parmetro automaticamente
iniciado com o valor enviado pelo programa invocador.
A passagem de argumentos para uma funo deve ser
realizada colocando-os dentro de parnteses, separados
por vrgulas, imediatamente aps o nome da funo.
Quando se faz a chamada de uma funo, o nmero e o tipo
dos argumentos enviados devem ser coincidentes com os
parmetros presentes no cabealho da funo.
No exemplo seguinte, a funcao recebe trs parmetros que
ela armazena em trs variveis denominadas ch (do tipo
char), n (do tipo int) e x (do tipo float). As variveis ch, n e
x so automaticamente iniciadas com os valores A, 123 e
23.456, respectivamente, que lhe so enviadas a partir do
main.
main()
{
funcao(A, 123, 23.456);
}
funcao(char ch, int n, float x)
{

}
Nota:
O nmero de parmetros enviados para uma funo deve
ser igual ao nmero de parmetros existente no
cabealho da funo. O tipo dos parmetros deve
igualmente corresponder, parmetro a parmetro.
Se a funo receber mais do que um parmetro, os
argumentos enviados so associados aos parmetros da
funo pela ordem em que so escritos.
Nota:
comum chamar parmetro tanto aos argumentos de
invocao de uma funo como aos verdadeiros
parmetros da funo.
Nota:
Qualquer expresso vlida em C pode ser enviada como
argumento para uma funo.
Problema: Altere o programa anterior de forma que a funo linha
escreva qualquer caractere, e no apenas o caractere asterisco.

#include <stdio.h>
#include <stdlib.h> Resultado:
linha(int num, char ch) +++
{ +++++
int i; -------
for(i=1;i<=num;i++) *****
putchar(ch); ***
putchar('\n');
}
main()
{
linha(3,'+'); Adicionar um novo parmetro
linha(5,'+'); funo permite-nos escrever uma
linha(7,'-'); linha com qualquer caractere que
linha(5,'*'); teremos de passar a adicionar na
linha(3,'*'); chamada da funo.
system("pause");
}
O Corpo da Funo
O corpo de uma funo constitudo por instrues
de C de acordo com a sintaxe da linguagem.
O corpo de uma funo tem que se seguir
imediatamente ao cabealho da funo, e escrito
entre chaves.
Nota:
O cabealho de uma funo NUNCA deve ser
seguido de ponto-e-vrgula (;)
Sempre que uma funo invocada pelo programa,
o corpo da funo executado, instruo a
instruo, at terminar o corpo da funo ou at
encontrar a instruo return, voltando
imediatamente ao programa em que foi invocada.
Nota:
Dentro do corpo de uma funo pode-se escrever
qualquer instruo ou conjuntos de instrues da
linguagem C. Em C no se pode definir funes
dentro de funes.
Qualquer instruo admissvel dentro de uma
funo (ex.: atribuies, if, for, switch, , invocar
outras funes, etc.)
O nmero de instrues que pode estar presente
dentro de uma funo no tem qualquer limite,
deve, no entanto, ser relativamente pequeno e
responsvel por realizar uma nica tarefa.
return
A instruo return permite terminar a execuo de uma funo
e voltar ao programa que a invocou.
A execuo da instruo return na funo main faz com que o
programa termine.

Exemplo:
#include <stdio.h>
main()
{
printf("Hello"); /* Escrever Hello */
return; /* Termina a funo (e o programa)
*/
printf(" World\n"); /* Esta linha nunca
executada */
}
Funes que retornam um
valor
possvel que uma funo seja responsvel por
realizar uma determinada tarefa e que, uma vez
terminada essa tarefa, devolva UM NICO
resultado. Esse resultado poder ser armazenado
numa varivel ou aproveitado por qualquer
instruo.
A devoluo de um resultado feita atravs da
instruo return, seguida do valor a ser devolvido.
Nota:
Aps a instruo return pode ser colocada qualquer
expresso vlida em C.
Suponhamos que quisssemos calcular a soma de dois nmeros
inteiros. A funo responsvel por essa tarefa dever ter a
capacidade de realizar a soma e de retornar o resultado desta.
n = soma(3,4);
printf("%d\n",n);
Repare que a funo soma ter que receber dois inteiros e ter que
devolver um resultado do tipo inteiro, que corresponder soma
dos dois parmetros recebidos pela funo.
Repare que a soma de x com y colocada numa varivel do tipo
inteiro, a qual , em seguida, devolvida como resultado da
funo.
int soma(int x, int y)
Tipo de Retorno {
int res;
res = x+y; Parmetros
return res;
}
Valor a Retornar
Escreva um programa que solicite dois nmeros ao usurio e
apresente na tela o resultado da sua soma e o dobro de cada um
deles.
#include <stdio.h>
#include <stdlib.h>
Resultado:
int soma(int a, int b)
{ Introduza dois numeros: 4 7
return a+b; 4+7=11
}
2*4=8 e 2*7=14
int dobro(int x)
{
return 2*x;
}
main()
{
int n, i, total;
printf("Introduza dois numeros: ");
scanf("%d%d",&n,&i);
total=soma(n,i);
printf("%d+%d=%d\n",n,i,total);
printf("2*%d=%d e 2*%d=%d\n",n,dobro(n),i,dobro(i));
system("pause");
}
Uma vez que a funo dobro devolve um
inteiro, o seu resultado pode ser usado
dentro de um printf, sendo escrito com o
formato de inteiro (%d).
Nota:
Uma funo pode ser invocada dentro de
outra funo. O resultado o mesmo que
se obteria se, em vez da chamada
funo, a estivesse o resultado devolvido
por esta.
Problema: Qual a sada da seguinte linha?
printf("%d\n",dobro(soma(dobro(2),3)));
dobro(2) 4
soma(dobro(2),3) soma(4,3) 7
dobro(soma(dobro(2),3)) dobro(soma(4,3))
dobro(7) 14
Assim, o valor colocado na tela seria 14.

A execuo anterior semelhante a:


a=dobro(2);
b=soma(a,3);
c=dobro(b);
printf("%d",c);
Nota:
Uma funo pode conter vrias instrues return. No entanto,
apenas uma instruo return executada na funo.
Exemplo: Escreva uma funo que calcule qual o maior de dois
nmeros inteiros.
int max(int n1, int n2)
{
if(n1>n2)
return n1;
else
return n2;
}
Note que se a funo recebe dois inteiros, ento o maior deles
certamente tambm um inteiro, logo a funo tem que
retornar um valor do tipo int.
Funes e Procedimentos
Em C existem apenas funes, enquanto em outras
linguagens existem dois tipos distintos de rotinas as
funes e os procedimentos. Por exemplo, a linguagem
PASCAL permite a definio de funes utilizando a palavra
reservada FUNCTION e permite definir procedimentos
atravs da palavra reservada PROCEDURE.
Qual a diferena entre uma funo e um procedimento?
Uma funo tem sempre um tipo e um valor de retorno
associados, enquanto um procedimento no devolve
qualquer valor.
Como exemplo de Funo temos a funo int max(int n1,
int n2), que verifica qual o maior dos inteiros e devolve
um deles.
Como exemplo de Procedimento temos a funo linha(),
que coloca na tela uma linha e termina em seguida sem
devolver qualquer valor.
Nota:
Sempre que no cabealho de uma funo no
colocado o tipo de retorno, este substitudo pelo
tipo int.
Dessa forma escrever
linha(int n)
equivalente a escrever
int linha(int n)
A forma de invocar funes e procedimentos
tambm diferente. No tendo um valor de
retorno, um procedimento invocado como se se
tratasse de uma instruo simples.
linha(12);
Quanto s funes, estas podem ser invocadas de trs
formas distintas:
Dentro de uma atribuio, para armazenar o valor
dentro de uma varivel.
x=soma(23,y)+dobro(k+2);
Dentro de uma funo, em que o valor de retorno
aproveitado como parmetro para outra funo.
printf(%d %d,dobro(5),soma(dobro(2),3+2));
ou
if(soma(x,y)>0)
Tal como se invoca um procedimento, perdendo-se,
nesse caso, o valor de retorno.
getchar(); /* para parar a tela. No
interessa qual o char digitado */
O tipo void
Em C existe uma palavra reservada void que permite indicar que uma funo
no devolve qualquer tipo. Dessa forma, a funo linha anteriormente
apresentada deveria ter sido escrita da seguinte forma:

#include <stdio.h>
#include <stdlib.h>
void linha(int num, char ch)
{
int i;
for(i=1;i<=num;i++)
putchar(ch);
putchar('\n');
}
main()
{
linha(3,'+');
linha(5,'+');
linha(7,'-');
linha(5,'*');
linha(3,'*');
system("pause");
}
habitual, tambm, encontrar a palavra reservada void para
indicar que uma funo no recebe qualquer parmetro.
Os dois trechos seguintes so equivalentes

void linha() void linha(void)


{ {
int i; int i;
for(i=1;i<=20;i++) for(i=1;i<=20;i++)
putchar(*); putchar(*);
putchar('\n'); putchar('\n');
} }

Nota:
Uma funo que retorna void chamada
normalmente de Procedimento.
Sempre que se quer sair de um procedimento,
usa-se a instruo return sem qualquer valor
ou expresso seguinte.
Nota:
A instruo return termina a execuo da funo
(procedimento), e o controle do programa
devolvido ao local onde a funo
(procedimento) foi invocada.
Existem alguns programadores que reforam na
definio de funo, uma vez que esta no
recebe qualquer argumento, colocando void
dentro dos parnteses. Escrevem assim a
funo func() como func(void).
Onde colocar as funes
Em C, as funes podem ser colocadas em qualquer local do
arquivo (por enquanto, apenas dentro de um nico
arquivo), antes ou depois de serem invocadas, antes ou
depois da funo main. Existe, no entanto, uma restrio
que deve ser levada em conta.
Suponhamos o seguinte programa:
1#include <stdio.h> 9: void linha()
2: #include <stdlib.h> 10: {
3: main() 11: int i;
4: { 12: for(i=1;i<=20;i++)
5: linha(); 13: putchar('*');
6: printf("Hello World\n"); 14: putchar('\n');
7: linha(); 15: }
8: }
Embora o cdigo esteja formalmente bem escrito,
vamos obter um erro de compilao semelhante a
conflicting types for linha
previous implicit declaration of linha
was here.
Como ser possvel que a funo linha esteja
redefinida, se ela escrita apenas uma vez
(linhas 9: a 15:)?
O processo de compilao , em geral, um processo
sequencial, que percorre todo o arquivo em que o
cdigo se encontra, do princpio at ao seu final.
Faz ento a verificao sinttica e, sempre que
tudo est bem, cria o arquivo com o cdigo
objeto.
Ora, estando a funo linha definida aps a funo main, o
compilador s sabe qual o seu cabealho quando a
compila. No entanto, a funo linha invocada pela funo
main. Como na altura em que a funo main compilada o
compilador ainda no a conhece, este cria um prottipo
(cabealho) para a funo linha semelhante a
int linha();

Quando encontra a funo linha (com o cabealho void


linha()), o compilador pensa que so duas funes distintas
(pois devolvem tipos diferentes) mas com o mesmo nome.
Como em C no podem existir duas funes com o mesmo
nome, o compilador apresenta o correspondente erro e
termina o processo de compilao.
Repare que se a funo linha devolvesse um inteiro no
haveria qualquer problema.
Como resolver ento esse problema?
A soluo indicar ao compilador qual o
cabealho (a interface) da funo, fazendo
a declarao da funo da mesma forma
que se declaram as variveis.
A declarao de uma funo consiste na
escrita do seu cabealho seguida de um
ponto-e-vrgula (;), e deve ser realizada
antes da utilizao da funo que se quer
declarar. Tradicionalmente, a declarao
realizada imediatamente aps os
#includes.
#include <stdio.h>
#include <stdlib.h>
void linha(); /* Declarao da Funo linha */
main()
{
linha();
printf("Hello World\n");
linha();
system("pause");
}
void linha()
{
int i;
for(i=1;i<=20;i++)
putchar('*');
putchar('\n');
}
Nota:
O prottipo de uma funo corresponde ao seu
cabealho seguido de um ponto-e-vrgula (;).
Este identifica toda a estrutura da funo
(nome, parmetros e tipo de retorno).
Um bom hbito de programao a colocao,
sempre, dos prottipos das funes no incio
dos programas, de forma a indicar ao
compilador qual a estrutura das funes que
vo ser utilizadas pelo programa. Dessa forma,
o compilador pode verificar, em cada
invocao de uma funo, se esta foi ou no
corretamente implementada.
Nota:
O prottipo de uma determinada
funo deve ser colocado apenas
antes da sua invocao. No entanto,
uma boa prtica de programao
colocar os cabealhos de todas as
funes definidas pelo programador
imediatamente antes do cdigo da
primeira funo.
#include <.....>
#include <.....>
void f1(int n, char ch); /* Prottipos das funes */
int max(int n1, int n2);
main()
{
.....
}
void f1(int n, char ch)
{
.....
}
int max(int n1, int n2)
{
.....
}
Variveis Locais
Como foi observado anteriormente, variveis podem ser
declaradas dentro do corpo de uma funo. Essas
variveis so visveis (isto , conhecidas) apenas dentro
da prpria funo.
Nota:
As variveis declaradas dentro de uma funo s so
conhecidas dentro dessa funo. So, por isso,
denominadas variveis locais.
A declarao de variveis dentro de uma funo deve ser
realizada antes de qualquer instruo.
funo(){
declarao de variveis
instrues
}
Essas variveis s podem ser utilizadas dentro da prpria
funo.
Se uma mesma varivel for declarada em duas
funes distintas no haver qualquer tipo de
problema, pois o compilador sabe qual utilizar em
cada uma delas. Apesar de terem o mesmo nome,
so variveis distintas sem qualquer relao, do
mesmo modo que podem existir dois indivduos
chamados Jos em salas distintas.
Nota:
Depois de terminada a execuo de uma determinada
funo, todas as suas variveis locais so destrudas.
Nota:
Sempre que possvel recorra a variveis locais,
evitando assim os efeitos colaterais que ocorrem
quando se utilizam variveis globais.
Exerccios Resolvidos
1. Escreva a funo x_isdigit, que verifica se um
determinado caractere dgito ou no. Escreva um
programa que teste a funo.
#include <stdio.h>
#include <stdlib.h>
/* funo que retorna 1 se for dgito, 0 se no for dgito */
int x_isdigit(char ch)
{
return(ch>='0' && ch<='9');
}
/* testa funo x_isdigit */
main()
{
char c;
while(1) /* termina com ctrl-c */
{
printf("Digite um numero entre 0 e 9 ou CTRL-C para sair:");
c=getchar();
fflush(stdin);
if(!x_isdigit(c)) /* se no for dgito */
printf("%c nao eh digito.\n",c);
else
printf("%c eh digito.\n",c);
}
system("pause");
}
Exerccios Resolvidos
2. Escreva a funo x_toupper, que transforma qualquer
caractere na maiscula correspondente. Escreva um
programa que teste a funo.
#include <stdio.h>
#include <stdlib.h>
/* funo retorna maiscula se ch for minscula, seno retorna ch */
int x_toupper(char ch)
{
if(ch>='a' && ch<='z') /* se minscula */
return ch += 'A'-'a';
else
return ch;
}
main()
{
char c;
while(1) /* termina com ctrl-c */
{
printf("Digite uma letra ou CTRL-C para sair:");
c=getchar();
fflush(stdin);
putchar(x_toupper(c));
printf("\n");
}
system("pause");
}
Exerccios Resolvidos
3. Implemente a funo
float Pot(float x, int n)
Devolve o valor de xn
x0=1.0
xn=x*x**x (n vezes)
#include <stdio.h>
#include <stdlib.h>
float Pot(float x, int n)
{
float res;
int i;
for(i=1,res=1.0;i<=n;i++)
res*=x;
return res;
}
main()
{
float b;
int e;
printf("entre com o valor da base:");
scanf("%f",&b);
printf("entre com o valor do expoente:");
scanf(" %d",&e);
printf("%.2f\n",Pot(b,e));
system("pause");
}

Вам также может понравиться