AULA 13 - Microcontroladores - Técnico

FUNÇÕES

Uma função é uma unidade de código de programa autônoma projetada para cumprir uma tarefa particular.

Funções permitem que grandes tarefas de computação sejam quebradas em tarefas menores e permitem às pessoas trabalharem sobre o que outras já fizeram, ao invés de partir do nada.

A linguagem C em si, não possui funções pré-definidas.

Todas as funções utilizadas em C foram projetadas pelos próprios usuários e algumas mais usadas já foram incorporadas às bibliotecas de alguns compiladores.

Um exemplo de função em C é printf(), que realiza saídas dos programas sem que o usuário precise preocupar-se como isto é feito, pois alguém já fez isto e vendeu sua ideia aos outros usuários.

A principal razão da existência de funções é impedir que o programador tenha de escrever o mesmo código repetidas vezes.

As funções em C são utilizadas como funções (retornam valores; podem ser chamadas de dentro de uma expressão e não recebem parâmetros) e como subrotinas ( não retornam valores; são chamadas por um comando CALL e recebem parâmetros) das outras linguagens.

No entanto, não pode haver aninhamento de uma função dentro de outras funções.

Cada bloco de um programa em C é uma e somente uma função.

Sintaxe:

        tipo  nome_da_função(declaração de parâmetros formais)
        {     declaração de variáveis
               comandos
        }

Onde:

• tipo - tipo do valor de retorno da função. Se uma função não retornar nenhum valor deve-se usar o tipo "void", pois, por default, as funções em C/C++ retornam um inteiro. Ex: "void main(void)".
• nome_da_função - nome da função. Como qualquer identificador em C, o nome não pode ser uma palavra reservada da linguagem (a não ser no caso da função main()), pode ser composto por letras, números e o caractere de sublinhado ( também chamado underscore: "_"), mas deve iniciar com uma letra ou com o underscore.
• declaração de parâmetros formais - neste campo são declarados os parâmetros que a função recebe. Se a função não receber nenhum parâmetro, em alguns compiladores exige-se a utilização de "void", em outros, basta a omissão (quando então os parâmetros são assumidos como inteiros). Os nomes dos parâmetros devem ser separados por vírgulas. Ex: " int sqrt(x, y)".

Em alguns compiladores, a declaração das variáveis utilizadas na função deve, obrigatoriamente, preceder quaisquer comandos da função.

Deve vir logo depois do caractere de abre-chaves ("{").

Existem outros compiladores que aceitam esta declaração em qualquer linha da função, desde que precedendo a utilização das mesmas.

• comandos - Além dos comandos do corpo da função, este bloco pode conter o comando return que finaliza a execução da função e retorna o valor para a expressão que a chamou. Caso não haja "return", este será assumido quando o compilador encontrar o caractere de fecha-chaves ("}") e o valor retornado será indefinido.

Ex:

    somaum ( int  numentra)
    { int numsai;
       numsai = numentra + 1;
       return numsai;
    }  

Exercício:

Escreva a função que recebe, calcula e devolve a média de 4 valores. Solução

CHAMADA DA FUNÇÃO

Vimos até agora, como é a sintaxe da execução do corpo de uma função chamada em um expressão.

Mas qual é a sintaxe da chamada de uma função? Seja numa expressão, ou não, a sintaxe é:

       nome_da_função(argumentos);

Na chamada de função em C não se utiliza CALL.

Note que o que diferencia a chamada de uma função, da declaração da mesma é a utilização do ponto-e-vírgula (";").

Os argumentos são valores passados para a função.

Quando não houver argumentos a serem passados, deixa-se este espaço em branco.

Ex:

  somaum(5)  ;                              -> Retorna o valor 6
  maior = acha_num_maior(4,7,2,5);          -> Retorna o valor 7 para a variável maior.

Ex:

/************************************************/
// Programa que demonstra ordem de execução de
// instruções de chamada de função e da main():
/************************************************/
#include <stdio.h>
func4()
{    printf("Esta \202 a funcao func4()\n"); }
func3()
{   printf("Esta \202 a funcao func3()\n");
   func4(); }
func2()
{    printf("Esta \202 a funcao func2()\n"); }
func1()
{   printf("Esta \202 a funcao func1()\n");
   func2();
   func3(); }
main()
{   printf("Esta \202 a primeira instrucao da funcao main()\n");
   func1();
   printf("Esta \202 a ultima instrucao da funcao main()\n");
}

A ordem de execução pode ser ilustrada como:

PARÂMETROS E ARGUMENTOS

Argumento é o valor passado para uma função.

Parâmetro (Formal) é a variável que recebe valor do argumento.

Ex:

  #include <stdio.h>
  mult(int,int);  //protótipo da função mult()
  //corpo da função main():
  void main(void)
  {   int a=4, b=5;
      printf(" O valor da multiplicação de %d por %d é  %d\n", a, b, mult(a,b)); 
  }
  //corpo da função mult():
  mult(int x, int y) 
  {  int resultado;
     resultado = x * y;
     return resultado;
  }     
 

Normalmente, C utiliza passagem de parâmetros "por valor" para funções.

Isto é, os parâmetros recebem cópias dos valores dos argumentos na expressão.

Temos isto ilustrado no exemplo acima.

Quando a função mult(), recebe os argumentos a e b, na verdade apenas cópias dos valores de a e b são enviados para a função mult().

Em resumo, as variáveis a e b não tem seus valores modificados após terem sido utilizadas como argumentos de uma função.

Se deseja-se que a própria variável seja passada para a função que vai modificar seu valor utilizamos a passagem "por referência".

Neste caso, o argumento recebe o endereço de memória da variável e a função chamada modifica o conteúdo deste endereço diretamente.

Para passar valores por referência, utiliza-se os operadores "&" e "*":

&  - " o endereço de "  - endereço da variável
*   - " no endereço de" - o que está contido no endereço da variável.

Ex:

  int saida = 5;
  ...
  incrementa(&saida);
  ...
  incrementa(int *numentra)        /* numentra contém o endereço e não o valor de saida  */
 /* conteúdo do endereço numentra é do tipo int */
 {  (* numentra)++;               /* incrementa o conteúdo de numentra  */
     return;
 }                                  -> No final da função incrementa(), saida tem o valor 6

VALORES DE RETORNO

Quando o tipo de valor de retorno da função não é especificado, por default a função vai retornar um valor inteiro.

Quando a função deve retornar um tipo que não o int, é necessário declarar-se o mesmo.

Quando a função não retorna nada, no caso de compiladores C ANSI, o tipo deve ser void.

Exercício:

1) Faça o programa que lê 3 notas para cada um dos 4 alunos da turma e calcula a média das notas de cada aluno, em uma função específica.

Solução:

#include <stdio.h>
float media3(float, float, float);
main()
{   int i;
   float n1, n2, n3;
   printf("\n*** Programa das notas:\n\n");
   for(i=1;i<=4;i++)
   {   printf("\nEntre com a 1a. nota do %do. aluno: ", i);
       scanf("%f", &n1);
       printf("\nEntre com a 2a. nota do %do. aluno: ", i);
       scanf("%f", &n2);
       printf("\nEntre com a 3a. nota do %do. aluno: ", i);
       scanf("%f", &n3);
       printf("\n\nMedia do aluno: > %.2f\n\n", media3(n1, n2, n3));
   }
}
float media3(float x, float y, float z)
{  float result;
  result = (x+y+z)/3;
  return result;
}

2) Faça o programa de Análise Combinatório, que calcula combinação, permutação e arranjo, para n elementos (tomados p a p). O cálculo fatorial é realizado por uma função específica. Solução

ESCOPO DE VARIÁVEIS

Um programa em C é um conjunto de uma ou mais funções, sendo que uma destas funções é a principal (main()), que será a primeira a ser executada.

Como saber a que função pertence determinada variável, como seu valor muda de função para função e em qual(is) função(ões) ela existe?

Variáveis Locais ou Automáticas

São todas as variáveis declaradas dentro de uma função.

Como só existem enquanto a função estiver sendo executada, são criadas quando tal função é chamada e destruídas quando termina a execução desta.

Parâmetros formais são sempre variáveis locais.

Somente podem ser referenciadas pela função onde foram declaradas e seus valores se perdem entre chamadas da função.

Ex:

     void func1(void)
      {  int x;               ® O x da func1() e o x da func2() são duas variáveis diferentes, armaze-
          x = 10; }               nadas em posições de memória diferentes, com conteúdos diferentes,
      void func2(void)        apesar do mesmo nome.
      { int x;                   
        x = -199;       }   

Uma variável local deve ser declarada no início da função (antes de qualquer comando), por motivos de clareza e organização do código e porque alguns compiladores assim o exigem.

Existem compiladores, no entanto, que permitem que a declaração seja feita em qualquer ponto do corpo da função, desde que antes da utilização da variável.

Variáveis Globais

São variáveis declaradas e/ou definidas fora de qualquer função do programa.

Podem ser acessadas por qualquer função do arquivo e seus valores existem durante toda a execução do programa.

Também por motivos de clareza convenciona-se declará-las no início do programa, após os comandos do pré-processador e das declarações de protótipos de funções.

Ex:

   ...
     int conta;                /* conta é global  */
     void main(void)
     {    conta = mul(10,123);
     ...  }
    func1()
    { int temp;
      temp = conta;
    ...   }
    func2()
    {   int conta;
        conta = 10;      /* esta conta é local   */
    ...   }     

Variáveis externas

Um programa em C pode ser composto por um ou mais arquivos-fonte, compilados separadamente e posteriormente linkados, gerando um arquivo executável.

Como as várias funções do programa estarão distribuídas pelos arquivos-fonte, variáveis globais de um arquivo não serão reconhecidas por outro, a menos que estas variáveis sejam declaradas como externas.

A variável externa deve ser definida em somente um dos arquivos-fonte e em quaisquer outros arquivos deve ser referenciada mediante a declaração com a seguinte sintaxe:

    extern  tipo_var  nome_var;

onde tipo_var é o tipo da variável e nome_var, o nome desta.

Ex:

          Arquivo 1                                          Arquivo 2
          int x, y;                                                extern int x, y;
            char ch;                                               extern char ch;
            void main(void)                                        func23()
            { ...  }                                               {   x = y/10;
            func1()                                                     }
            {     x = 123;                                         func24()
            ...    }                                               {  y = 10; } 

Variáveis Estáticas

São variáveis reconhecidas e permanentes apenas dentro dos arquivos-fonte ou funções onde foram declaradas.

Uma variável estática mantém seus valores entre chamadas da função o que é muito útil quando se quer escrever funções generalizadas (sem o uso de variáveis globais) e biblioteca de funções.

A sintaxe é:

            static tipo_var  nome_var;

onde tipo_var é o tipo da variável e nome_var, o nome desta.

Ex:

            #include <stdio.h>
            int rand(void)
            {     static int semente = 1;
                  semente = (semente * 25173+ 13849)%65536;    
                  return (semente);
             }    
             void main(void)
             {    int c;
                  for(c=1; c<=5; c++)
                       printf("Número randômico: %d \n", rand());
             }

A saída deste programa será:

              Número randômico:  39022
              Número randômico:  61087
              Número randômico:  20196
              Número randômico:  45005
              Número randômico:  3882

Sem o modificador static na declaração da variável semente, a saída seria:

              Número randômico:  39022
              Número randômico:  39022
              Número randômico:  39022
              Número randômico:  39022
              Número randômico:  39022

Variáveis Registradores

Uma variável declarada com o modificador register indica ao compilador para utilizar um registrador da CPU, ao invés de alocar memória para a variável.

Variáveis armazenadas em registradores são acessadas muito mais rápido que as armazenadas em memória, o que aumenta muito a velocidade de processamento.

Se o número de variáveis designadas como register exceder o número disponível de registradores da máquina, então o excesso será tratado como variáveis automáticas.

Variáveis registradores não podem ser globais e geralmente aplicam-se aos tipos int e char.

Obs: Existem programadores que costumam colocar variáveis contadoras em registradores, para tornar o processamento o mais rápido possível.

Ex:

/************************************************/
// Este programa mostra a diferença que uma variável register 
// pode fazer na velocidade de execucao de um programa
/************************************************/
#include <stdio.h>
#include <time.h>
unsigned int i;   // variável não-register
unsigned int delay;
void main(void)
{   register unsigned int j;
   long t;
   t = time('\0');
   for(delay = 0;delay < 50000; delay++)
      for(i = 0; i< 64000; i++) ;
   printf("tempo de loop não register: %d \n", time('\0')-t);
   printf("\nDigite uma tecla para continuar...\n");
   getch( );
   t = time('\0');
   for(delay = 0; delay < 50000; delay++)
      for(j=0; j< 64000; j++) ;
   printf("tempo do loop register: %d \n", time('\0')-t);
}

Exercícios de análise

Analisar e inferir a saída dos programas abaixo.

---

(a) Valor de i ao final do programa ____

#include <stdio.h>
main()
{
 int i;
 for (i=0;i<10;i++) {
    if (i==8)
       break;
 }
 printf("Valor de i = %d\n",i);
}

---

(b) Valor de i e j ao final do programa ____

#include <stdio.h>
main()
{
 int i,j;
 for (i=0;i<10;i++) {
    j=i;
    if (j=5)
       break;
 }
 printf("Valor de i = %d j = %d\n",i,j);
}

---

(c) Valor de i ao final do programa ____

#include <stdio.h>
main()
{
 int i;
 for (i=0;i<10;i++) {
    if (i==5) {
       i=11;
       continue;
    }
 }
 printf("Valor de i = %d\n", i);
}

---

(d) Valor de i e j ao final do programa ____

#include <stdio.h>
main()
{
 int i,j=2;

 for (i=0;i<10 && j==5;i++) {
    j++;
 }
 printf("Valor de i = %d e j = %d\n",i,j);
}

---

(e) Valor de i e j ao final do programa ____

#include <stdio.h>
main()
{
 int i,j=2;

 for (i=0;i<2;i++) {
    j=i;
    do {
      j++; 
    } while(j<3);
 }
 printf("Valor de i = %d e j = %d\n",i,j);
}

---

(f) Valor de k ao final do programa ____

#include <stdio.h>
main()
{
 int i,j=2,k=1;

 for (i=0;i<2;i++) {
    j=j+2;
    if (j==4) {
       k++;
    } else {
       if (j==5) 
          k=k+100;
    }
 }
 printf("Valor de k é %d\n",k);
}

---

(g) Valor de k ao final do programa ____

#include <stdio.h>
main()
{
 int i,j=2,k=10;

 for (i=0;i>2;i++) {
    j=j+2;
    if (j==4 && j<=5) {
       k++;
    } else {
       if (j==5) 
          k=k+100;
    }
 }
 printf("Valor de k é %d\n",k);
}

---

(h) Valor de k ao final do programa ____

#include <stdio.h>
main()
{
 int i=5,j=2,k=10;

 for (i=0;i<3;i++) {
    j=0;
    while(j<2) {
        j++;
        if (j==1);
           k++;
    }
 }
 printf("Valor de k é %d\n",k);
}

---

(i) Valor de k ao final do programa ____

#include <stdio.h>
int alfa (int x)
{
 if (x<=3)
    return -1;
 else
    return 0;
}

main()
{
 int i,k=1;

 for (i=0;i<3;i++) {
     if (alfa(i)==-1)
         k++;
 }
 printf("Valor de k é %d\n",k);
}

---

(j) Valor de k ao final do programa ____

#include <stdio.h>
int alfa (int x)
{
 if (x==0 || x==2)
    return -1;
 else
    return 0;
}

main()
{
 int i,k=1;

 for (i=0;i<3;i++) {
     if (alfa(i)==-1)
         k++;
 }
 printf("Valor de k é %d\n",k);
}

---

(k) Valor de k ao final do programa ____

#include <stdio.h>
int beta (int x)
{
 if (x==1)
    return 1;
 else
    return 0;
}

int alfa (int x)
{
 if (x==0 || x==2)
    return -1;
 else
    return 0;
}

main()
{
 int i,k=1;

 for (i=0;i<3;i++) {
     if (alfa(i)==-1 && beta(i))
         k++;
 }
 printf("Valor de k é %d\n",k);
}

---

(l) Valor de delta ao final do programa ____

#include <stdio.h>
int delta=10;
int beta (int x)
{
 delta++;
 if (x==1)
    return 1;
 else
    return 0;
}
int alfa (int x)
{
 if (x==0 || x==2)
    return -1;
 else
    return 0;
}
main()
{
 int i,k=1;

 for (i=0;i<3;i++) {
     if (alfa(i)==-1 && beta(i))
         k++;
 }
 printf("Valor de delta é %d\n",delta);
}

---

(m) Valor de soma ao final do programa ____

#include <stdio.h>
int alfa (int x, int y, int w)
{
if (x==(y+1)) {
    w--;
    return x*w; 
 } else {
    x++;
    return x*y;
 }
}
main()
{
  int i,soma=0;
  for (i=0;i<2;i++) {
     soma = soma + alfa(i,i+1,i+2);
 }
 printf("Valor de soma é %d\n",soma);
}

---

(n) Valor de delta ao final do programa ____

1. include <stdio.h>

main()
{
 int i,j,k,soma=0, delta=0;

 j=0;
 for (i=0;i<2;i++) {
    for (;j<2;j++) {
       soma = soma + 1;
       delta = delta + soma * 2;
    }
 }
 printf("Valor de delta é %d\n",delta);
}

---

(o) Valor de delta ao final do programa ____

#include <stdio.h>
main()
{
  int alfa,beta,gama,delta=0;
 alfa = 11;
 beta = 5;
 gama = 1;
 delta = (alfa%2) + (gama>beta) + (beta==5);
 printf("Valor de delta é %d\n",delta);
}

---

(p) Valor de delta ao final do programa ____

#include <stdio.h>
main()
{
 int alfa,beta,gama,delta=0;

 alfa = 11;
 beta = 5;
 gama = 1;
 delta = (alfa%2) + (beta=5) + (gama>beta);
 printf("Valor de delta é %d\n",delta);
}

---

(q) O valor de delta ao final do programa ____

#include <stdio.h>
int delta=1;
int alfa (int x)
{
 delta=5*x;
 return delta;
}
main()
{
 int i=1;
 if (i==1 || alfa(i)==5)
      delta++;
 printf("Valor de delta é %d\n",delta);
}

---

(r) O valor de k ao final do programa ____

#include <stdio.h>
main()
{
 int i=5,j=2,k=10;
 for (i=0;i<3;i++) {
    j=0;
    while(j<2) 
        j++;
        if (j==1)
           k++;
  }
 printf("Valor de k é %d\n",k);
}

---

<< Página do curso

<< Aula 12 - Instruções DO-WHILE, FOR e SWITCH	AULA 13 - Microcontroladores	Aula 14 - Matrizes >>