error: new initializer expression list treated as compound expression [-fpermissive]

Question

I am trying to write a playlist method for songs in c++, however, I keep running into frequent errors.

template <typename T>
struct cir_list_node
{
    
    T* data;
    cir_list_node *next, *prev;
    //destructor
    ~cir_list_node() {
            delete data;
    }
};


template <typename T>
struct cir_list
{
    public:
            using node = cir_list_node<T>;    // renaiming for local use
            using node_ptr = node*;
    private:
            node_ptr head;
            size_t n;

    public:
    // basic constructor and size function
    cir_list(): n(0) // initiator list
    {
            head = new node(NULL,NULL,NULL); //dummy node
            head->next = head;      // circular list wraps around
            head->prev = head;
    }


    cir_list(const cir_list& other): cir_list()
    {
            // insert in reverse order (okay because list is circular)
            for(const auto& i : other)
                    insert(i);
    }
    cir_list(const std::initializer_list<T>& il): head(NULL), n(0)
    {
            //insert in reverse order
            for(const auto& i : il)
                    insert(i);
    }
    ~cir_list()
    {
            while(size())
            {
                    erase(head->data);
            }
    }

    size_t size() const
    {
            return n;
    }
    void insert(const T& value)
    {
            node_ptr newNode = new node(new T(value),NULL,NULL);
            n++;
            auto dummy = head->prev;
            dummy->next = newNode;
            newNode->prev = dummy;
            if(head == dummy) {
                    dummy->prev = newNode;
                    newNode->next = dummy;
                    head = newNode;
                    return;
            }
            newNode->next = head;
            head->prev = newNode;
            head = newNode;
            return;
    }

    void erase(const T& value)
    {
            auto cur = head, dummy = head->prev;
            while (cur != dummy){
                    if(*(cur->data) == value){
                            cur->prev->next = cur->next;
                            cur->next->prev = cur->prev;
                            if(cur == head)
                                    head = head->next;
                            delete cur;
                            n--;
                            return;
                    }
            cur = cur->next;
            }
    }

    struct cir_list_it
    {
    private:
            node_ptr ptr;
     public:
            cir_list_it(node_ptr p) : ptr(p)
            {}

            T& operator*()
            {
                    return *(ptr->data);
            }
            node_ptr get()
            {
                    return ptr;
            }

            cir_list_it& operator++() // prefix
            {
                    ptr = ptr->next;
                    return *this;
            }
            cir_list_it operator++(int) // postfix
            {
                    cir_list_it it = *this;
                    ++(*this);
            }
            cir_list_it& operator--() //prefix
            {
                    ptr = ptr->prev;
                    return *this;
            }
            cir_list_it operator--(int) // postfix
            {
                    cir_list_it it = *this;
                    --(*this);
                    return it;
            }

            friend bool operator == (const cir_list_it& it1, const cir_list_it& it2)
            {
                    return it1.ptr == it2.ptr;
            }
            friend bool operator != (const cir_list_it& it1, const cir_list_it& it2)
            {
                    return it1.ptr != it2.ptr;
            }
    };

    cir_list_it begin()
    {
            return cir_list_it {head};
    }
    cir_list_it end()
    {
            return cir_list_it {head->prev};
    }
    cir_list_it end() const
    {
            return cir_list_it{head->prev};
    }
};
struct playlist
{
    cir_list<int> list;

    void insert(int song)
    {
            list.insert(song);
    }
    void erase(int song)
    {
            list.erase(song);
    }
    void loopOnce()
    {
            for(auto& song : list){
                    std::cout << song << " ";
            }
            std::cout << std::endl;
    }
};

int main()
{
    playlist pl;
    pl.insert(1);
    pl.insert(2);
    std::cout << "Playlist: ";
    pl.loopOnce();

    playlist pl2 = pl;
    pl2.erase(2);
    pl2.insert(3);
    std::cout << "Second playlist";
    pl2.loopOnce();
}

Errors

1 and 2:

3 and 4:

Answer 1

It seems there is a typo

struct cir_list_node
{
    
    T* data;
    cir_list_node *next, *prev;
    //destructor
    ~cir_list_node() {
            delete data;
    }
};

You forgot to prefix this declaration with

template <typename T>

This template structure declaration declares an aggregate.

You can not initialized it with an expression inside parentheses like

head = new node(NULL,NULL,NULL); 

Instead you need to write using braces

head = new node { NULL, NULL, NULL }; 

or as you are writing a C++ program then

head = new node { nullptr, nullptr, nullptr }; 

Answer 2

It seems there is a typo

struct cir_list_node {

T* data;
cir_list_node *next, *prev;
//destructor
~cir_list_node() {
        delete data;
}

};