sábado, 9 de fevereiro de 2013

Linguagem C: Parte 5 [Funções]

►Funções e Procedimentos

     Até agora, todo os programas que escrevemos foram colocados direto na função main(). Mas no decorrer em que criamos novos programas, precisaremos reutilizar pequenos, médios, ou grandes trechos de código, sem a necessidade de escreve-los novamente. Para isso, criaremos funções com tarefas específicas pelo programa. Já tínhamos utilizado funções anteriormente (printf(), scanf(), putchar(), getchar(), entre outras). 

Ex:

/*
* O programa recebe três funções, cada uma contendo uma mensagem.
* Elas são chamadas pela função main(), exibindo seu conteúdo na ordem que forem chamadas.
* Não existe ordem certa para chamadas de funções.
* Chame na hora que precisar.
*/

#include<stdio.h>

void msg_oi();

void msg_eaee();
void msg_cambio();

main()
{
   msg_oi();
   msg_eaee();
   msg_cambio();
}

void msg_oi()
{
   printf("Oi!");
   getchar();
}


void msg_eaee()
{
   printf("Eaee!");
   getchar();
}


void msg_cambio()
{
   printf("Cambio!");
   getchar();
}

►Regras de funções

  • Uma função pode ser invocada por outra.
  • Cada função recebe apenas um único nome.
  • Uma função deve ser utilizada para, realizar determinada tarefa. Não dependendo do resto do programa.
  • Podem receber parâmetros.
  • Pode retornar, para o lugar que a invocou, um valor.
  • uma função é declarada dentro de blocos.
  • Uma função nunca deve receber " ; " no fim de sua declaração.

►Parâmetros


     Uma outra forma de enxergarmos uma função, é imaginar um processador de alimentos. Você coloca uma fruta na entrada, e recebe o suco logo depois. Partindo do ponto em que você é apenas um consumidor comum, não lhe interessa, como o processador de alimentos faz o suco. Se ele filtra, coa, faz em tal velocidade e mais milhares de processos, nada lhe interessa. O que importa é você receber seu suco, depois de colocar uma laranja no bocal do aparelho.
     Uma função é como esse processador, recebe ( por parâmetros ) o alimento e depois realiza o processo até o resultado final. 

Ex: 

#include<stdio.h>

/*
* Foi criada uma função chamada calculo.
* Ela recebe um valor por parâmetro.
* Quando chamada pela main(), recebe o valor da variável de n1.
* Ela é processada, como se fosse a " x ".
* E imprimi o valor no fim
*/

void calculo();

main()
{
   int n1 = 5;
   calculo(n1); // recebe n1 como parâmetro
}

void calculo(int x)
{
   int a = 95;
   int calc = (a + x)*2;
   printf("Cálculo = %d",calc);
}

     Eu não poderia enviar mais de um valor para calculo(), pois foi especificado, que calculo() receberia apenas UM PARÂMETRO. Se eu quisesse, poderia declarar, mais de um na função. Lembrando que uma função só recebe o número de parâmetros, que ela foi projetada para receber.

Ex:
#include<stdio.h>

// Aqui esta a mesma função, agora com 2 parâmetros

void calculo();

main()
{
   int n1 = 5;
   int n2 = 20;
   calculo(n1, n2); // recebe n1 e n2 como parâmetro
}

void calculo(int x, int y)
{
   int a = 95;
   int calc = (a + x + y)*2;
   printf("Cálculo = %d",calc);
}

►Return

     Ela permite terminar a execução de uma função e voltar ao programa que a invocou. Quando utilizada dentro de main(), termina o programa.

Ex:

#include<stdio.h>

main()
{
   int a = 5;
   int b = 5;
   return a * b; // O que vier depois de return, não executa. ;)
}

Ex2:

int calc(int a, int b)
{
   int z = a + b;
   return z;
}

►Procedimentos

     O procedimento pode ser intendido como aquele que não retorna nada. Diferente de uma função, que tem um tipo e retorna algo. Um exemplo seria a função calculo(). Ela não tem um tipo e não retorna nada. Mas, eis que na linguagem C, sempre quando não colocamos um tipo de retorno, no cabeçalho da função, automaticamente ele é substituído por int. Existem programadores que negam a existência de procedimentos em C, considerando-os como funções. Outros, defendem a diferença entre eles.
     Em linguagens como PASCAL, as funções são definidas por FUNCTION, e os procedimentos por PROCEDURE. Eu, particularmente, considero que procedimentos são funções, na linguagem C.

►Void

     É um tipo, indicando que uma função não retornará nada. Também, são passadas por parâmetros, indicando que a função não receberá nenhum parâmetro. Um exemplo de void foi o do calculo().

►Variáveis Locais

     São variáveis criadas dentro de funções. Diferentes das globais, apenas são reconhecidas dentro da função, sendo destruídos depois do término da função. Foram utilizadas variáveis locais na função calculo().

Até a próxima! ^^

► Menu da Linguagem C

sábado, 2 de fevereiro de 2013

Linguagem C: Parte 4 [Laços]

     Muitas vezes enquanto estamos programando, vamos precisar repetir determinadas instruções diversas vezes, enquanto não for estabilizada a condição correta. Para isso utilizaremos os laços while, do while e for, que auxiliados de alguns operadores, se tornam fundamentais para nossos programas. 


While

     Esse laço sempre executara a instrução enquanto uma certa condição for verdadeira. Primeiro ele avalia a condição. A instrução sendo verdadeira, a instrução é repetida novamente, sendo assim, ficara repetindo até a condição se tornar falsa. Se for falso (ZERO), ele simplesmente encerra o laço e partirá para próxima instrução.
     Aqui esta um pequeno exemplo, onde eu quero mostrar na tela todos os números menores que 9, partindo de 1.

Ex1:
#include<stdio.h>

/*
* O laço executa enquanto num for menor que 9.
* Se eu quisesse que ele chegasse a 9, precisaria colocar apenas " <= " ao invés de " < ". :)
*/
main()
{
   int num = 1; // carga inicial

   while(num<9) // condição a verificar
   {
       printf("E aeee %d\n",num);
       num++; // pós instrução
   }
}

Ex2:

#include<stdio.h>

main()
{
   int num = 2;
   while(num<90)
   {
       printf("3 * %d = %d\n",num, 3*num);
       num = num + 1;
   }
}

For

     Esse laço reúne carga inicial, condição e pós-instrução, tudo em apenas uma linha. É utilizada para executar uma determinada instrução dentro de um bloco, sendo a condição feita no inicio do corpo do laço, até o limite estipulado.
     Ele executa a carga inicial, avalia a condição, e se for falsa termina e passa para próxima instrução. No caso de ser verdadeira, a instrução (ou bloco de instruções) é executada. Depois de executada é feita a pós-instrução, onde é realizado o incremento ou o decremento dos valores. Voltando depois a verificação da condição, até se tornar falsa.

Ex:

#include<stdio.h>
main()
{
   int num;

   printf("Carregando...\n");

   for(num = 1; num <= 100; num++)
   {
       printf("...%d%%\n",num);
   }
   printf("Concluído!");
}

Poderia também adicionar um numero para interagir.

Ex2:

#include<stdio.h>
main()
{
   int num;
   int z;

   scanf("%d ",&z);
   
   printf("Carregando...\n");

   for(num = 0; num <= 100;  num++)
   {
       printf("...%d\n",num);
   }
}

do While

     A instrução do.. while diferencia-se de for e while, pois a condição é testada no fim do laço. Ele executa a condição avaliando logo em seguida. Se o resultado for positivo, volta a executar e avaliar, até o resultado ser negativo. Sendo negativo, o laço é terminado e a próxima instrução é executada.

Ex:

#include<stdio.h>
/*
* Criei aqui um humilde programa, que faz o usuário escolher uma fruta.
*/
main()
{
    char op;

    do
    {
        printf("\t\nEscolha uma fruta \n");
        printf("\tL = Limão \n");
        printf("\tB = Banana \n");
        printf("\tT = Tomate\n\n");

        scanf("%c", &op);
        fflush(stdin); // Limpa o Buffer do teclado
        switch(op)
       {
             case 'l':
             case 'L': printf("Limão!");
             break;

             case 'b':
             case 'B': printf("Banana!");
             break;

             case 't':
             case 'T': printf("Tomate!");
             break;

             default: printf("Erro");
       }
    } while (op!=  's' && op != 'S'); // Enquanto não for digitado 's' ou 'S', o programa continuara.
}

     LEMBRANDO QUE PODEMOS UTILIZAR TODOS ESSES LAÇOS DE FORMA ENCADEADA. VOU EXPLICAR MAIS TARDE!

     Também é possível criar laços infinitos, bastando colocar uma condição que seja sempre verdadeira.
Ex:

#include<stdio.h>

main()
{
    int z = 2;

    while(z>1)
   {
       printf("...%d \n",z);
       z++;
   }
}

Os Operadores unários ++ e --

     São operadores utilizados para incrementar ou decrementar as variáveis. Foram utilizados nos exemplos anteriores.

► Operador " ++ " ► Incremento de 1. Ex: a++, ++z

► Operador " -- " ► Decremento de 1. Ex: b--, --f

Diferença de ++z e z++

     Quando o operador vier antes da variável (++z), a variável é incrementada primeiro, para depois ser utilizada. No caso de ser incrementa depois (z++), ela é utilizada primeiro, para depois ser incrementada. Isto vale o mesmo para decremento. E depende é claro, se ela estiver isolada.

Até a próxima! ^^


► Menu da Linguagem C