Linguagem C Básico Aula 12: Funções e Bibliotecas

Relembrando

    No curso de algoritmos vimos que Funções e Procedimentos são blocos de instruções que são executados ao serem chamados. Essas estruturas são chamadas através dos seus nomes, seguidos de um abre e fecha parenteses. 

    Dentro desses parênteses podem ou não existir parâmetros para a execução das instruções. A diferença entre Procedimentos e Funções é que o segundo retorna algum dado para a instrução que o chamou. 

    A vantagem do uso de Procedimentos e Funções é que eles deixam o código mais organizado, mais legível e permitem a reutilização do código. Vimos também que existem funções criadas pelo usuário e funções nativas. Também vimos que as funções nativas ficam armazenadas em bibliotecas padrão. Relembrou?

Nomenclaturas em termos práticos

    Essas diferentes nomenclaturas para as sub-rotinas classificando as de Procedimentos ou Funções é algo meramente acadêmico que desaparece no dia a dia. Na prática acabamos por chamar genericamente todas as sub-rotinas como funções de forma indistinta.

    Alguns estudantes chamam erroneamente as funções de métodos, mas veremos futuramente que esse termo deve ser usado na codificação do paradigma de programação orientada a objetos. Lembrando que a linguagem C não é orientada a objetos.

    No início do seu curso de C eu disse que ao carregar arquivos de cabeçalho no seu programa, você traz para o programa recursos, está lembrado? Por exemplo, você escreve #include <stdio.h> para fazer uso do printf() no programa.  O printf() é um exemplo de função que vem no arquivo de cabeçalho.

    Por isso que no dia a dia usamos o termo "incluir a biblioteca" ou "carregar a biblioteca" quando incluímos um arquivo de cabeçalho. 

    Em Sistemas Embarcados o uso de sensores e dispositivos na maioria da vezes exige a inclusão de uma ou mais bibliotecas na forma de arquivos de cabeçalho contendo definições e funcionalidades para que esses sensores e dispositivos possam funcionar.

Funções no C

    Como já vimos, os programas em C começam com uma função principal chamada main(), cujo conteúdo são as instruções contidas entre o abre e fecha chaves {} que pode ou não retornar ao sistema operacional uma informação. 

    Já uma função criada pelo usuário terá uma estrutura semelhante, isto é, com nome(){}, mas deverá ser criada fora e antes da função main(), para que o programa a conheça antes do main() chamá-la. Vejamos um exemplo onde o main() chama uma função que mostra uma mensagem da tela:

1. #include <stdio.h>
2. void mensagem(){
3.     printf("\n*************************\n");
4.     printf("Esta é a minha mensagem");
5.     printf("\n*************************\n");
6. }
7. int main()
8. {
9.     mensagem();
10.     return 0;
11. }

    Neste exemplo entre as linhas 2 e 6 eu estou criando uma função chamada "mensagem". Ela não retorna nenhuma informação para a rotina que a chamou, por isso ela começa com a instrução void. 

    Entre o abre e fecha chaves {} nós temos as instruções que ela executa, que no caso são saídas na tela formando um quadro com mensagem. Logo abaixo temos a função main() com a chamada da função na linha 9.

Funções com parâmetros

    Como já visto no curso de algoritmos, eu posso passar um ou mais parâmetros para a função dentro dos seus parenteses. Nesse caso cada parâmetro deverá ser declarado com seu tipo de dados. Digamos que eu quero que a função mensagem() que criamos no tópico anterior recebe como parâmetro uma string que será o texto mostrado na mensagem.

1. #include <stdio.h>
2. void mensagem(char texto[]){
3.     printf("\n*************************\n");
4.     printf("%s",texto);
5.     printf("\n*************************\n");
6. }
7. int main()
8. {
9.     mensagem("Olá mundo!");
10.     mensagem("Eu já sei");
11.     mensagem("criar função!");
12.     return 0;
13. }

    Neste caso eu estou criando a função mensagem com a possibilidade de receber uma string como parâmetro. Já no main() estou chamando a função mensagem() passando as parâmetros para ela, com isso eu posso reutilizar a função em várias situações como nas linhas 9, 10 e 11.

Funções com retorno

    Tecnicamente o que vimos até agora foi a criação de procedimentos, pois as funções de exemplo não retornavam nada para a rotina que a chamou. Agora veremos um função propriamente dita que retorna algo para a função main().

    Nesse caso ela não poderá ser criada com o void e no seu lugar escreveremos o tipo de dado que ela retorna. Na sua linha final, antes do fecha chaves } deverá constar um return e o valor que ela retorna. 

    Por exemplo, digamos que eu queira fazer uma função matemática chamada quadrado() que pega como parâmetro um número inteiro e retorna para a main() o quadrado desse número:

1. #include <stdio.h>
2. int quadrado(int numero){
3.     return numero*numero;
4. }
5. int main(){
6.     printf("O quadrado de 5 é %d",quadrado(5));
7.     return 0;
8. }

    Repare que nesse exemplo eu comecei a função com int porque ela retornará um valor int. Ela está também pegando um número inteiro como parâmetro. Quando main() chama quadrado(5) ele está passando o 5 como parâmetro para a função quadrado que está retornando o 5*5.

Criando sua própria biblioteca

    Você pode criar um arquivo de cabeçalho e armazenar nele todas as suas funções criadas pelo usuário bastando usar a instrução include no arquivo main.c informando o nome desse arquivo de cabeçalho. No caso do GDB online o arquivo que você está usando já é o main.c.

    Para criar um arquivo chamado bibliotec.h no GDB online basta pressionar CTRL+M ou clicar no botão New File no canto superior esquerdo da tela. Digita-se o nome do arquivo e depois coloca-se o código.

Processo de criação de arquivo de cabeçalho no GDB Online

    Digamos que vou usar o exemplo das funções com parâmetros para criação da nossa biblioteca. Na janela do arquivo biblioteca.h colocaríamos o seguinte código:

1. #include <stdio.h>
2. void mensagem(char texto[]){
3.     printf("\n*************************\n");
4.     printf("%s",texto);
5.     printf("\n*************************\n");
6. }

    Já no arquivo main.c deixaríamos apenas esse código:

1. #include "biblioteca.h"
2. int main()
3. {
4. mensagem("Ola mundo!");
5. mensagem("Eu já sei");
6. mensagem("criar funcão!");
7. return 0;
8. }

Janela do GDB Online com dois arquivos destacados em vermelho

    É claro que isso só é interessante quando o arquivo de biblioteca possui várias funções. Repare também que o include do arquivo main.c refere-se a biblioteca entre "aspas" e não com <>.

   

Próxima Aula                                                                                                                        Aula Anterior

Referências

DAMAS, L. Linguagem C. Rio de Janeiro: LTC Editora, 2007.

GBD ONLINE. C for Beginners. Disponível em: <https://learn.onlinegdb.com/c_for_beginners> Acesso em 05 ago. 2024.

GBD ONLINE. C Programming Examples Disponível em: <https://learn.onlinegdb.com/c_program_examples> Acesso em 05 ago. 2024.

W3SCHOOLS. C Tutorial. Disponível em: <https://www.w3schools.com/c/index.php> Acesso em 05 ago. 2024.