LÓGICA - Variáveis Compostas Homegêneas Unidimensionais

Programação em C - Passagem de parâmetros por valor e referência

Estudo de caso: Soma de bits/bytes

Para estudarmos um pouco mais sobre passagem de parâmetros por valor e referência vamos aplicar um exemplo.

Exemplo

(a)Escreva uma função com protótipo void somabit (int b1, int b2, int *vaium, int *soma); que recebe três bits (inteiros entre 0 e 1) b1, b2 e *vaium e devolve um bit soma representando a soma dos três e o novo um bit "vai-um" em *vaium.
(b)Escreva um programa que leia dois números em binário (8 bits) e calcula um número em binário que é a soma dos dois números dados. Utilize a função acima.

Entendendo

Considerando o protótipo do item (a), temos que dois dados são passados por valor (b1 e b2) e dois dados são passados por referência (vaium e soma). Isso se fez necessário pois ao somar dois bits podemos ter dois resultados. Sabe-se, em binário, que:

• 0 + 0 = 0
• 0 + 1 = 1
• 1 + 0 = 1
• 1 + 1 = 0 e o bit 1 é inserido a esquerda, desta forma, 1 + 1 = 10

Por isso, a função somabit tem dois retornos, o bit que foi somado (soma) e o bit que vai para esquerda (vaium).
Observe a seguir a implementação da função somabit:

 void somabit(int b1, int b2, int *vaium, int *soma){  
   /*  
    * Como estratégia de desenvolvimento, vamos somar todos os bits (b1, b2 e vaium).  
    * Desta forma teremos as possíveis combinações:  
    *   b1   0  1  1  1  1  0  0  0  
    *   b2   0  0  1  0  1  1  1  0  
    *   vaium  0  0  0  1  1  0  1  1  
    *   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  
    *   sum   0  1  2  2  3  1  2  1  -> Considerando a soma como inteiros  
    *  
    *   Assim, quando sum:  
    *     = 0, soma é 0 e vaium é 0  
    *     = 1, soma é 1 e vaium é 0  
    *     = 2, soma é 0 e vaium é 1  
    *     = 3, soma é 1 e vaium é 1  
    *  
    * Definida a lógica, agora basta trabalhar com os ponteiros.  
    */  
   int sum;  
   sum = b1 + b2 + *vaium;  
   switch(sum){  
     case 0:  
       *soma = 0;  
       *vaium = 0;  
       break;  
     case 1:  
       *soma = 1;  
       *vaium = 0;  
       break;  
     case 2:  
       *soma = 0;  
       *vaium = 1;  
       break;  
     default:  
       *soma = 1;  
       *vaium = 1;  
   }  
 }  

Observe que para atribuir um valor para a variável (ponteiro) que é passada por referência devemos utilizar o (*) antes do nome da variável, isso para indicar que queremos acessar o "conteúdo" do espaço de memória apontado pelo ponteiro.
Após essa implementação, vamos resolver o restante da questão. Definimos a biblioteca com as assinaturas das funções e na sequência temos a implementação das funções.

Biblioteca:

 void somabit(int, int, int *, int *);  
 int somaBytes(int, int, int *);  
 int ehByte(int);  
 void fatorarByte(int[], int);  

Funções:

 void fatorarByte(int vetor[], int byte){  
   int i;  
   i = 7;  
   while(i >= 0){  
     vetor[i] = byte / pow(10, i);  
     byte = byte - vetor[i] * pow(10, i);  
     i--;  
   }  
 }  
 int somaBytes(int byte1, int byte2, int *erro){  
   int byte3, bit1, bit2, bitAdicional, bitSoma, i;  
   int vByte1[8], vByte2[8];  
   byte3 = 0;  
   *erro = FALSE;  
   if(ehByte(byte1) && ehByte(byte2)){  
     fatorarByte(vByte1, byte1);  
     fatorarByte(vByte2, byte2);  
     i=0;  
     bitAdicional = 0;  
     while(i<=7){  
       somabit(vByte1[i], vByte2[i], &bitAdicional, &bitSoma);  
       byte3 += bitSoma * pow(10, i);  
       i++;  
     }  
     byte3 += bitAdicional * pow(10, 8);  
   }else{  
     *erro = TRUE;  
   }  
   return byte3;  
 }  
 int ehByte(int byte){  
   int i, bit;  
   int ehValido = TRUE;  
   if(byte <= pow(10, 8) && byte >= 0){  
     i=7;  
     while(i>=0 && ehValido){  
       bit = byte / pow(10, i);  
       if(bit > 1){  
         ehValido = FALSE;  
       }  
       byte = byte - bit * pow(10, i);  
       i--;  
     }  
   }else{  
     ehValido = FALSE;  
   }  
   return ehValido;  
 }  
 int main(){  
   int a, b, c, d;  
   printf("Digite binário de 8 bits: ");  
   scanf("%d", &a);  
   printf("Digite binário de 8 bits: ");  
   scanf("%d", &b);  
   printf("\t%8d\n+\n\t%8d\n=\n\t", a, b);  
   d = somaBytes(a, b, &c);  
   if(c != TRUE){  
     printf("%8d\n", d );  
   }else{  
     printf("Erro ao somar os bytes.\n");  
   }  
   return 0;  
 }  

Disciplina: Estruturas de Dados - 2º semestre 2016

Este assunto foi abordado na aula de 29/07/2016.