#include <iostream>
#include <string>

// Template für flexiblen Array Typ
template <typename T>
class Container {
private:
    // T-Pointer für Inhalt des Array
    T* data;
    // int für Größe des Array
    int arr_size;

    // Methode für Umkopieren in neues Array
    void updateSize(int new_arr_size) {
        // Reservierung von Speicher mit T-Pointer für Übergangsarray mit benötigter Größe
        T* new_data = new T[new_arr_size];
        // Füllen des Übergangsarray mit Array Inhalt
        for (int i = 0; i < arr_size; i++) {
            new_data[i] = data[i];
        }
        // Speicherfreigabe von altem Array
        delete[] data;
        // Array Inhalt von Objekt Instanz auf T-Pointer von Übergangsarray linken
        data = new_data;
        // Speicherfreigabe vom Übergangsarray
        delete[] new_data;
        // Aktualisieren der Array Größe der Instanz
        arr_size = new_arr_size;
    }

public:
    // Konstruktor mit Anfangsarraygröße als Parameter
    Container(int initial_arr_size){
        // Array Größe der Instanz initialisieren
        arr_size = initial_arr_size;
        // Speicherreservierung für Array Inhalt
        data = new T[initial_arr_size];
    }

    // Destruktor
    ~Container() {
        // Speicherfreigabe von Array Inhalt
        delete[] data;
    }

    // Überladung des [] Operators
    T& operator[](int index) {
        // Aktualisierung auf neue Größe, falls nötig
        if (index >= arr_size) {
            updateSize(index + 1); 
        }
        // Eigentliche Rückgabe des Inhalt an Stelle des Index
        return data[index];
    }

    // Methode zur Rückgabe der Array Größe
    int getArraySize() {
        return arr_size;
    }
};

int main() {

    Container<std::string> container(10);

    printf("%d\n", container.getArraySize());

    container[15] = "Test";

    std::cout << "container[15]: " << container[15] << std::endl;
    
    printf("%d\n", container.getArraySize());

    return 0;
};