I've written a singly linked list in C++. Would appreciate reviews on code efficiency and best practices. 


    #ifndef SLIST_HPP
    #define SLIST_HPP
    
    #include <stdexcept>
    
    template <typename T> struct node{
        node(T data):data(data),next(nullptr){}
        T data;
        node<T> * next;
    };
    
    template< typename T> class slist{
        node<T>* head;
        int size;
    public:
        slist(node<T>* head):head(head), size(0){}
    
        slist(const slist<T>& rhs){

        node<T>* temp = rhs.getHead();
        node<T>* p = new node<T>(temp->data);
        head = p;
        node<T>* current = p;
        while(temp != nullptr){

            current->next = new node<T>(temp->next->data);
            temp = temp->next;
            current = current->next;
            
        }

    }
        ~slist(){
            if(head == nullptr) return;
    
            while(head != nullptr){
                node<T>* current = head;
                head = head->next;
                delete(current);
            }
        }
        slist& operator= (const slist& rhs){
    
        }
        node<T>* getHead()const {
            return head;
        }
    
        void add(node<T>* p, T item){
            if(p == nullptr) return;
            node<T>* current = new node<T>(item);
            node<T>* temp = p->next;
            p->next = current;
            current->next = temp;
            size++;
    
        }
        void insertFront(T item){
            node<T>* p = new node<T>(item);
            if(head == nullptr){
                p = head;
                size++;
                return;
            }
            p->next = head;
            head = p;
            size++;
        }
    
        void insertBack(T item){
            node<T>* p = new node<T>(item);
            node<T>* current = head;
            while(current->next != nullptr){
                current = current->next;
            }
            current->next = p;
            size++;
        }
    
        void remove(T item){
            bool check = false;
    
            node<T>* current = head;
            try {
                while(current != nullptr){
                    if(current->data == item) check = true;
                    current = current->next;
                }
                if(!check){
                    throw std::runtime_error("Item not in list");
    
                }
            }catch(std::runtime_error& e){
                std::cout<<e.what()<<std::endl;
                exit(-1);
            }
    
            current = head;
            while(current != nullptr){
               if(current->next->data == item){
                   node<T>* temp = current->next;
                   current->next = current->next->next;
                   delete(temp);
                   break;
               }
                current = current->next;
            }
            size--;
    
        }
        int getSize () const {
            return size;
        }
    
        void printList(){
            node<T>* current = head;
            while(current != nullptr){
                if(current->next != nullptr){
                    std::cout<<current->data<<"->";
                }else{
                    std::cout<<current->data<<std::endl;
                }
                current = current->next;
            }
        }
    };
    #endif //SLIST_HPP