Programar em C
185 pág.

Programar em C


DisciplinaLinguagem de Programação Estruturada128 materiais1.055 seguidores
Pré-visualização40 páginas
printf("\nO fatorial de %d e' %d", n, fat(n));
 system ("pause");
 return 0;
}
Exemplo 2 :
#include <stdio.h>
#include <stdlib.h>
Funções 60
unsigned long fib(unsigned int n)
{
 if (n == 0 || n == 1)
 return n;
 else
 return fib(n - 1) + fib(n - 2); 
}
int main()
{
int n;
 
 printf(&quot;\n\nDigite um valor para n: &quot;);
 scanf(&quot;%d&quot;, &n);
 printf(&quot;\n F(%d) = %d \n &quot;,n, fib(n));
 system (&quot;pause&quot;);
 
 return 0;
 
} 
Vamos introduzir o valor 5 para este programa.
São feitas as seguintes chamadas recursivas . Observe a estrutura upside-down (árvore de cabeça para baixo) criada
pelas chamadas recursivas.
Fibonacci(5)
 / \
 / \
 / \
 / \
 / \
 F(4) + F(3)
 / \ / \
 / \ / \
 / \ / \
 / \ / \
 / \ / \
 F(3) + F(2) F(2) + F(1)
 /\ /\ | \ \
 / \ / \ | \ \
 / \ / \ | \ \
 / \ / \ | \ \
 F(2) + F(1) F(1) + F(0) F(1) + F(0) 1
 /\ | | | | |
 / \ | | | | |
 / \ | | | | |
 / \ | | | | |
Funções 61
 F(1) + F(0) 1 1 0 1 0
 | |
 | |
 | |
 | |
 1 0
Cada vez que a sub-rotina chama a si mesmo, ela deve armazenar o estado actual da sub-rotina (linha atual que está
sendo executada, os valores de todas as variáveis , etc) em uma estrutura de dados chamada de &quot;pilha&quot;.
Se você usar a recursividade durante um longo período de tempo, a pilha vai ficar muito grande e o programa dará
uma mensagem de aviso .
inline
Uma função inline, em vez de ser chamada, será movida para o local de chamada no momento da compilação.
Se fizermos um paralelismo com as directivas de compilação, como #define, ela vai substituir cada chamada da
função pela própria função, é como fosse uma macro.
Mas isto só tem vantagens para códigos pequenos e para quem necessite muito da velocidade no processamento.
Alguns compiladores já fazem isto automaticamente.
Para tornar uma função inline basta preceder a declaração da função com o nome inline.
inline [tipo_de_retorno] [nome_da_função] (argumentos)
{
 //código 
}
Pré-processador 62
Pré-processador
O pré-processador
O pré-processador C é um programa que examina o programa fonte escrito em C e executa certas modificações nele,
baseado nas diretivas de compilação (ou diretivas do pré-processador). As diretivas de compilação são comandos
que não são compilados, sendo dirigidos ao pré-processador, executado pelo compilador antes da execução do
processo de compilação propriamente dito.
Portanto, o pré-processador modifica o programa fonte, que ainda não estaria pronto para ser entregue ao
compilador. Todas as directivas de compilação são iniciadas pelo caractere # (sharp). As diretivas podem ser
colocadas em qualquer parte do programa, mas não podem ser colocadas na mesma linha que outra diretiva ou
instrução.
As principais diretivas de compilação são:
\u2022\u2022 #include
\u2022\u2022 #define
\u2022\u2022 #undef
\u2022\u2022 #ifdef
\u2022\u2022 #ifndef
\u2022\u2022 #if
\u2022\u2022 #else
\u2022\u2022 #elif
\u2022\u2022 #endif
Diretivas de compilação
#include
A diretiva #include diz ao pré-processador para incluir naquele ponto um arquivo especificado. Sua sintaxe é:
#include &quot;nome_do_arquivo&quot;
ou
#include <nome_do_arquivo>
A diferença entre se usar &quot;&quot; e <> é somente a ordem de procura nos directórios pelo arquivo especificado. Se você
quiser informar o nome do arquivo com o caminho completo, ou se o arquivo estiver no directório de trabalho, use
&quot;arquivo&quot;. Se o arquivo estiver nos caminhos de procura pré-especificados do compilador, isto é, se ele for um
arquivo do próprio sistema (como é o caso de arquivos como stdio.h, string.h, etc...), use <arquivo>.
#define
A diretiva #define tem duas utilidades. Uma delas é apenas definir um símbolo que pode ser testado mais tarde.
Outra é definir uma constante ou ainda uma macro com parâmetros. As três maneiras de usar a diretiva são:
#define nome_do_símbolo
#define nome_da_constante valor_da_constante
#define nome_da_macro(parâmetros) expressão_de_substituição
\u2022 Toda vez que o pré-processador encontrar nome_da_constante no código a ser compilado, ele deve substituí-lo
por valor_da_constante.
Pré-processador 63
\u2022 Toda vez que o pré-processador encontrar nome_da_macro(parâmetros), ele deve substituir por
expressão_de_substituição, também substituindo os parâmetros encontrados na expressão de substituição;
funciona mais ou menos como uma função. Veja o exemplo para entender melhor.
Exemplo 1:
#include <stdio.h>
#define PI 3.1416
#define VERSAO &quot;2.02&quot;
int main ()
{
 printf (&quot;Programa versão %s\n&quot;, VERSAO);
 printf (&quot;O numero pi vale: %f\n&quot;, PI);
 return 0;
}
Exemplo 2:
#define max(A, B) ((A > B) ? (A) : (B))
#define min(A, B) ((A < B) ? (A) : (B))
...
x = max(i, j);
y = min(t, r);
Aqui, a linha de código: x = max(i, j); será substituída pela linha: x = ((i) > (j) ? (i) : (j));.
Ou seja, atribuiremos a x o maior valor entre i ou j.
Quando você utiliza a diretiva #define, nunca deve haver espaços em branco no identificador (o nome da macro).
Por exemplo, a macro #define PRINT (i) printf(&quot; %d \n&quot;, i) não funcionará correctamente porque
existe um espaço em branco entre PRINT e (i).
#undef
A diretiva #undef tem a seguinte forma geral:
#undef nome_da_macro
Ela faz com que a macro que a segue seja apagada da tabela interna que guarda as macros. O compilador passa a
partir deste ponto a não conhecer mais esta macro.
#ifdef e #ifndef
O pré-processador também tem estruturas condicionais. No entanto, como as diretivas são processadas antes de tudo,
só podemos usar como condições expressões que envolvam constantes e símbolos do pré-processador. A estrutura
ifdef é a mais simples delas:
#ifdef nome_do_símbolo
 código
 ...
#endif
Pré-processador 64
O código entre as duas diretivas só será compilado se o símbolo (ou constante) nome_do_símbolo já tiver sido
definido. Há também a estrutura ifndef, que executa o código se o símbolo não tiver sido definido.
Lembre que o símbolo deve ter sido definido através da diretiva #define.
#if
A diretiva #if tem a seguinte forma geral:
#if expressão
 código
 ...
#endif 
A sequência de declarações será compilada apenas se a expressão fornecida for verdadeira. É muito importande
ressaltar que a expressão fornecida não pode conter nenhuma variável, apenas valores constantes e símbolos do
pré-processador.
#else
A diretiva #else funciona como na estrutura de bloco if (condição) {...} else {...}:
#if expressão /* ou #ifndef expressão */
 código /* será executado se a expressão for verdadeira */
#else
 código /* será executado se a expressão for falsa */
#endif 
Um exemplo:
#define WINDOWS
...
/* código */
...
#ifdef WINDOWS
#define CABECALHO &quot;windows_io.h&quot;
#else
#define CABECALHO &quot;unix_io.h&quot;
#endif
#include CABECALHO
#elif
A diretiva #elif serve para implementar uma estrutura do tipo if (condição) {...} else if
(condição) {...}. Sua forma geral é:
#if expressão_1 
 código