classe ainda mais completa

#include <iostream>

template <typename T>
class Vetor {
private:
    T* arr;
    int capacidade;
    int atual;

public:
    // Construtor padrão
    Vetor() {
        arr = new T[1];
        capacidade = 1;
        atual = 0;
    }

    // Construtor com tamanho inicial
    Vetor(int tamanho) {
        arr = new T[tamanho];
        capacidade = tamanho;
        atual = tamanho;
    }

    // Construtor com tamanho inicial e valores
    Vetor(int tamanho, T valor) {
        arr = new T[tamanho];
        capacidade = tamanho;
        atual = tamanho;
        for (int i = 0; i < tamanho; i++) {
            arr[i] = valor;
        }
    }

    // Construtor a partir de um array
    Vetor(T* inicio, T* fim) {
        int tamanho = fim - inicio;
        arr = new T[tamanho];
        capacidade = tamanho;
        atual = tamanho;
        for (int i = 0; i < tamanho; i++) {
            arr[i] = inicio[i];
        }
    }

    // Construtor a partir de outro vetor (cópia direta)
    Vetor(const Vetor& outro) {
        capacidade = outro.capacidade;
        atual = outro.atual;
        arr = new T[capacidade];
        for (int i = 0; i < atual; i++) {
            arr[i] = outro.arr[i];
        }
    }

    ~Vetor() {
        delete[] arr;
    }

    void adicionar(T dado) {
        if (atual == capacidade) {
            T* temp = new T[2 * capacidade];
            for (int i = 0; i < capacidade; i++) {
                temp[i] = arr[i];
            }
            delete[] arr;
            capacidade *= 2;
            arr = temp;
        }
        arr[atual] = dado;
        atual++;
    }

    void adicionar(T dado, int indice) {
        if (indice == capacidade) {
            adicionar(dado);
        } else {
            arr[indice] = dado;
        }
    }

    T obter(int indice) {
        if (indice < atual) {
            return arr[indice];
        }
        return -1; // ou lançar uma exceção
    }

    void remover() {
        if (atual > 0) {
            atual--;
        }
    }

    int tamanho() {
        return atual;
    }

    int obterCapacidade() {
        return capacidade;
    }

    void imprimir() {
        for (int i = 0; i < atual; i++) {
            std::cout << arr[i] << " ";
        }
        std::cout << std::endl;
    }

    // Operador de índice
    T& operator {
        if (indice >= atual) {
            throw std::out_of_range("Índice fora do intervalo");
        }
        return arr[indice];
    }

    // Método para redimensionar o vetor
    void redimensionar(int novoTamanho, T valor = T()) {
        T* temp = new T[novoTamanho];
        int limite = (novoTamanho < atual) ? novoTamanho : atual;
        for (int i = 0; i < limite; i++) {
            temp[i] = arr[i];
        }
        for (int i = limite; i < novoTamanho; i++) {
            temp[i] = valor;
        }
        delete[] arr;
        arr = temp;
        capacidade = novoTamanho;
        atual = novoTamanho;
    }
};

int main() {
    // Usando o construtor padrão
    Vetor<int> v1;
    v1.adicionar(10);
    v1.adicionar(20);
    v1.adicionar(30);

    std::cout << "Elementos do vetor v1: ";
    v1.imprimir();

    // Usando o construtor com tamanho inicial
    Vetor<int> v2(5);
    v2.adicionar(40);
    v2.adicionar(50);

    std::cout << "Elementos do vetor v2: ";
    v2.imprimir();

    // Usando o construtor com tamanho inicial e valores
    Vetor<int> v3(4, 100);

    std::cout << "Elementos do vetor v3: ";
    v3.imprimir();

    // Usando o construtor a partir de um array
    int meusInts[] = {16, 2, 77, 29};
    Vetor<int> v4(meusInts, meusInts + sizeof(meusInts) / sizeof(int));

    std::cout << "Elementos do vetor v4: ";
    v4.imprimir();

    // Usando o construtor a partir de outro vetor (cópia direta)
    Vetor<int> v5(v4);
    std::cout << "Elementos do vetor v5 (cópia de v4): ";
    v5.imprimir();

    // Acessando elementos com o operador []
    std::cout << "Elemento no índice 2 de v5: " << v5[2] << std::endl;

    // Redimensionando o vetor
    v5.redimensionar(6, 200);
    std::cout << "Elementos do vetor v5 após redimensionar: ";
    v5.imprimir();

    return 0;
}