Funções

As funções são ferramentas úteis para qualquer programador, eles servem para resumir
partes de código que são repetidas rotineiramente no código fonte.

Exemplo:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void main( )
{
int variavel = 0;

while( variavel < 100 )

{
system( "cls" );
printf( "%d", variavel );
getch( );
}
}

Usando funções podemos resumir algumas linhas de código

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void minha_funcao ( )
{
system( "cls" );
printf( "%d", variavel );
getch( );
}

void main( )
{
int variavel = 0;

while( variavel < 100 )

{
minha_funcao( );
}
}

Uma função é formada pelos seguintes componentes:

O tipo da variável que será retornada tem implicação direta na função, Exemplo:
void RetornaNada ( )
{
int a = 1;
int b = 2;
int resposta;
resposta = a+b;
printf("%d",resposta); //NÃO RETORNA NADA,
//MAS NÃO IMPEDE QUE
//ALGO SEJA IMPRESSO NA TELA
}
int RetornaInteiro ( )
{
int a = 1;
int b = 2;
int resposta;
resposta = a+b;
return resposta; //RESPOSTA DEVE SER DO TIPO INTEIRO
}

char RetornaCaracter( )
{
return 'c'; //RESPOSTA DEVE SER DO TIPO CHAR
}

A assinatura de uma função, simboliza toda a função exceto pela sua implementação ou
seja, das 3 expressões acima, temos as seguintes assinaturas respectivamente:

void RetornaNada ( );
int RetornaInteiro ( );
char RetoranCaracter ( );

obs.: Na assinatura temos o ‘;’ sempre presente!

Com as assinaturas temos uma breve idéia do que a função recebe de parâmetro e
retorna após sua execução.

A passagem de parâmetros para uma função simboliza a entrada de variáveis para

dentro da função, serve para que variáveis não declaradas em seu interior possam ser
usadas e manipuladas.

void RetornaNada ( int c, int d )

{
int resposta;
resposta = c+d;
printf("%d",resposta);
}

void main ( )
{
int a, b;
a = 10;
RetornaNada ( a , 50 ); //imprime 60
RetornaNada ( 10, 5 ); //imprime 15
RetornaNada ( -10 , a );//imprime 0
RetornaNada ( a , a ); //imprime 20
}

Note que até o momento para todos os exemplos as funções foram colocadas antes da
função MAIN, isso se deve pelo simples fato de quando o compilador estiver
compilando o código ele já deve ter idéia de todas as funções que o MAIN chama, uma
forma de contornar isso é inserir a assinatura das funções antes do MAIN e deixar a
função contendo seu código fonte depois do MAIN, como segue o exemplo:

void RetornaNada ( int c, int d );

void main ( )
{
int a, b;
a = 10;
RetornaNada ( a , 50 ); //imprime 60
RetornaNada ( 10, 5 ); //imprime 15
RetornaNada ( -10 , a );//imprime 0
RetornaNada ( a , a ); //imprime 20
}

void RetornaNada ( int c, int d )

{
int resposta;
resposta = c+d;
printf("%d",resposta);
}
Bibliotecas

Para as bibliotecas temos os mesmos conceitos das funções anteriormente brevemente

comentadas.
As bibliotecas nos permitem isolar as funções que por ventura não façam parte do
algoritmo de maior interesse, esse último normalmente colocado junto ao arquivo onde
encontra-se a função MAIN.
É através das bibliotecas que temos acesso a funções sem ter de implementa-las, uma
vez que essas estejam implementadas dentro da biblioteca.
Por exemplo sito a função printf a qual é de uso comum e rotineiro a todos os
desenvolvedores C/C++, porém não é de conhecimento geral como essa função fora
implementada, isso se deve porque sua implementação encontra-se dentro de uma
biblioteca utilizada stdio que é responsável por funções padrões de entrada e saída, daí
seu nome STANDARD INPUT OUTPUT.

Basicamente as bibliotecas consistem de 1 ou 2 arquivos, ambos de mesmo nome,

porém tipos de arquivos distintos. O principal deles, dito arquivo HEADER (.h) é
responsável por incluir a assinatura de todas as funções que posteriormente serão
implementadas no segundo arquivo denominado arquivo C (.c).

O arquivo C é responsável por implementar todas as funções declaradas do arquivo

Header, qualquer variável global declarada pela biblioteca deverá ser declarada no
arquivo Header.

Para chamar a biblioteca em qualquer arquivo C, seja ele o arquivo C principal do

programa basta utilizar a palavra reservada da linguagem include.

Exemplo:

//arquivo main.c
#include <stdio.h>
#include "my_lib.h"

void main ( )
{
RetornaNada( 1 , 2 );
}

//arquivo my_lib.h
#include <stdio.h>

void RetornaNada ( int c, int d );

//arquivo my_lib.c
#include “my_lib.h”

void RetornaNada ( int c, int d )

{
int resposta;
resposta = c+d;
 printf("%d",resposta);
}

Com esse exemplo pode ser visualizado algumas particularidades, como por exemplo a
inclusão do arquivo “my_lib.h” pelo arquivo “my_lib.c”, isso se deve para que haja um
link (ligação) entre os arquivos da biblioteca, já o arquivo “um_lib.h” não tem essa
responsabilidade de linkar qualquer outro arquivo, porém ele fica responsável por
incluir qualquer biblioteca que ambos os arquivos, “my_lib.h” e “my_lib.c” possa vir a
utilizar, como por exemplo o arquivo “my_lib.c” faz uma chamada a função printf
declarada da biblioteca “stdio.h” por isso de sua inclusão no arquivo “my_lib.h”.
Outra particularidade é a presença das aspas duplas (“) ao invés dos sinais de maior e
menor (< , >), isso se deve pela localização dos arquivos “my_lib.h” e “my_lib.c”,
quando esses se encontram na mesma pasta do arquivo que o inclui, ele deve chama-lo
utilizando (“), caso o arquivo se encontre na mesma pasta do compilador, como é o caso
das bibliotecas ANSI, stdio.h , stdlib.h e outras não mantidas pelo padrão porém muito
utilizadas como a biblioteca conio.h devem ser incluídas utilizando (< e >). Isso serve
tão e somente para que o compilador possa encontrar os arquivos para a compilação.