Em diversas situações faz-se necessário a troca dos valores entre duas variáveis. Isso pode ser feito com o auxílio de uma variável auxiliar ou através de uma função dedicada à essa troca. Tal função geralmente é denominada swap (“trocar” em inglês) que recebe o endereço das variáveis cujos conteúdos se deseja trocar e dentro da função é realizada a troca. Desenvolva a função swap(), cujo esqueleto encontra-se indicado abaixo. Realize testes de utilização dessa função para validá-la.
void swap( float *a, float *b ) {
}

Passo 1

O que o enunciado pede:
  • Desenvolver a função swap() com a assinatura:
void swap( float *a, float *b ) {
}
  • A função deve trocar os valores das variáveis cujos endereços são passados por a e b.
  • Realizar testes de utilização para validar que a função funciona.
Informações dadas:
  • Você recebeu apenas o esqueleto da função com dois parâmetros do tipo float * (ponteiros para float).
  • Não foi pedido nenhum método específico dentro da função — apenas que a troca seja realizada.

Passo 2

Entendendo o problema (porque usamos ponteiros e o que significa “trocar”):
  • Em C, quando você chama uma função normalmente, os argumentos são passados por valor. Ou seja, a função recebe cópias dos dados; modificar essas cópias não muda a variável original fora da função.
  • Para que uma função consiga alterar o conteúdo de uma variável definida no chamador, precisamos passar o endereço dessa variável. Em C usamos ponteiros para isso: um ponteiro guarda o endereço de memória.
  • No caso da assinatura void swap( float *a, float *b ), a e b são ponteiros que apontam para os locais onde estão guardados os float originais. Dentro da função podemos usar o operador de desreferência (*) para ler e escrever o valor nesses endereços.
  • A ideia da troca (swap) é simples: guardar temporariamente o valor de um, copiar o valor do outro para o primeiro e então colocar o valor temporário no segundo. Ou seja, precisamos de uma variável temporária.
Analoginha rápida: pense em duas caixas com números dentro. Você está com as instruções e pode abrir as caixas apontadas por um endereço. Para trocar, pega o número da caixa A, coloca em uma bolsinha (temporária), copia o número da caixa B para A, e então tira da bolsinha e coloca em B.

Passo 3

Implementação segura e simples (com variável temporária):
  • O método mais claro e seguro é usar uma variável temporária do mesmo tipo (float) para guardar um valor enquanto o outro é copiado.
  • Explicação passo a passo do código:
    • float temp = *a; — lemos o valor apontado por a e guardamos em temp.
    • *a = *b; — copiamos para aonde a aponta o valor que está em b.
    • *b = temp; — colocamos no local apontado por b o valor guardado em temp.
  • Esse método funciona mesmo se a == b (os dois ponteiros apontarem para o mesmo endereço): o valor final permanece igual, não há problema.
Exemplo da função:
void swap( float *a, float *b ) {
    float temp = *a;
    *a = *b;
    *b = temp;
}

Passo 4

Por que não usar métodos “esquisitos” em prova (como soma/subtração sem temporária)?
  • Para inteiros existe a técnica de XOR-swap (apenas para inteiros) ou somar/subtrair sem temporária. Porém:
    • XOR-swap só serve para inteiros e é menos legível.
    • Somar/subtrair para floats pode causar perda de precisão ou overflow, então não é recomendável.
  • Portanto, use a variável temporária: é simples, seguro e fácil de explicar/justificar na prova.

Passo 5

Testes: como montar um programa de teste e quais casos testar
  • Devemos testar:
    1. Dois valores distintos (positivo/negativo) para ver se realmente trocou.
    2. Valores iguais para verificar comportamento neutro.
    3. Ambos zero.
    4. Trocar uma variável com ela mesma (passando o mesmo endereço duas vezes) — deve permanecer inalterada.
  • Um bom teste imprime os valores antes e depois de chamar swap.
Exemplo de programa de teste (explicado):
  • Declarar algumas variáveis float.
  • Mostrar valores antes.
  • Chamar swap(&x, &y).
  • Mostrar valores depois.
  • Repetir para outros casos.
Também compile com algo como:
gcc -Wall -Wextra -std=c99 swap.c -o swap
e rode ./swap para ver as mensagens.

Passo 6

Exemplo de execução esperada (se usar os testes que sugeri):
  • Para o caso x = 1.5 e y = -3.25, antes: x = 1.500000, y = -3.250000; depois: x = -3.250000, y = 1.500000.
  • Para troca do mesmo endereço, o valor não muda.
Dica de escrita na prova: escreva a função com comentários curtos e mostre um teste mínimo (duas linhas de saída antes/depois). Isso já deixa claro que a função funciona.

Passo 7

Resumo final: o método recomendado e por quê
  • Use a versão com variável temporária.
  • É clara, segura para float, funciona em todos os casos práticos e é a que o examinador espera numa solução simples e correta.
  • Nos testes, verifique casos distintos e o caso de apontadores iguais.

Resposta

#include <stdio.h>

void swap( float *a, float *b ) {
    float temp = *a;
    *a = *b;
    *b = temp;
}

int main(void) {
    float x = 1.5f, y = -3.25f;
    printf("Antes: x = %f, y = %f\n", x, y);
    swap(&x, &y);
    printf("Depois: x = %f, y = %f\n\n", x, y);

    float a = 2.0f, b = 2.0f;
    printf("Antes: a = %f, b = %f\n", a, b);
    swap(&a, &b);
    printf("Depois: a = %f, b = %f\n\n", a, b);

    float z = 4.2f;
    printf("Antes (swap mesmo endereço): z = %f\n", z);
    swap(&z, &z);
    printf("Depois (swap mesmo endereço): z = %f\n", z);

    return 0;
}

Exercícios relacionados