C/C++ - Qt Template su un tipo

Salve ragazzi,
Sto cercando di creare un template paragonabile ad una lista generica,
Ma ho un errore quando provo ad inizializzare il costruttore o la lista stessa.

Quello che vorrei fare è avere una lista basata su questa classe

1) Classe Rectangle

#ifndef RECTANGLE_H
#define RECTANGLE_H

class Rectangle
{
public:
    int X;
    int Y;
    int Width;
    int Height;

    Rectangle(int x,int y,int width,int height) : X(x),Y(y),Width(width),Height(height){}

    //Costruttore
    Rectangle(const Rectangle& o)
    {
        X = o.X;
        Y = o.Y;
        Width = o.Width;
        Height = o.Height;
    }

    Rectangle& operator =(const Rectangle& o)
    {
        if(this != &other)
        {
            X = o.X;
            Y = o.Y;
            Width = o.Width;
            Height = o.Height;
        }
        return *this;
    }

};

#endif // RECTANGLE_H

2) Un Template di una lista generica

template <class T>
class List {
T values [100000];


private:
    int count = 0;
  public:


    void Add(T value)
    {
        values[count] = value;
        count++;
    }
    int Count()
    {
        return count;
    }

    T& operator [](int idx)
    {
        return values[idx];
    }

    T& operator ++ (int idx)
    {
        values[idx]++;
    }

    T& operator -- (int idx)
    {
        values[idx]--;
    }

    bool Contains(T key)
    {
        for(int i = 0; i < sizeof(values); i++)
        {
            if(key == values[i])
                return true;

        }
    }
};

Nel codice esempio come provo a scrivere

List<Rectangle> *re = new List<Rectangle>;

//oppure
List<Rectangle> re;

Ho un errore del genere:


error: no matching function for call to 'Rectangle::Rectangle()'

Aiuti su come posso risolvere?

In effetti non esiste il costruttore

Rectangle()

senza argomenti. Mi sa che lo hai dimenticato.

P.S. la riga T values [100000]; non ha molto senso. Non devi allocare tanto spazio inutile nello stack. Devi usare un puntatore per strutture linkate.

Grazie mille nessuno!

Ho risolto come mi hai suggerito.
Purtroppo sono abiutato a programmare in C#.
Solitamente anche se dichiari un costruttore diverso dalla classe (parametrizzato) funziona ugualmente.
Nel senso che non c'è bisogno di estendere il costrutto vuoto.

Pensavo che la stessa regola valesse per il C++ invece no.

Grazie ancora nessuno.

Riguardo al template, ho provato a dare un'aggiustatina come mi hai consigliato.

Tutto funziona perfettamente.

template <class T> class List {
T* values;


private:
    int count = 0;
    int size;
    int capacity;

  public:
    List() : size(0),capacity(10)
    {
        values = new T[capacity];
    }

    ~List()
    {
        delete[] values;
    }

    void Add(T value)
    {
        if(size == capacity)
        {
            capacity*=2;
            T* new_values = new T[capacity];
            for(int i = 0; i < size; i++)
            {
                new_values[i] = values[i];
            }
            delete[] values;
            values = new_values;
        }

        values[size] = value;
        size++;
        count++;
    }



    int Count() const
    {
        return count;
    }


    T& operator [](int idx)
    {

        return values[idx];
    }

    T& operator ++ (int idx)
    {
        values[idx]++;
    }

    T& operator -- (int idx)
    {
        values[idx]--;
    }


    bool Contains(T key) const
    {
        for(int i = 0; i < sizeof(values); i++)
        {
            if(key == values[i])
                return true;

        }
    }

    int getSize() const
    {
        return size;
    }
};

Piccola domanda
secondo tuo consiglio, è più opportuno aggiungere inline ad esempio al getSize o rimanere come sta?

Va bene così

Ok grazie ancora nessuno.
Chiedevo giusto per informazione visto che si tratta di una libreria.

Ma ovviamente seguo i consigli di chi è più esperto di me.