Introdução ao uso de funções em C: variáveis locais, globais e aninhamento de funções

Sobre o aninhamento de funções na linguagem C

Nesta seção apresento um conceito mais "sutil" de programação, para entendê-lo é essencial que você copie os códigos apresentados, "cole" em seu editor preferido e os teste até que esteja tudo claro. Experimente alterar os exemplos e criar outros: grave-os, compile-os e os rode. Para prender programação é preciso programar!

Em várias linguagens de programação, C em particular, é possível declarar função dentro de função (aninhar). Por exemplo, dentro de uma função de nome funcao2, pode-se declarar outra função de nome funcao3. O resultado é que, dentro da primeira função, pode-se invocar a segunda, mas em nenhum outro local do código seria possível invocar esssa função funcao3.

Mas vale destacar que esse recurso só é efetivamente útil se a função interna (funcao3) só fizer sentido dentro da função que a contém. Pois em caso contrário, você poderia invocar a função interna em outros contextos. Um exemplo dessa situação é ilustrado no parágrafo seguinte, a função fatorial poderia ficar melhor se declarada fora da função combinacao.

Um exemplo simples de função contendo outra função, poderia ser o caso do cálculo da combinação de n, tomados k-a-k: Cn,k = n!/(k!(n-k)!). Como para o calculo de Cn,k é necessário invocar o cálculo do fatorial 3 vezes, podemos desejar fazer um implementação que deixe essa dependência clara, definindo uma função de nome combinacao e, dentro dela, declarar a função fatorial. Vide exemplo 1.

Porém, como anteriormente comentado, como a função fatorial tem potencial de aplicação mais amplo, ela ficaria melhor se declarada fora da função combinacao (vide a crítica a esse organização de código logo após o exemplo 1).

Exemplo 1. Declaração aninhada de funções.

    <verm>int</verm> combinacao (<verm>int</verm> n, <verm>int</verm> k) { <cyan>// combinacao de n, k-a-k</cyan>
      <verm>int</verm> fatorial (<verm>int</verm> n) { <cyan>// fatorial de n (supondo n natural)</cyan>
        <verm>int</verm> i, fat = 1;
        for (i=2; i≶=n; i++)
          fat *= i;
        return fat;
        }
      return fatorial(n) / (fatorial(k)*fatorial(n-k));
      }

    <verm>void</verm> main (<verm>void</verm>) :
      <verm>int</verm> n = 5, k = 3;
      <verd>printf</verd>("Combinacao %d, %d-a-%d = %d\n", n, k, k, combinacao(n,k));
      <cyan>// Problema de declarar 'fatorial()' dentro de 'combinacao()': a linha abaixo daria erro!</cyan>
      <cyan>// Erro: exemplo_funcao_aninhada.c:(.text+0xd3): undefined reference to fatorial'</cyan>
      <cyan>// <verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));</cyan>
      }

Note que o código acima apresenta a linha comentada `<verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));`. A razão é que ela resultaria erro, pois a função fatorial foi declarada dentro da função combinacao e portanto só pode ser usando (invocada) dentro dessa segunda!

Uma vez que o uso do cálculo de fatorial é muito comum e pensando que o código acima seria parte de um maior, então provavelmente o desenho de código usado não é bom, pois implicaria em precisarmos definir outra função fatorial, essa fora do contexto da função combinacao. Nesse sentido, poderia ser melhor usar o código (pensando que ele seja o início de um sistema maior) do exemplo a seguir.

Exemplo 2. Declaração de funções sem aninhamento.

    <verm>int</verm> fatorial (<verm>int</verm> n) { <cyan>// fatorial de n (supondo n natural)</cyan>
      <verm>int</verm> i, fat = 1;
      for (i=2; i≶=n; i++)
        fat *= i;
      return fat;
      }

    <verm>int</verm> combinacao (<verm>int</verm> n, <verm>int</verm> k) { <cyan>// combinacao de n, k-a-k</cyan>
      return fatorial(n) / (fatorial(k)*fatorial(n-k));
      }

    <verm>void</verm> main (<verm>void</verm>) :
      <verm>int</verm> n = 5, k = 3;
      <verd>printf</verd>("Combinacao %d, %d-a-%d = %d\n", n, k, k, combinacao(n,k));
      <cyan>// Note que agora pode-se invocar 'fatorial()' dentro da 'main'</cyan>
      <verd>printf</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d", fatorial(0), fatorial(1), fatorial(2), fatorial(3));
      }

Variáveis globais e locais

Outro conceito importante relacionado com funções é o de declaração de variáveis. Assim, uma variável é local se declarada dentro de uma função qualquer, quer dizer, essa variável será "conhecida" (poderá ser usada) apenas dentro dessa função. Por exemplo, no exemplo 2 acima, a variável fat é conhecida apenas dentro da função fatorial, portanto seu uso deve-se restringir a esse contexto.

Por outro lado, pode-se usar o mesmo nome para variáveis que estão em contextos distintos. Por exemplo, no código do exemplo 1, se fosse necessário poderíamos usar o nome de variável local i dentro da função combinacao e não haveria qualquer colisão com a variável i de fatorial.

Entretanto é necessário um critério que elimine ambiguidades, isto é, que permita identificar unicamente cada uma das variáries. Para isso usa-se o princípio da proximidade (ou da localidade), quer dizer, ao usar uma variável considera-se como sua declarção aquela mais próxima. Por isso, que poderiamos usar i tanto em combinacao, quanto em fatorial,

Fig. 1. Imagem de código ilustrando o princípio da localidade, variável `var1` dentro de `funcao2` é a declarada localmente.

Já uma variável global pode ser acessada em qualquer ponto do código. Mas por essa mesma razão deve evitada, sendo necessária apenas para casos excepcionais, sempre com um nome significativo, que evite qualquer confusão.

Em C, toda variável declarar fora do contexto de qualquer função, é uma variável global, ou seja, uma variável que pode ser acessada em qualquer ponto do código (em qualquer função). A ideia de variável global é ilustrado no próximo exemplo.

Exemplo 3. Declaração de variável global.

    <verm>char</verm> var_global1[] = "essa variavel e' uma variavel global";

    <verm>int</verm> funcao () {
      <verd>printf</verd>("funcao1: var_global1 = %s\n", var_global1);
      }

    <verm>void</verm> main (void) {
      <verd>printf</verd>("main   : var_global1 = %s\n", var_global1); <cyan>// uso da global</cyan>
      funcao();
      }

Aninhando funções e variáveis locais e globais

Deve-se notar que é possível aninhar tantas funções quantas forem necessárias e o mesmo para variáveis locais. O exemplo abaixo ilustra esses aninhamentos e o princípio da proximidade. Examine-o com atenção, copie-o em seu computador, utilizando um compilador C e altere seu código, compile-o e rode-o até que esteja certo de ter assimilado os conceitos.

Exemplo 4. Declaração de variáveis locais, usando globais e aninhamento de funções.

    #include <stdio.h>

    <verm>char</verm> glob1[] = "glob1: variavel global, conhecida em qualquer local";

    <verm>void</verm> funcao1 () {
      <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao1'";
      <verm>char</verm> glob1[] = "funcao1.glob1: declarada dentro de 'funcao1' => uma variavel local `a funcao 'funcao1'";
      <verd>printf</verd>("funcao1: loc1 = %s\n", loc1); <cyan>// note que: pode haver m</cyan>
      <verd>printf</verd>("funcao1: glob1 = %s\n\n", glob1);
      }

    <verm>void</verm> funcao2 (param1) {
      <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao2 - NAO sou a 'funcao1.loc1'!'";
      <verm>char</verm> loc2[] = "loc2: conhecida apenas dentro da funcao 'funcao2'";
      <verm>void</verm> funcao3 () { <cyan>// essa funcao so' e' conhecida dentro de 'funcao2'!</cyan>
        <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'funcao3' - NAO sou a 'funcao1.loc1' e nem a 'funcao2.loc1'!";
        <verm>char</verm> glob1[] = "funcao3.glob1: declarada dentro de 'funcao3' => var. local `a funcao 'funcao3' - NAO e' global 'glob1' e nem 'funcao1.glob1'!";</cyan>
        <verd>printf</verd>("funcao3: loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
        <verd>printf</verd>("funcao3: loc2 = %s\n", loc2); <cyan>// note que: e' local `a funcao 'funcao2' - variavel declarada fora de funcao3!</cyan>
        <verd>printf</verd>("funcao3: glob1 = %s\n", glob1);
        }
      <verd>printf</verd>("funcao2: param1 = %s\n", param1);
      <verd>printf</verd>("funcao2: loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
      <verd>printf</verd>("funcao2: loc2 = %s\n", loc2); <cyan>// note que: e' local</cyan>
      <verd>printf</verd>("funcao2: glob1 = %s\n", glob1);
      <verd>printf</verd>("funcao2: chama funcao3\n\n");
      funcao3();
      <verd>printf</verd>("funcao2: chama funcao1\n\n");
      funcao1();
      }

    <verm>void</verm> main () {
      <verm>char</verm> loc1[] = "loc1: conhecida apenas dentro da funcao 'main'";
      <verd>printf</verd>("main   : loc1 = %s\n", loc1); <cyan>// note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>

      <verd>printf</verd>("main   : glob1 = %s\n", glob1);

      <verd>printf</verd>("main   : chama funcao1\n\n");
      funcao1();
      <verd>printf</verd>("main   : chama funcao2\n\n");
      funcao2("parametro efetivo passado para a funcao 'funcao2'");

      <cyan>// Atencao: como a funcao 'funcao3' foi declarada dentro da funcao 'funcao2', entao ela so' pode se invocada em 'funcao2'</cyan>
      <cyan>// Por exemplo, a linha abaixo resultaria no erro: sobre_variaveis_global_local.c:(.text+0x4d2): undefined reference to funcao3'</cyan>
      <cyan>// funcao3();</cyan>
      }

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2020/08/15: novo formato, pequenas revisões
2020/08/09: formato, revisão geral;
2018/05/22: pequenas alterações
2018/05/21: pequenas alterações