Aula 02 e 03 - Modularização - Funcoes 1.1

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Programação II
Unidade 1 - Modularização
parte 1.1
Universidade Federal de Santa Catarina
Campus Araranguá
Daniel Cruz
‹#›
1
Uma maneira de realizar a modularização em desenvolvimento de software é criar CAIXAS PRETAS. 
Uma CAIXA PRETA em software é um módulo que internamente não precisa ser mostrado a ninguém; 
Usuários interagem com este módulo apenas através das suas interações 
Modularização 
‹#›
Modularização
‹#›
Funções em Linguagem “C”
O que são “Funções”? (ou subprogramas ou subrotinas)
São trechos de código fonte agrupados sob um nome, que podem ser chamados sempre que for necessário executar uma determinada ação programada neste trecho; 
Como usar funções?
Atribui-se um nome à uma sequência de comandos, e faz-se referência a este nome nos vários lugares do programa onde a sequência em questão deveria ser repetida.
‹#›
Funções em Linguagem “C”
Por que usar funções?
Evita escrita repetida de código (uma certa sequência de comandos deve ser repetida em vários lugares de um programa).
Economiza o tempo gasto com o trabalho de copiar estas sequências;
Evitar a necessidade de mudar em múltiplos lugares caso deseje alterar o seu funcionamento;
Dividir grandes tarefas de computação em tarefas menores:
Facilita o gerenciamento de grandes sistemas e 
Aumenta a confiabilidade dos mesmos. 
Resumo: Principais motivações para uso das funções!
Evitar repetição de código
Modularização
‹#›
Funções em Linguagem “C”
Funções em “C"
Em “C”, todo programa é composto por funções;
Já utilizamos muitas funções, mesmo sem saber que eram funções(printf, scanf, sqrt, e até a famosa função “main”…)
Formato de declaração de funções :
tipo_de_retorno especifica o tipo do valor que será retornado para quem chamou a função (int, float, double, char, void).
Se o tipo_de_retorno for void significa que se trata de uma função que se comporta como uma subrotina; ou seja, a função não necessita retornar nenhum valor (exemplo: printf)
tipo_de_retorno nome_da_função (tipo1 param1, tipo2 param2,..., tipoN paramN)
{
	/* corpo da função */
	return valor_de_retorno;
} /* fim da função */
‹#›
Funções em Linguagem “C”
Exemplo: Calcular o fatorial de um número n(sem função):
‹#›
Funções em Linguagem “C”
Exemplo: Calcular o fatorial de um número n (com função):
Declarando como variável global 
‹#›
Funções em Linguagem “C”
Função fat recebendo um número como parâmetro(por valor!)
#include <stdio.h>
#include <stdlib.h>
int i,n,fatorial;
int fat(int numero)
{
	fatorial = 1;
	for(i=2;i<=numero;i++)
		{ fatorial = fatorial * i; }
	return(fatorial);
}
int main()
{
	printf(“Digite o numero N:”);
	scanf(“%d”, &n);
	if(n>=0){printf(“O fatorial de N = %d vale %d.\n”, n, fat(n));}
	else {printf(“Não existe fatorial de numero negativo\n”);}
 system("PAUSE");	
 return 0;
}
‹#›
Funções em Linguagem “C”
‹#›
Funções em Linguagem “C”
Agora o programa principal-função main- não precisa mais “conhecer” as variáveis i e fatorial. Portanto estas podem ser variáveis “locais” à função “fat”.
‹#›
Funções em Linguagem “C”
Variáveis “locais” às funções “fat” e “main”.
#include <stdio.h>
#include <stdlib.h>
int fat(int numero)
{
int i,fatorial;
	fatorial = 1;
	for(i=2;i<=numero;i++)
		{ fatorial = fatorial * i; }
	return(fatorial);
}
int main()
{
int n;
	printf(“Digite o numero N:”);
	scanf(“%d”, &n);
	if(n>=0){printf(“O fatorial de N = %d vale %d.\n”, n, fat(n));}
	else {printf(“Não existe fatorial de numero negativo\n”);}
 system("PAUSE");	
 return 0;
}
‹#›
Crie um programa onde o usuário digita dois valores e imprima na tela a soma destes valores na tela, utilizando uma função do tipo int.
Exercício 1
‹#›
 #include<stdio.h>
// ----------Funcao SOMA----------
 int soma(int v1,int v2){
 return(v1+v2);
 }
// ----------Funcao SOMA----------
 main(){
 int v1,v2;
 int total;
 printf("Digite dois valores: ");
 scanf("%d",&v1);
 scanf("%d",&v2);
 total=soma(v1,v2);
 printf("Soma: %d",total);
 // printf("Soma: %d", soma(v1,v2));
 getch();
 }
Exercício 1: Solução
‹#›
Crie um programa onde o usuário digita dois valores e imprima na tela a soma destes valores na tela, utilizando uma função do tipo void
Exercício 1.1
‹#›
 #include<stdio.h> 
 
 int soma(int valor1,int valor2){ 
 printf("Soma: %d",valor1+valor2); 
 } 
 main(){ 
 int v1,v2; 
 int total; 
 printf("Digite dois valores: "); 
 scanf("%d",&v1); 
 scanf("%d",&v2); 
 soma(v1,v2); 
 getch(); 
 }
Exercício 1.1: Solução
‹#›
Crie um programa onde o usuário digita três valores e imprima na tela o maior valor, devendo para isso, criar uma função Maior do tipo int que retorna o maior dos três valores.
Exercício 2
‹#›
 #include<stdio.h> 
 
 int Maior(int v1,int v2,int v3){ 
 if((v1>=v2)&&(v1>=v3)){ 
 return v1; 
 } 
 else{ 
 if ((v2>=v1) && (v2>=v3))
 { 
 return v2; 
 } 
 else
 { 
 return v3; 
 } 
 } 
 }
Exercício 2: Solução
 main(){ 
 int v1,v2,v3; 
 printf("Digite 3 valores: "); 
 scanf("%d",&v1); 
 scanf("%d",&v2); 
 scanf("%d",&v3); 
 printf("Maior: %d“ , Maior(v1,v2,v3)); 
 getch(); 
 }
‹#›
Crie um programa onde o usuário digita três valores e imprima na tela o menor valor, devendo para isso, criar uma função Menor do tipo void que imprime na tela o menor valor..
Exercício 3
‹#›
 #include<stdio.h> 
 void Menor(int v1,int v2,int v3){ 
 if((v1<=v2)&&(v1<=v3)){ 
 printf("Menor: %d",v1); 
 } 
 else{ 
 if((v2<=v1)&&(v2<=v3)){ 
 printf("Menor: %d",v2); 
 } 
 else{ 
 printf("Menor: %d",v3); 
 } 
 } 
 }
Exercício 3: Solução
 main(){ 
 int v1,v2,v3; 
 printf("Digite 3 valores: "); 
 scanf("%d",&v1); 
 scanf("%d",&v2); 
 scanf("%d",&v3); 
 Menor(v1,v2,v3); 
 getch(); 
 }
‹#›
Programação II
Unidade 1 - Modularização
parte 1.2
Universidade Federal de Santa Catarina
Campus Araranguá
Daniel Cruz
‹#›
21
Crie um programa onde o usuário digita dois valores e imprima a soma, subtração, multiplicação e divisão do primeiro valor pelo segundo, sendo que deverá ser criada uma função para cada operação.
Exercício 4
‹#›
 #include<stdio.h> 
 int soma(int a,int b){ 
 return(a+b); 
 } 
 int subtrai(int a,int b){ 
 return(a-b); 
 } 
 int multiplica(int a,int b){ 
 return(a*b); 
 } 
 float divide(int a,int b){ 
 return((float)a/b); 
 }
Exercício 4: Solução
 main(){ 
 int v1,v2; 
 printf("Digite 2 valores: "); 
 scanf("%d",&v1); 
 scanf("%d",&v2); 
 printf("Soma: %d",soma(v1,v2)); 
 printf("\nSubracao: %d",subtrai(v1,v2)); 
 printf("\nMultiplicacao: %d",multiplica(v1,v2)); 
 printf("\nDivisao: %.2f",divide(v1,v2)); 
 getch(); 
 } 
‹#›
Criar uma função que retorne o seguinte: A função recebe 3 valores float (x, y e z) e retorne o quadrado de x + a soma de y e x). 
Formula: (pow(x,2) + (y + z))	
Exercício 5
‹#›
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
float calcula (float x, float y, float z)
 {
 return (pow(x,2)+(y+z));
 }
Exercício 5: Solução
 main()
{
 int x, y, z;
 float vet[3];
 printf("\nDigite um numero: ");
 scanf("%d",&x);
 printf("\nDigite um numero: ");
 scanf("%d",&y);
 printf("\nDigite um numero: ");
 scanf("%d",&z);
 printf("\n\nO Resultado e: %3.2f\n", calcula(x,y,z));
 
 system("pause");
 return(0);
}
‹#›
Funções em Linguagem “C”
Parece que ficou mais complicado????Então vamos fazer o seguinte programa:
Como calcular a combinação de N elementos P a P????
Simples: Basta calcular pela fórmula:
Então, vamos lá!!!!
Primeiro, sem funções!!!
‹#›
Combinação sem Funções
#include <stdio.h>
#include <stdlib.h>
int N,P,i;
int Fat1, Fat2, Fat3;
int main()
{
 printf("Digite o numero N:");
 scanf("%d", &N);
 printf("Digite o numero P:");
 scanf("%d", &P);
 if(N<0 || P<0)
 {
	printf("Não existe combinação negativa.\n"); 
	system("PAUSE");	
 	return 0;
	}
	else
	
{ // Iniciou o else
 Fat1 = 1;
 for(i=2;i<=N;i++)
 { 
 Fat1 = Fat1 * i; }
 Fat2 = 1;
	for(i=2;i<=P;i++)
	 { Fat2 = Fat2 * i; }
	 Fat3 = 1;
	 for(i=2;i<=(N-P);i++)
 {
 		Fat3 = Fat3 * i; }
		 printf("A combinação de %d numeros %d a %d vale %d.\n", N,P,P, Fat1/(Fat2*Fat3));
		 system("PAUSE");	
 		 return 0;
	} // Acabou o else
}// Acabou a função main
‹#›
Combinação com Funções
#include <stdio.h>
#include <stdlib.h>
int fat(int numero)
{
int i,fatorial;
	fatorial = 1;
	for(i=2;i<=numero;i++)
		{ fatorial = fatorial * i; }
	return(fatorial);
}
	
int main()
{
int N,P;
	printf("Digite o numero N:");
	scanf("%d”, &N);
	printf("Digite o numero P:");
	scanf("%d", &P);
	if(N<0 || P<0)
	{
		printf("Não existe combinação negativa\n"); 
	}
	else
	{ 
		 printf("A combinação de %d numeros %d a %d 		vale %d.\n", N,P,P,fat(N)/(fat(P)*fat(N-P));
 	} 
 system("PAUSE");	
 return 0;
}
‹#›
Aspectos Importantes sobre Funções em Linguagem “C”
Funções permitem que cada “parte”(função) do programa possua suas próprias variáveis locais, evitando “confusões” em programas grandes (será que alguém já usou a variável "i“???)
Usualmente existe um arquivo (.h) onde são definidos os “protótipos” das funções(os cabeçalhos). A partir daí é possível saber como utilizar as funções (quantos parâmetros as funções possuem, qual a sua ordem e quais os seus tipos).
 
‹#›
Funções “Recursivas” em Linguagem “C”
 #include<stdio.h>
#include<stdlib.h>
long int fatorial(int); /* prototipo da funcao fatorial */
int main(void)
{ 
int N; /* declaracao da variavel local N*/
long int F; /* declaracao da variavel local F */
	printf(“Entre com um valor inteiro: “);
	scanf(“%d”,&N);
	F = fatorial( N);
	if (F != -1) 
	{
	 printf(“O fatorial de %d e´ %ld \n”,N,F);
	}
	else 
	{	
	 printf(“Não existe fatorial de numero negativo \n”);
	}
system(“pause”);
return(0);
}
long int fatorial(int N)
{ 
long int Fat;
 if (N==0 )
 {
 return(1); /* definição de fatorial de 0*/
 }
 else
 { 
 if (N>0)
 {
	Fat = N*fatorial(N-1);
 	return(Fat);
 }
	else
 	 {
	 return(-1);/* Indica que não há fatorial */
	 }
	}
}
‹#›
Funções e Vetores
#include <stdio.h>
#include <stdlib.h>
#define NUM_ALUNOS 3
float media ( float notas[], int n )
{
	int i = 0;
	float m = 0.0;
	
	for ( i = 0; i < n; i++ )
	{
		m = m + ( notas[i] / n );
	}
	return m;
}
int main( )
{
float notas [NUM_ALUNOS];
float media_turma;
int i;
 for ( i = 0; i < NUM_ALUNOS; i++ )
 {
 do
 {
 printf ("Digite a nota do %d o. aluno: ", i+1);
 scanf ("%f", &notas[i]);
 } while ( ( notas[i] < 0.0 ) || ( notas[i] > 10.0 ) );
 }
 media_turma = media ( notas, NUM_ALUNOS );
 printf ("A media da turma eh %.2f \n", media_turma);
 system ("Pause");
 return 0;
}
‹#›
Funções em Linguagem “C”
Exercício 1:
Fazer um programa capaz de calcular a área de um quadrado, um retângulo ou um triângulo retângulo. 
O programa deve perguntar qual a figura geométrica, e então pedir para o usuário digitar os tamanhos dos lados. 
Um quadrado só tem um tamanho de lado, o retângulo tem dois, e o triângulo retângulo também tem dois lados(mais a hipotenusa, mas neste caso não é necessário digitar este valor).
Após a digitação, o programa deve calcular a área e apresentar ao usuário.
Utilizar uma função para a leitura dos lados (verificando se não é digitado um valor negativo para o lado), e uma função para o cálculo de cada área. As fórmulas são:
Área_quadrado = lado * lado
Área_retângulo = lado1 * lado2
Área_triângulo = (lado 1 * lado 2)/2
 
‹#›
Funções em Linguagem “C”
Exercício 2:
Criar um programa capaz de calcular o tempo entre dois horários quaisquer de um determinado dia.
O programa deve ler dois horários, compostos por três números inteiros, representando horas, minutos e segundos. O programa deve verificar se o horário é válido(horas entre 0 e 23, minutos entre 0 e 59, e segundos entre 00 e 59).
O programa deve ter uma função para calcular a quantidade de segundos em um horário, e outra função para calcular e imprimir a quantidade de horas, minutos e segundos em uma quantidade de segundos;
 
‹#›
Funções em Linguagem “C”
Exercício 3:
Criar um programa capaz de ler duas notas de cada um dos 10 alunos de uma turma, calculando a média geral da primeira e da segunda prova. Em seguida, informe quantos alunos tiraram notas acima da média, tanto na primeira como na segunda prova.
 
‹#›
Funções em Linguagem “C”
Exercício Desafio: Fazer um programa para ler 2 matrizes 2x2 e imprimir na tela as matrizes, e sua soma.
Digite os 4 valores da matriz:
Valor [0][0] = 1
Valor [0][1] = 2
Valor [1][0] = 3
Valor [1][1] = 4
Digite os 4 valores da matriz:
Valor [0][0] = 1
Valor [0][1] = 2
Valor [1][0] = 3
Valor [1][1] = 4
A primeira matriz eh:
1 2
3 4
A segunda matriz eh:
1 2
3 4
A soma das duas matrizes eh:
2 4
6 8
 
‹#›