Funções e Procedimentos

Função ou procedimento é um trecho de código que posso chamar várias vezes.

Seu uso traz algumas vantagens:

-O código fica mais organizado.

-O código fica mais curto (normalmente).

-O código fica com melhor Manutenibilidade (mais fácil de corrigir e manter).

-O código passa a ser mais reutilizável.

               --->|------------|

       número  --->|   Função   |----> saída

               --->|------------|

Exemplos: sqrt, pow, strlen, abs, gets, scanf, printf, ...

Procedimento é uma função que não precisa retornar nada.

                --->|--------------------|

      entradas  --->|   Procedimento     |

                --->|--------------------|

Na hora de implementar em linguagem C, lembre-se:

1) Uma função deve ser declarada fora de qualquer outra função.

2) "return" serve para encerrar a função e retornar o resultado.

Exercícios sobre função:

1) Eu quero construir um jogo que simule de maneira realista a física. Assim, terei de calcular muitas e muitas vezes a posição de uma partícula que segue a lei de Newton do movimento uniformemente acelerado:

s = s0 + v*t + 1/2*a*t²

Assim, crie uma função em C que receba s0, v, a e t, e retorne o valor de s.

#include <stdio.h>

#include <math.h>

float muv(float s0, float v, float a, float t)

{   float s = s0 + v*t + 0.5*a*pow(t,2);

    return s;

}

int main()

{ int tempo;

    for(tempo=1; tempo<10; tempo++)

    {   printf("%.1f\n", muv(0, 10, -2, tempo));

    }

return 0;

}

2) Crie uma função que aceite o valor principal, o tempo e a taxa de juros compostos e retorne o montante final após o período especificado.

montanteFinal = principal*(1+juros)^tempo

#include <stdio.h>

#include <math.h>

float jurosCompostos(float principal, float juros, float tempo)

{   float m = principal * pow(1+juros, tempo);

    return m;

}

int main()

{ printf("%.2f\n", jurosCompostos(100, 0.20, 12));

return 0;

}

 3) Crie uma função que calcule a raiz quadrada de um número (aproximada) através de "chutes":

Exemplo: Calculando a raiz quadrada de 87

Chuto 0: 0*0 = 0 (pouco)

Chuto 1: 1*1 = 1 (pouco)

Chuto 2: 2*2 = 4 (pouco)

Chuto 3: 3*3 = 9 (pouco)

Chuto 4: 4*4 = 16 (pouco)

..

Chuto 8: 8*8 = 64 (pouco)

Chuto 9: 9*9 = 81 (pouco)

Chuto 10: 10*10 = 100 (passou)

Assim, a resposta deveria ser 9

....

Melhorando a ideia:

Chuto 9.1: 9.1*9.1 = 82.8 (pouco)

Chuto 9.2: 9.2*9.2 = 84.6 (pouco)

Chuto 9.3: 9.3*9.3 = 86.5 (pouco)

Chuto 9.4: 9.4*9.4 = 88.4 (passou)

Assim, a resposta deveria ser 9.3

#include <stdio.h>

float raiz(float n)

{   float chute=0;

    int casas;

    float incremento = 100;

    for(casas=0; casas<8; casas++)

    {

        while(chute*chute <= n)

        {   chute=chute+ incremento;

        }

        chute=chute- incremento;

        incremento = incremento/10;

    }

    

    return chute;

}

int main()

{ printf("Raiz de %.6f é %.6f\n", 87.0, raiz(87.0));

return 0;

}

4) Faça um programa que calcule o número de arranjos simples de n elementos organizados em grupos de p elementos:

   An,p = n! / (n-p)!

Repare que precisará calcular um fatorial 2 vezes. Assim, elabore uma função que calcule o fatorial de um número.

n! = 1*2*3*4*5*....*(n-1)*n

3! = 1*2*3 = 6

4! = 1*2*3*4 = 24

int fatorial(int x)

{ int resposta = 1;

int i;

for(i=2; i<=x; i++)

{ resposta = resposta * i;

}

return resposta;

}

int main()

{ int n, p, a;

printf("\nEntre com o numero de elementos: ");

scanf("%d", &n);

printf("\nEntre com o tamanho dos grupos: ");

scanf("%d", &p);

//An,p = n! / (n-p)!

a = fatorial(n) / fatorial(n-p);

printf("\nHavera %d arranjos simples\n", a);

return 0;

}

5) Este exercício ilustra um método melhor de calcular raiz quadrada, o algoritmo de Newton-Raphson:

Algoritmo de Newton/Raphson:

Seja N o número do qual você quer extrair a raiz quadrada e seja CANDIDATO = N/2 (este é um bom "chute inicial".

Repetidamente, calcule o NOVO_CANDIDATO com base na fórmula:

NOVO_CANDIDATO = (CANDIDATO² + N)/(2*CANDIDATO)

Repita até que a diferença com o valor anterior seja muito pequena:

NOVO_CANDIDATO = (CANDIDATO² + N)/(2*CANDIDATO)

CANDIDATO = NOVO_CANDIDATO

#include<stdio.h>

#include<math.h>

float minhaRaizQuadrada(float N)

{   float candidato = N/2, novo, diferenca = 1;

    while(diferenca > 0.0001)

    {   novo = (candidato*candidato + N)/(2*candidato);

        diferenca = fabs(novo - candidato);

        candidato = novo;

    }

    return novo;

}

int main()

{   float N, raiz;

    printf("Entre com um numero: ");

    scanf("%f", &N);

    raiz = minhaRaizQuadrada(N);

    printf("\nA raiz quadrada de %f eh %f\n",

        N, raiz);

    return 0;

}