C++ C++&引用；没有合适的默认构造函数可用“；

我正在尝试创建一个数组的链接列表，而不使用STL。但是，我很难将数组传递到我的链接列表

当我编译时，我得到上面列出的错误。我需要如何将数组传递到链接列表？谢谢（有问题的代码标记为**，如果正在测试，请删除。）

SingleLinkedList.h

#pragma once 

#ifndef SinglyLinkedList_h
#define SinglyLinkedList_h

#include<iostream>

template <typename Type>
struct node
{

    Type value;
    node *next;
};

template <typename Object>
class SinglyLinkedList
{

private:
    node<Object> *head;

public:
    SinglyLinkedList();
    ~SinglyLinkedList();
    bool insert(Object x);
    bool empty();
};

template <typename Object>
SinglyLinkedList<Object>::SinglyLinkedList()
{
    this->head = NULL;
}

template <typename Object>
bool SinglyLinkedList<Object>::insert(Object x)
{
    node<Object> *temp = new node<Object>;
    temp->value = x;
    temp->next = NULL;

    if (this->head==NULL)
    {
        this->head = temp;
    }
    else
    {
        node<Object> *S = this->head, *P = S;

        while ((S->value < temp->value)&&(S != NULL))
        {
            S = S->next;
            P = S;
        }
        if(S == NULL)
            temp->next = P;
        else
        {
            temp->next = S;
            P->next = temp;
        }
    }
    return true;
}

template <typename Object>
bool SinglyLinkedList<Object>::empty()
{
    if(this->head == NULL)
        return true;
    else
        return false;
}

template <typename Object>
SinglyLinkedList<Object>::~SinglyLinkedList()
{
    delete this->head;
}

#endif

#pragma一次
#ifndef SinglyLinkedList\u h
#定义单个链接列表
#包括
模板
结构节点
{
类型值；
节点*下一步；
};
模板
类单链接列表
{
私人：
节点*头；
公众：
SingleLinkedList（）；
~SinglyLinkedList（）；
布尔插入（对象x）；
bool empty（）；
};
模板
SinglyLinkedList:：SinglyLinkedList（）
{
此->头=空；
}
模板
bool SinglyLinkedList:：insert（对象x）
{
node*temp=新节点；
温度->值=x；
temp->next=NULL；
如果（此->头==NULL）
{
这个->头=温度；
}
其他的
{
节点*S=this->head，*P=S；
而（（S->valuevalue）&&（S！=NULL））
{
S=S->next；
P=S；
}
如果（S==NULL）
温度->下一步=P；
其他的
{
温度->下一步=S；
P->next=温度；
}
}
返回true；
}
模板
bool SinglyLinkedList:：empty（）
{
如果（此->头==NULL）
返回true；
其他的
返回false；
}
模板
SinglyLinkedList:：~SinglyLinkedList（）
{
删除此->标题；
}
#恩迪夫

动态类

#pragma once

#ifndef DynamicArrayClass_h
#define DynamicArrayClass_h
#include<iostream>

template <class T>
class DynamicArrayClass
{
private:
    T *array;
    int size, numItems;

public:
    DynamicArrayClass(int newSize)
    {
        size = newSize;
        numItems=0;
        array = new T[size];
    }

    int GetSize(){ return size;}
    int GetNumItems() const { return numItems; }
    bool isEmpty() const { return numItems==0; }
    bool isFull() const { return numItems==size; }
    bool addItem (const T &object)
    {
        if(isFull())
        {
            return false;
        }
        else
        {
            array[numItems++] = object;
            return true;
        }
    }
    const T& getItem(int index) {return array[index];}
    void makeEmpty()
    {
        numItems = 0;
    }

    ~DynamicArrayClass()
    {
        if(array !NULL)
            delete [] array;
    }   


};

#endif

#pragma一次
#ifndef动态卡雷等级h
#定义动态类
#包括
模板
类动态CarrayClass
{
私人：
T*阵列；
整数大小，numItems；
公众：
DynamicArrayClass（int newSize）
{
大小=新闻大小；
numItems=0；
数组=新的T[大小]；
}
int GetSize（）{return size；}
int GetNumItems（）常量{return numItems；}
bool isEmpty（）常量{return numItems==0；}
bool isFull（）常量{return numItems==size；}
布尔附加项（常量T和对象）
{
如果（isFull（））
{
返回false；
}
其他的
{
数组[numItems++]=对象；
返回true；
}
}
常量T&getItem（int-index）{返回数组[index]；}
void makeEmpty（）
{
numItems=0；
}
~z~动态类（）
{
if（数组！NULL）
删除[]数组；
}   
};
#恩迪夫

main.cpp

#include "DynamicArrayClass.h"
#include "SinglyLinkedList.h"
#include "stopwatch.h"

#include<iostream>

int main()
{
    int totalCapacity = 0;
    int arrayAddSize = 0;
    while(totalCapacity < 10000)
    {
        if(totalCapacity==0)
        {
            DynamicArrayClass<int> *array1 = new DynamicArrayClass<int>(25);
            totalCapacity = 25;
            SinglyLinkedList<DynamicArrayClass<int>> *list = new SinglyLinkedList<DynamicArrayClass<int>>();

            for(int i = 0; i<25; i++)
            {
                array1->addItem(1); 
            }       
            **list->insert(*array1);**
        }
        else
        {
            arrayAddSize = (totalCapacity/2);
            totalCapacity = totalCapacity + arrayAddSize;
            DynamicArrayClass<int> *array = new DynamicArrayClass<int>(arrayAddSize);
            SinglyLinkedList<DynamicArrayClass<int>> *list = new SinglyLinkedList<DynamicArrayClass<int>>();
            for(int i=0; i <arrayAddSize; i++)
            {
                array->addItem(1);
            }
        }

    }
    return 0;
}

#包括“DynamicArrayClass.h”
#包括“SingleLinkedList.h”
#包括“秒表.h”
#包括
int main（）
{
整数总容量=0；
int arrayAddSize=0；
同时（总容量<10000）
{
如果（总容量==0）
{
DynamicCarrayClass*array1=新的DynamicCarrayClass（25）；
总容量=25；
SinglyLinkedList*列表=新建SinglyLinkedList（）；
对于（int i=0；iaddItem（1）；
}       
**列表->插入（*array1）**
}
其他的
{
arrayAddSize=（总容量/2）；
总容量=总容量+阵列大小；
DynamicArrayClass*数组=新的DynamicArrayClass（arrayAddSize）；
SinglyLinkedList*列表=新建SinglyLinkedList（）；
对于（int i=0；i addItem（1）；
}
}
}
返回0；
}
问题出在插入的这一部分中：

node<Object> *temp = new node<Object>;

该
类型值；
将由
新节点
调用默认构造。为
节点
结构提供一个合适的构造函数，您应该会很好。
有很多代码要转储到我们身上，但是+1用于在未被要求的情况下使用家庭作业标记。
node<Object> *temp = new node<Object>(x, NULL);

node<Object> *temp = new node<Object>;

template <typename Type>
struct node
{
    Type value;
    node *next;
};