qt c++ template: 'Instantiation of variable required here, but no definition is available' [duplicate]

I was creating a custom vector for university project. So i've created a class CVector of type T, but when i compile i get the message:

/home/toldo/Desktop/UniPD/PAO/Progetto/DuISmart/Models/mainviewmodel.cpp:24: warning: instantiation of function 'CVector::erase' required here, but no definition is available

but i don't get why, I read that the cause may be a static member, but i do not have one in CVector class.

This is CVector.h:

#define CVECTOR_H


template <class T>
class CVector {

private:
    /**
     * @brief arr: E' l'array di tipo T che contiene l'indirizzo del vettore
     */
    T* arr;

    /**
     * @brief capacity: Storage totale del vector
     */
    int capacity;

    /**
     * @brief current: Numero corrente di elementi presenti nel vettore
     */
    int current;

public:

    /**
     * @brief CVector: Costruttore di default
     */
    CVector();

    /**
     * @brief CVector: Costruttore di copia
     * @param vec: vettore da copiare
     */
    CVector(const CVector<T>& vec);

    ~CVector();

    const T& operator[](int i) const;

    T& operator[](int i);

    const T& operator*() const;

    T& operator*();

    /**
     * @brief push: Funzione per aggiungere un elemento in coda al vettore
     * @param data: Dato da inserire
     */
    void push(const T& data);

    /**
     * @brief push: Funzione per aggiungere un elemento ad una qualsiasi posizione
     * @param data: Dato da inserire
     * @param index: Indice in cui inserire il dato
     */
    void push(const T& data, int index);

    /**
     * @brief get: Estrae l'elemento ad un dato indice
     * @param index: indice di cui si vuole l'elemento
     * @return
     */
    T& get(int index) const;

    /**
     * @brief erase: Funzione per eliminare uno specifico elemento. Viene tolto dal vettore e viene chiamato il distruttore dell'elemento
     * @param item: Elemento da eliminare
     */
    void erase(const T& item);

    /**
     * @brief size: Funzione per avere la dimenzione del vettore
     * @return
     */
    int size() const;
};

#endif // CVECTOR_H

This is CVector.cpp:

#include "cvector.h"

template<class T>
CVector<T>::CVector(){
    arr = new T[1];
    capacity = 1;
    current = 0;
}

template<class T>
CVector<T>::CVector(const CVector<T>& vec){
    delete[] arr;
    arr = new T[vec.capacity];
    for (int i = 0; i < capacity; i++) { arr[i] = vec[i]; }
}

template<class T>
CVector<T>::~CVector(){
    delete[] arr;
}

template<class T>
const T& CVector<T>::operator[](int i) const{ return arr[i]; }

template<class T>
T& CVector<T>::operator[](int i) { return arr[i]; }

template<class T>
const T& CVector<T>::operator*() const { return arr[0]; }

template<class T>
T& CVector<T>::operator*() { return arr[0]; }

template<class T>
void CVector<T>::push(const T& data){
    // se il numero di elementi e' uguale a capacity
    // significa che non c'e piu spazio.
    // dobbiamo raddoppiare la capacita'
    if (current == capacity) {
        T* temp = new T[2 * capacity];

        // copio il vecchio array in un nuovo array
        for (int i = 0; i < capacity; i++) {
            (temp+i) = (arr+i);
        }

        // deleting previous array
        delete[] arr;
        capacity *= 2;
        arr = temp;
    }

    // inserisco il nuovo elemento
    arr[current] = data;
    current++;
}

template<class T>
void CVector<T>::push(const T& data, int index){
    // se l'index e' uguale a capacity allora
    // la funzione e' la sessa di quella definita sopra
    if (index == capacity) push(data);
    else arr[index] = data;
}

template<class T>
T& CVector<T>::get(int index) const{
    // se l'index e' nel range
    if (index < current) return arr[index];
    else return nullptr;
}

template<class T>
void CVector<T>::erase(const T& item){
    bool transpose = false;
    for (int i=0; i<current-1; i++) {
        if(item == arr[i]) transpose = true;
        (arr+i) = transpose ? (arr+i+1) : (arr+i);
    }
    (arr+current) = nullptr;
    delete item;
    current--;
}

template<class T>
int CVector<T>::size() const{ return current;}

And here is where i use the CVector class (.h file):

#ifndef MAINVIEWMODEL_H
#define MAINVIEWMODEL_H

#include "basemodel.h"
#include "Entities/smartdevice.h"
#include "Entities/listdevice.h"
#include "Entities/cvector.h"


class MainViewModel : public BaseModel{

******
private:

    /**
     * @brief rooms: Stanze presenti
     */
    QList<const QString*> *rooms;

    /**
     * @brief deviceList: Lista device
     */
    CVector<const SmartDevice*> deviceList;
};
******

.cpp file:

******
void MainViewModel::removeDevice(int devId){
    const SmartDevice* dev = nullptr;
     for (int i=0; i<deviceList.size() && !dev; i++) { //here got the warning for size
         dev = deviceList[i]->isThisDevice(devId); //here got the warning for operator[]
         if(dev){
             deviceList.erase(dev); //here got the warning for erase
         }
     }
}
******