При применении operator+ появляется ошибка "invalid operands of types 'List*' and 'List*' to binary 'operator+"

#include <iostream>
 
using namespace std;
 
struct Node
{
    Node* next;
    int value;
};
 
class List
{
public:
    Node* ptr;
 
    List()
    {
        ptr = new Node;
        ptr->next = nullptr;
    }
 
    List(int value)
    {
        ptr = new Node;
        ptr->next = new Node;
        ptr->next->value = value;
        ptr->next->next = nullptr;
    }
 
    List(const List &list)
    {
        Node* temp = list.ptr;
        if(temp != nullptr && temp->next != nullptr)
        {
            temp = temp->next;
            ptr = new Node;
 
            while(temp->next != nullptr)
            {
                ptr->next = temp;
                ptr = ptr->next;
                temp = temp->next;
            }
        }
    }
 
    List& operator= (List const &list)
    {
        Node* temp = list.ptr;
        if(temp != nullptr && temp->next != nullptr)
        {
            temp = temp->next;
            ptr = new Node;
 
            while(temp->next != nullptr)
            {
                ptr->next = temp;
                ptr = ptr->next;
                temp = temp->next;
            }
        }
 
        return *this;
    }
 
    ~List()
    {
 
    }
 
    List* operator+ (List const &list)
    {
        List* sum_result = clone();
        Node* temp = list.ptr;
        while(temp->next != nullptr)
        {
            sum_result->add(temp->next->value);
            temp = temp->next;
        }
        return sum_result;
    }
 
    void remove(int value)
    {
        if(ptr != nullptr)
        {
            Node* p = ptr;
 
            while(p->next != nullptr && p->next->value != value)
            {
                p = p->next;
            }
 
            if(p->next != nullptr && p->next->value == value)
            {
                Node* delete_element = p->next;
                p->next = p->next->next;
                delete delete_element;
            }
        }
    }
 
    void add(int value)
    {
        if(ptr == nullptr)
        {
            List(value);
        }
        else
        {
            Node* p = ptr;
 
            while(p->next != nullptr)
            {
                p = p->next;
            }
 
            p->next = new Node;
            p->next->value = value;
            p->next->next = nullptr;
        }
    }
 
    List* clone()
    {
        List* copy_list = new List();
        Node* p = ptr;
 
        while(p->next != nullptr)
        {
            copy_list->add(p->next->value);
            p = p->next;
        }
 
        return copy_list;
    }
 
    List* sort()
    {
        if(ptr == nullptr || ptr->next == nullptr)
            return NULL;
 
        List* sorted_list = clone();
        int temp;
 
        for(Node* i = sorted_list->ptr; i->next->next != nullptr; i = i->next)
        {
            for(Node* j = sorted_list->ptr; ; j = j->next)
            {
                if(j->next->next == nullptr)
                    break;
 
                if(j->next->value > j->next->next->value)
                {
                    temp = j->next->value;
                    j->next->value = j->next->next->value;
                    j->next->next->value = temp;
                }
            }
        }
 
        return sorted_list;
    }
};
 
 
int main()
{
    List* list = new List();
    list->add(3);
    list->add(2);
    list->add(1);
 
    List* list2 = list;
    List* list3 = list + list2;
 
    return 0;
}

List *list3 = *list + *list2;