MACROS
Uso de diretivas de compilação
As diretivas são instruções especiais usadas, geralmente, nas primeiras linhas do seu código fonte. Elas servem para modificar o texto fonte do programa que se esta elaborando, antes mesmo de sua compilação. Portanto, são comandos que não estarão presentes no programa executável, apenas no código fonte.
Essas diretivas são identificadas pelo caracter sustenido (#), por exemplo a diretiva #include, que você certamente já utilizou em programação, não expressa um comando do programa, mas é responsável pela inclusão de outros arquivos com código no corpo do seu texto-fonte.
Entre as várias diretivas da Linguagem C, será abordada a seguir outra diretiva importante na programação com esta linguagem. A diretiva #define serve para definir termos (palavras) que serão substituídos por algum outro valor ou expressão, antes do programa ser compilado (traduzido pelo computador), por exemplo:
#define LIMITE 30
Este exemplo instrui o computador ao acionamento do pré-processador, que procurará o termo LIMITE no programa fonte e o substituirá pelo valor 30, antes mesmo de sua compilação.
#define FIM printf("\nPressione um tecla para continuar.")
Da mesma forma, em todas as linhas de um programa que possuir a diretiva acima (FIM), todos os locais onde o termo FIM estiver inserido no programa fonte sofrerão alteração com a substituição pela instrução printf, definida na diretiva de FIM. Observe nestes exemplo que por convenção o termo empregado nesta diretiva está sempre, totalmente, em letras maiúsculas.
Entre várias utilidades, o bom uso desta diretiva de substituição de texto no programa fonte, facilita a adaptabilidade dos seus programas. Veja o exemplo de um programa que armazena as notas dos alunos de uma turma formada por 20 pessoas, apresentando antes do término de sua execução a média da turma:
/* SÍNTESE
Objetivo: calcular a média da turma de 20 alunos
Entrada: 20 notas
Saída: média da turma
*/
#include <stdio.h>
#include <conio.ch>
#define MAX 20
int main(void)
{
// Declarações
float nota[MAX], mediaTurma = 0;
int contador;
// Instruções
for(contador=0; contador < MAX; contador++){
printf("\nInforme a nota do aluno %d: ", contador + 1);
scanf("%f",¬a[contador]);
mediaTurma = mediaTurma + nota[contador];
}
clrscr();
mediaTurma = mediaTurma / MAX;
printf("\n\nMedia dos MAX alunos: %.2f",mediaTurma);
getch();
return 0;
}
MAX é uma diretiva que define a quantidade de alunos sempre que é necessário no programa, como na declaração do vetor de notas, nas leituras, no cálculo da média e na apresentação do resultado. Caso a quantidade de alunos da turma seja diferente de 20, basta modificar o valor de MAX na diretiva #define somente, que todo o programa será adaptado para a nova quantidade, respeitando a lógica do raciocínio empregado.
De maneira similar as funções, esta diretiva ainda pode receber e manipular parâmetros para realizarem substituições coerentes com os valores e operações a serem efetivadas. A esta empregabilidade da diretiva #define é atribuída a denominação de
Observe o exemplo:
# define SOMA(X,Y) X+Y
Esta diretiva #define manipulará dois parâmetros (X,Y), sendo identificada como uma macro denominada SOMA. Ela representará a instrução de adição dos parâmetros X e Y, como no programa de exemplo:
/* SÍNTESE
Objetivo: somar dois valores numéricos
Entrada: dois números
Saída: valor da soma
*/
#include <stdio.h>
#include <conio.ch>
#define SOMA(X,Y) X+Y
int main(void)
{
// Declarações
int valor1, valor2, total;
// Instruções
printf("\nInforme dois números: ");
scanf("%d %d", &valor1, valor2);
total = SOMA(valor1, valor2);
printf("\n\nTotal da soma = %2d", total);
getch();
return 0;
}
No exemplo acima são lidos dois valores inteiros definidos pelo programa e na sequência a macro SOMA é acionada e seu resultado é armazenado e apresentado pela variável total. Repare que X e Y (os argumentos da macro SOMA) não possuem tipos de dados definidos, por isso também podem ser usados por valores float sem sofrer nenhuma alteração em sua instrução #define SOMA(X,Y) X+Y.
Esta importante constatação é relevante no uso de macros, pois corresponde a uma das diferenças fundamentais entre função e macro. Outro ponto relevante e diferencial entre as funções e as macros consiste no cuidado que deve existir com a sintaxe e a utilização dos parâmetros desde a criação da macro. Suponha que no exemplo anterior fosse criada a macro para o cálculo de uma operação aritmética de multiplicação, ao invés da adição. A expectativa do raciocínio resultante da execução deste programa poderia divergir do resultado apresentado pelo mesmo. Por exemplo:
- Imagine qual seria o resultado para a instrução do programa
- total = 2 * SOMA(valor1,valor2) que substituiria a instrução similar do exemplo acima (total = SOMA(valor1, valor2 )).
Após sua substituição a expressão matemática resultante realizaria primeiro a multiplicação entre 2 e somente o valor armazenado pela variável valor1. Em seguida, somaria ao seu resultado o valor da variável valor2, sendo este armazenado na variável total. No entanto, a expectativa do programador poderia ser que primeiro seria efetuada a soma para depois ser realizada a multiplicação de 2 sobre seu resultado.
Para evitar este tipo de inconveniente, recomenda-se o uso apropriado de parênteses nos parâmetros de definição da macro, pois estes não possuem tipos de dados defindos e podem aceitar e manipular qualquer tipo de valor para cada um de seus acionamentos. Para o exemplo da multiplicação seria mais conveniente a definição abaixo, evitanto este tipo de inconveniente de execução da macro:
#define SOMA(X,Y) ((X) * (Y))
Já para o exemplo acima, a adição seria elaborada na macro SOMA como:
#define SOMA(X,Y) ((X) + (Y))
Atividade de Fixação
No intuito de fixar os novos conteúdos abordados por este módulo e verificar sua compreensão sobre os mesmos, são sugeridos alguns exercícios de fixação para serem resolvidos. Clique no link de exercícios ao lado para iniciar a lista de exercícios referente a este conteúdo abordado. Bons estudos sobre os mesmos!!