Templates de Classes

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 65 de 104.

Assim como os templates de função permitem que você escreva funções independentes de tipo, os templates de classe permitem que você crie classes independentes de tipo. É assim que containers como std::vector funcionam - você define a estrutura uma vez, e o compilador gera versões específicas para cada tipo que você utiliza.

template <typename T>
class Box {
    T value;
public:
    Box(T v) : value(v) {}
    T getValue() const { return value; }
    void setValue(T v) { value = v; }
};

int main() {
    Box<int> intBox(42);
    Box<std::string> strBox("Hello");
    
    std::cout << intBox.getValue() << std::endl;  // 42
    std::cout << strBox.getValue() << std::endl;  // Hello
}

Ao contrário dos templates de função, você deve especificar explicitamente o tipo ao criar objetos a partir de templates de classe usando colchetes angulares. O compilador então gera uma definição de classe completa para esse tipo específico.

Templates de classe podem ter múltiplos parâmetros de tipo e até mesmo parâmetros que não são de tipo, como inteiros:

template <typename T, int Size>
class FixedArray {
    T data[Size];
public:
    T& operator[](int index) { return data[index]; }
    int size() const { return Size; }
};

FixedArray<double, 5> arr;  // Array de 5 doubles
arr[0] = 3.14;

Ao definir funções-membro fora da classe, você deve repetir a declaração do template:

template <typename T>
class Container {
    T* data;
public:
    Container();
    ~Container();
};

template <typename T>
Container<T>::Container() : data(nullptr) {}

template <typename T>
Container<T>::~Container() { delete data; }

Templates de classe formam a base da programação genérica em C++, permitindo que você escreva estruturas de dados reutilizáveis que funcionam com qualquer tipo.

Desafio

Fácil

Vamos criar um sistema de armazenamento genérico usando templates de classe para criar um contêiner flexível que possa armazenar qualquer tipo de dado. Você organizará sua classe de template em um arquivo de cabeçalho e demonstrará sua versatilidade com diferentes tipos no seu programa principal.

Você criará dois arquivos:

Storage.h: Defina um template de classe chamado Storage que funciona como um contêiner simples para um único valor, com algumas operações úteis:
Seu template Storage deve ter:
- Um membro privado para armazenar o valor
- Um construtor que recebe um valor inicial
- Um método getValue() que retorna o valor armazenado
- Um método setValue() que atualiza o valor armazenado
- Um método isEmpty() que retorna true se o valor for igual ao valor construído por padrão do tipo T, e false caso contrário
Crie também um template de classe chamado Pair com dois parâmetros de tipo, que armazena dois valores relacionados:
- Membros privados para o primeiro e o segundo valores (que podem ser de tipos diferentes)
- Um construtor que inicializa ambos os valores
- Métodos getFirst() e getSecond() para obter cada valor
- Um método display() que imprime: (<first>, <second>)
main.cpp: Leia quatro entradas (cada uma em uma linha separada):
1. Um valor inteiro
2. Um novo valor inteiro
3. Um valor de string
4. Um valor double
Demonstre seus templates:
1. Criando um Storage<int> com o primeiro inteiro e imprimindo: Int storage: <value>
2. Atualizando-o com o segundo inteiro usando setValue() e, em seguida, imprimindo: Updated: <value>
3. Criando um Storage<std::string> com a entrada de string e imprimindo: String storage: <value>
4. Verificando se o armazenamento de string está vazio e imprimindo: Is empty: <true/false> (imprima true ou false)
5. Criando um Pair<std::string, double> com os valores de string e double e, em seguida, chamando display()
6. Criando um Pair<int, int> com ambas as entradas inteiras e, em seguida, chamando display()

Por exemplo, com as entradas 42, 100, Hello e 3.14:

Int storage: 42
Updated: 100
String storage: Hello
Is empty: false
(Hello, 3.14)
(42, 100)

Observe como o mesmo template Storage funciona perfeitamente com inteiros e strings, e como Pair pode combinar diferentes tipos. O compilador gera definições de classe separadas para cada combinação de tipos que você usa. Lembre-se de usar a sintaxe template <typename T> para templates de tipo único e template <typename T, typename U> para templates com vários parâmetros de tipo.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Storage.h"

using namespace std;

int main() {
    // Ler entradas
    int intValue1;
    int intValue2;
    string strValue;
    double doubleValue;
    
    cin >> intValue1;
    cin >> intValue2;
    cin >> strValue;
    cin >> doubleValue;
    
    // TODO: Criar Storage<int> com o primeiro inteiro e imprimir: Int storage: <value>
    
    // TODO: Atualizar com o segundo inteiro usando setValue(), imprimir: Updated: <value>
    
    // TODO: Criar Storage<std::string> com a string de entrada, imprimir: String storage: <value>
    
    // TODO: Verificar se o storage de string está vazio, imprimir: Is empty: true/false
    
    // TODO: Criar Pair<std::string, double> com a string e o double, chamar display()
    
    // TODO: Criar Pair<int, int> com ambos os inteiros, chamar display()
    
    return 0;
}