Fácil C++

Criando um par genérico

Enunciado

Implemente uma classe template Par que armazena dois valores de tipos possivelmente diferentes. A classe deve ter um construtor que recebe os dois valores, um método primeiro() que retorna o primeiro, um método segundo() que retorna o segundo, e um método trocar() que troca os valores entre si.

Requisitos

  • A classe deve ser um template com dois parâmetros de tipo.
  • O construtor deve inicializar os membros com os valores fornecidos.
  • Os métodos primeiro() e segundo() devem retornar os valores.
  • O método trocar() deve inverter os valores armazenados.

Código inicial

#include <iostream>
#include <string>

template <typename T1, typename T2>
class Par {
    // TODO: declarar membros e métodos
};

int main() {
    Par<int, std::string> p(10, "dez");
    std::cout << p.primeiro() << " " << p.segundo() << '\n';
    p.trocar();
    std::cout << p.primeiro() << " " << p.segundo() << '\n';
    return 0;
}

Saída esperada

10 dez
dez 10
Ver dica

Use dois membros privados primeiro_ e segundo_ do tipo T1 e T2. No método trocar(), use std::swap.

Mostrar solução 
#include <iostream>
#include <string>
#include <utility> // std::swap

template <typename T1, typename T2>
class Par {
    T1 primeiro_;
    T2 segundo_;
public:
    Par(const T1& p, const T2& s) : primeiro_(p), segundo_(s) {}

    T1 primeiro() const { return primeiro_; }
    T2 segundo() const { return segundo_; }

    void trocar() {
        std::swap(primeiro_, segundo_);
    }
};

int main() {
    Par<int, std::string> p(10, "dez");
    std::cout << p.primeiro() << " " << p.segundo() << '\n';
    p.trocar();
    std::cout << p.primeiro() << " " << p.segundo() << '\n';
    return 0;
}

Passo a passo

  1. Declaramos a classe template Par com dois parâmetros de tipo T1 e T2.
  2. Os membros primeiro_ e segundo_ armazenam os valores.
  3. O construtor recebe dois argumentos e inicializa os membros.
  4. Os métodos primeiro() e segundo() retornam cópias dos valores (poderiam retornar referências, mas aqui simplificamos).
  5. O método trocar() usa std::swap para trocar os valores entre si.
  6. No main, instanciamos Par<int, std::string> e testamos.

Por que funciona

O template permite que a mesma classe armazene tipos diferentes. A troca funciona porque std::swap é genérico e funciona para qualquer tipo que seja movível/copiável. O compilador gera uma especialização para Par<int, std::string>.

Erros comuns

  • Esquecer de incluir <utility> para std::swap: erro de compilação.
  • Declarar trocar() como const: não compila, pois modifica os membros.
  • Retornar referências sem cuidado: se retornar T1&, o objeto pode ser modificado externamente; aqui retornamos por valor.

Outra forma de resolver

Usar std::pair da biblioteca padrão, que já faz isso. Preferível quando não precisa de métodos extras.

Saída esperada

10 dez
dez 10