[Resolvido] [Tutorial] Subalgoritmos - Procedimentos e Funções

SUBALGORITMOS

A complexidade dos algoritmos está intimamente ligada à da aplicação a que se destinam. Em geral, problemas complicados exigem algoritmos extensos para sua solução. Sempre é possível dividir um problema grande em problemas menores e de solução mais simples.

Assim, podemos solucionar cada um destes problemas mais simples e combinar essas soluções de forma que o problema maior seja resolvido. Podemos codificar a solução destes problemas simples utilizando os chamados subalgoritmos ou subrotinas.

Subalgoritmo é um nome dado a um trecho de um algoritmo mais complexo e que, em geral, encerra em si mesmo um pedaço da solução de um problema maior – o algoritmo a que ele está subordinado.

Subalgoritmo divide-se em funções e procedimentos. É importante observar que na linguagem C não existe distinção entre funções (possui um único retorno) e procedimentos (não possui retorno algum). Um procedimentos, na linguagem C, é apenas uma função que não retorna nenhum valor.

A idéia de reutilização de software tem sido adotada há muito tempo por muitos desenvolvedores de sistemas de computador, devido à economia de tempo e trabalho que proporcionam.

Seu princípio é o seguinte: um conjunto de algoritmos destinado a solucionar uma série de tarefas bastante corriqueiras é desenvolvido e vai sendo aumentado com o passar do tempo, com o acréscimo de novos algoritmos. A este conjunto dá-se o nome de biblioteca.

No desenvolvimento de novos sistemas, procura-se ao máximo basear sua concepção em subalgoritmos já existentes na biblioteca, de modo que a quantidade de software realmente novo que deve ser desenvolvido é minimizada.

Muitas vezes os subalgoritmos são utilizados para conter certas seqüências de instruções que são repetidas em um algoritmo. Nestes casos, os subalgoritmos proporcionam uma diminuição no tamanho dos algoritmos.

Em resumo, os subalgoritmos são importantes na:

subdivisão de algoritmos complexos, facilitando o seu entendimento;

estruturação de algoritmos, facilitando principalmente a detecção de erros e a documentação de sistemas; e,

modularização de sistemas, que facilita a manutenção de softwares e a reutilização de subalgoritmos já implementados.

FUNÇÕES

A linguagem C é baseada no conceito de blocos de construção. Os blocos de construção são chamados de funções. Um programa em C é uma coleção de uma ou mais funções. Para escrever um programa, você primeiro cria funções e, então, coloca-as juntas.

Em C, uma função é uma sub-rotina que contém uma ou mais declarações e realiza uma ou mais tarefas. Em programas bem-escritos, cada função realiza somente uma tarefa. Cada função tem um nome e uma lista de argumentos que receberá. Em geral, pode-se dar qualquer nome a uma função, com exceção de main, que é reservada para a função que começa a execução dos programas.

Por que usar funções?

Para permitir o reaproveitamento de código já construído(por você ou por outros programadores);

Para evitar que um trecho de código que seja repetido várias vezes dentro de um mesmo programa;

Para permitir a alteração de um trecho de código de uma forma mais rápida. Com o uso de uma função é preciso alterar apenas dentro da função que se deseja;

Para que os blocos do programa não fiquem grandes demais e, por conseqüência, mais difíceis de entender;

Para facilitar a leitura do programa-fonte de uma forma mais fácil;

Para separar o programa em partes(blocos) que possam ser logicamente compreendidos de forma isolada

Uma convenção notacional tornou-se padrão quando se escreve sobre a linguagem C. Haverá parênteses depois do nome da função. Por exemplo, se o nome de uma função é max( ), ela será escrita como max( ) quando referenciada no texto.

Essa notação:

specificador_de_tipo nome_da_função (declaração de parâmetros){

// Corpo da função:

Declarações

Comandos
}Especificador de tipo: determina o tipo de valor que a função retornará usando a declaração return. Ele pode ser qualquer tipo válido. Se nenhum tipo é especificado então, por definição, a função retorna um resultado inteiro. Mas se a função não retorna nenhum tipo de valor de resposta, então deverá ser void (vazio).

Nome da função: corresponde ao nome dado a função, respeitando todas as regras de dar nomes a objetos (variáveis e constantes) na programação computacional.

Declaração de parâmetros: é uma lista de tipos de variáveis e nomes, separados por vírgula e que receberão os valores dos argumentos quando a função for chamada. Uma função pode estar sem parâmetro, caso em que a lista de parâmetros estará vazia. Contudo, mesmo se não houver parâmetros, os parênteses ainda são requeridos.

É importante entender algo sobre a lista de declaração de parâmetros de uma função. Ao contrário da declaração de variáveis, na qual muitas variáveis podem ser declaradas para serem de um tipo comum, usando-se uma lista de nomes de variáveis separados por vírgula, todos os parâmetros de uma função devem incluir tanto o tipo como o nome da variável. Isto é, a lista de declaração de parâmetros para uma função toma esta forma geral:

f (tipo nomevar1, tipo nomevar2, ..., tipo nomevarN)Exemplo:

f ( int x, int z, float y )VARIÁVEIS GLOBAIS E LOCAIS

Variáveis globais são aquelas declaradas no início de um algoritmo. Estas variáveis são visíveis (isto é, podem ser usadas) no algoritmo principal e por todos os demais subalgoritmos.

Variáveis locais são aquelas definidas dentro de um subalgoritmo e, portanto, somente visíveis (utilizáveis) dentro do mesmo. Outros subalgoritmos, ou mesmo o algoritmo principal, não podem utilizá-las.

float media(float X,float Y ) {
return (X + Y) / 2;
}No exemplo anterior, X e Y são parâmetros formais da função media.

Parâmetros reais são aqueles que substituem os parâmetros formais quando da chamada de um subalgoritmo. Por exemplo, o trecho seguinte de um algoritmo invoca a função Media com os parâmetros reais 8 e 7 e mais adiante com os parâmetros reais N1 e N2, substituindo os parâmetros formais X e Y:

Z = media( 8 , 7 );

ou ainda

printf("Informe a nota 1: ");
scanf("%d", &N1);

printf("Informe a nota 2: ");
scanf("%d", &N2);

Z = media( N1 , N2 );Assim, os parâmetros formais são úteis somente na definição (formalização) do subalgoritmo, ao passo que os parâmetros reais substituem-nos a cada chamada do subalgoritmo. Note que os parâmetros reais podem ser diferentes a cada chamada de um subalgoritmo. MECANISMOS DE PASSAGEM DE PARÂMETROS

Os parâmetros reais substituem os formais no ato da chamada de um subalgoritmo. Esta substituição é denominada passagem de parâmetros e pode se dar segundo dois mecanismos distintos: passagem por valor (ou por cópia) ou passagem por referência.

1. Passagem de Parâmetros por Valor

Na passagem de parâmetros por valor o parâmetro real é calculado e uma cópia de seu valor é fornecida ao parâmetro formal, no ato da chamada do subalgoritmo. A execução do subalgoritmo prossegue normalmente e todas as modificações feitas no parâmetro formal não afetam o parâmetro real, pois se trabalha apenas com uma cópia do mesmo.

#include<stdio.h>
#include<conio.h>

int Fs (int x, int y){

	if( x >= y ){
 x += 2;
 return x;
	}
	else{
 y += 5;
 return y;
	}

}

main(){

int n1, n2, z;
printf("\n\nInforme um valor para N1: ");
scanf("%d", &n1);

printf("\n\nInforme um valor para N2: ");
scanf("%d", &n2);

printf("\n\n-------------------------------------------------\n\n");
printf("Valores iniciais: \n");
printf("\n\tN1: %d", n1);
printf("\n\tN2: %d", n2);

z = Fs(n1, n2);

printf("\n\n-------------------------------------------------\n\n");
printf("Valores finais (apos a chamada da funcao): \n");
printf("\n\tN1: %3d", n1);
printf("\n\tN2: %3d", n2);
printf("\n\t Z: %3d", z);
getch();

}2. Passagem de Parâmetros por Referência

A passagem de parâmetros por referência é o método que copia o endereço de um parâmetro real para o parâmetro formal da função. Dentro da função, o endereço é usado para acessar o parâmetro real usado na chamada. Assim, qualquer alteração feita no parâmetro formal alterará o valor do parâmetro real.

Uma variável, passada como parâmetro, ao ser alterada dentro da função tem seu valor alterado também na função chamadora (é na verdade uma única variável usada por ambas as fuções).

Todas as alterações feitas nos parâmetros formais, dentro dos subalgoritmos, são feitas diretamente nos parâmetros reais associados.

A convenção da linguagem C é a passagem de parâmetros por valor, mas é possível conseguir na prática a chamada por referência passando um ponteiro para o parâmetro real. Para isso, basta declarar os parâmetros formais como sendo do tipo ponteiro e fazer a chamada da função com o endereço dos parâmetros reais.

#include<stdio.h>
#include<conio.h>

int Fs (int x, int y){

	if( *x >= *y ){
 *x += 2;
 return *x;
	}
	else{
 *y += 5;
 return *y;
	}

}

main(){

int n1, n2, z;
printf("\n\nInforme um valor para N1: ");
scanf("%d", &n1);

printf("\n\nInforme um valor para N2: ");
scanf("%d", &n2);
printf("\n\n-------------------------------------------------\n\n");
printf("Valores iniciais: \n");
printf("\n\tN1: %d", n1);
printf("\n\tN2: %d", n2);

z = Fs(&n1, &n2);

printf("\n\n-------------------------------------------------\n\n");
printf("Valores finais (apos a chamada da funcao): \n");
printf("\n\tN1: %3d", n1);
printf("\n\tN2: %3d", n2);
printf("\n\t Z: %3d", z);
getch();

}Argumentos e parâmetros

Argumentos são os valores usados para chamar a função e parâmetros são as variáveis, declaradas na definição da função, que recebem estes argumentos.

Observe o exemplo abaixo:

/ Argumentos e parâmetros /

#include <stdio.h>

int soma(int a, int b) / "a" e "b" são os parâmetros da função "soma" /
{

	int resultado;
	resultado = a + b;
	return(resultado);
 }

int main()
{

	printf("A soma entre 5 e 2 é %d\n",soma(5,2));

 /* No comando printf acima a função "soma" é chamada
	* com os argumentos 5 e 2 */

	return(0);
 }Os tipos dos argumentos devem ser compatíveis com os tipos dos parâmetros. Os parâmetros formais são os parâmetros propriamente ditos, enquanto que os parâmtros reais são os argumentos. PROCEDIMENTO X FUNÇÃO

Na linguagem C, procedimento corresponde a uma função sem retorno, como em algoritmo. Nesta linguagem não existe distinção entre função e procedimento, sendo ambos tratados como função, ou seja, um subprograma com lógica bem definida que pode ser acionada quantas vezes seja necessária para solucionar um problema.

O procedimento corresponde a uma função do tipo void (tipo de dado indefinido) que não possui o comando return devolvendo algum valor para a função chamadora. Desta forma se for preciso armazenar os dados coletados durante a execução da função pode -se recorrer a passagem de parâmetros por referência, uso de variáveis globais ou ainda alguns outros métodos que serão estudados mais adiante sobre esta linguagem de programação computacional.

PARÂMETROS

Parâmetros são canais pelos quais se estabelece uma comunicação bidirecional entre um subalgoritmo e o algoritmo chamador (o algoritmo principal ou outro subalgoritmo). Dados são passados pelo algoritmo chamador ao subalgoritmo, ou retornados por este ao primeiro por meio de parâmetros.

Parâmetros formais são os nomes simbólicos introduzidos no cabeçalho de subalgoritmos, usados na definição dos parâmetros do mesmo. Dentro de um subalgoritmo trabalha-se com estes nomes da mesma forma como se trabalha com variáveis locais ou globais.