Использование удаленной функции?

Question

Это мой int main:

#include <iostream>
#include "celle.h"
using namespace std;
int main(){
    cell a(1,9,true);
    grid A;
    return 0;}

Я пытаюсь реализовать список ячеек, но компилятор сообщает мне об этой ошибке:

| 10 | ошибка: нет соответствующей функции для вызова 'cell :: cell ()' |

| 52 | ошибка: использование удаленной функции 'List_node :: List_node ()' |

| 139 | ошибка: использование удаленной функции 'List_node :: List_node ()' |

Код связанный с ним список:

    template <class T>
    class Linked_list;

    template <class T>
    class List_node{
        friend class Linked_list<T>;
     private:
        T _value;
        List_node<T> * _pPrev;
        List_node<T> * _pNext;
    };

    template <class T >
    class Linked_list : public Linear_list<T, List_node<T>*>{
     public:
        typedef typename Linear_list<T, List_node<T>*>::value_type value_type;
        typedef typename Linear_list<T, List_node<T>*>::position position;

        Linked_list();
        ~Linked_list();
        void create();
        bool empty() const;
        value_type read(position) const;
        void write(const value_type &, position);
        position begin() const;
        void erase(position);
        void insert(const value_type &, position);
        };

     private:
        List_node<T> * _pHead;
        int _length;
    };

    template <class T>
    Linked_list< T >::Linked_list() {
        _pHead = new List_node<T>;
        _pHead->_pNext = _pHead;
        _pHead->_pPrev = _pHead;
        _length = 0;
    }

    template< class T >
    Linked_list< T >::~Linked_list(){
        while(!empty())
            erase(begin());
        delete _pHead;
    }

    template< class T >
    void Linked_list< T >::create(){
        if (empty())
                _length = 0;
    }

    template< class T >
    bool Linked_list< T >::empty() const {
        return(_pHead == _pHead->_pNext);
    }

    template< class T >
    typename Linked_list< T >::position Linked_list< T >::begin() const {
        return (_pHead->_pNext);
    }

    template< class T >
    typename Linked_list< T >::value_type
    Linked_list< T >::read(position p) const {
        if (!end(p))
            return(p->_value);
    }

  template< class T >
  void Linked_list< T >::write(const value_type &a, position p) {
        if (!end(p))
        p->_value = a;
    }

  template< class T >
  void Linked_list< T >::insert(const value_type &a, position p){
        position t = new List_node<T>;
        t->_value = a;
        t->_pNext = p;
        t->_pPrev = p->_pPrev;
        p->_pPrev->_pNext = t;
        p->_pPrev = t;
        _length++;
    }

template< class T >
void Linked_list< T >::erase(position p){
    if (!empty() && !end(p)){
        p->_pPrev->_pNext = p->_pNext;
        p->_pNext->_pPrev = p->_pPrev;
        delete p;
    }
}

Код celle.h:

#include "linked_list.h"

using std::cout;
using std::endl;
using std::cin;

class grid;

class cell{
public:
    friend class grid;
    cell(int x,int y, bool viva){
        this->x=x;
        this->y=y;
        this->viva=viva;
    }
    ~cell(){};

private:
    int x;
    int y;
    bool viva;
};

class grid{
public:
    grid();
    grid(int,int);
    ~grid(){};
    void insert (cell &);
    void remove (cell &);
    void moveLeft (int x, int y);
    void moveRight (int x, int y);
    void moveDown (int x, int y);
    void moveUpper (int x, int y);
    bool Sorrounded (int x, int y);
    void RemoveSorrounded ();

private:
    Linked_list<cell> cells;
    int rig;
    int col;
};

grid::grid(){
    rig=5;
    col=5;
}

grid::grid(int r, int c){
    rig=r;
    col=c;
}

/*void grid::insert (cell &k){
    if(k.viva){
        cells.insert(k,cells.begin());
    }
}*/

Как я мог решить это? Почему вы говорите мне, что конструктор узла был неявно удален? Я схожу с ума, извините, если я скопировал вам весь код

Answer 1

Когда вы создаете Linked_list с типом cell, это означает, что List_node имеет тип cell. В вашем List_node у вас есть T _value;, в котором хранится значение для cell. Однако cell не имеет конструктора по умолчанию, поскольку вы определили его конструктор как cell(int,int, bool). Это неявно удаляет конструктор по умолчанию в List_node. В вашем методе insert для вашего Linked_list вы делаете position t = new List_node<T>;, который вызывает конструктор по умолчанию, которого не существует.

Простой способ исправить это - иметь конструктор List_node, который принимает значение по ссылке типа T, который используется для конструктора путем копирования необходимого T. Примерно так:

List_node( const T& value ) : _value(value) {}

Тогда в вашем методе вставки вы получите:

position t = new List_node<T>( a );
// t->_value = a; // not needed anymore

Более сложный способ - использовать forward_args для построения на месте. Но в вашем коде достаточно простой копии.