List 在C+中统一动态列表+；使用重载运算符

所以，我一直在制作一个链表类，现在我正在尝试制作它，这样两个链表就可以通过简单的a+操作符联合起来。以下是当前代码，整体如下：

#include <iostream>
using namespace std;

// ---/ List Class /--- //

template <class Type>
struct Node {
    Type core;
    Node<Type> *next;
};

template <class Type>
class List {
    public:
        Node<Type> *start, *end;
        unsigned int siz;

        static const int END;

    public:
        // Genesis
        List() {
            start = NULL;
            end = NULL;

            siz = 0;
        };

        // ---
        void push (const Type&, const int&);

        // DEBUG
        void show (void);

        // +-*/
        List operator+ (const List&);
        List& operator= (const List&);
        List& operator+= (const List&);

        // Abbadon
        ~List() {
            delete start;
            delete end;
        };
};

template <class Type>
const int List<Type>::END = -1;

// ---

template <class Type>
void List<Type>::push (const Type& elem, const int& pos = END) {
    Node<Type> *aux;

    aux = new Node<Type>;
    aux->core = elem;

    if (siz == 0) {
        aux->next = NULL;

        start = aux;
        end = aux;
    }
    else {
        if (pos == END) {
            aux->next = NULL;

            end->next = aux;
            end = end->next;
        }
        else if (pos == 0) {
            aux->next = start;

            start = aux;
        }
        else {
            Node<Type> *pesq = start;
            for (int i = 1; (i < pos) && (pesq->next != NULL); i++) {
                pesq = pesq->next;
            }

            aux->next = pesq->next;
            pesq->next = aux;
        }
    }

    siz++;
}

// DEBUG

template <class Type>
void List<Type>::show (void) {
    Node<Type> *pesq = start;
    while (pesq != NULL) {
        cout << pesq->core << endl;
        pesq = pesq->next;
    }

    cin.get();
}

// +-*/

template <class Type>
List<Type> List<Type>::operator+ (const List<Type>& nimda) {
    List<Type> aux = *this;

    aux.end->next = nimda.start;
    aux.end = nimda.end;

    aux.siz += nimda.siz;

    return aux;
}

template <class Type>
List<Type>& List<Type>::operator= (const List<Type>& nimda) {
    if (&nimda != this) {
        start = nimda.start;
        end = nimda.start;
        siz = nimda.siz;
    }
} 

template <class Type>
List<Type>& List<Type>::operator+= (const List<Type>& nimda) {
    *this = *this + nimda;  
    return *this;
}

// ---/ MAIN() /--- //

int main() {
    List<int> adabo;
    List<int> inakos;

    adabo.push(1);
    adabo.push(2);

    inakos.push(3);
    inakos.push(4);

    adabo = adabo + inakos;

    adabo.show();
}

#包括
使用名称空间std；
//--/List类/--//
模板
结构节点{
型芯；
节点*下一步；
};
模板
班级名单{
公众：
节点*开始，*结束；
无符号整数siz；
静态常数int END；
公众：
//起源
列表（）{
start=NULL；
end=NULL；
siz=0；
};
// ---
无效推送（常数类型和，常数整数和）；
//调试
无效显示（无效）；
// +-*/
列表运算符+（常量列表&）；
列表和运算符=（常量列表和）；
列表和运算符+=（常量列表和）；
//阿巴顿
~List（）{
删除开始；
删除结束；
};
};
模板
常量int List:：END=-1；
// ---
模板
无效列表：：推送（常量类型和元素，常量内部和位置=结束）{
节点*aux；
aux=新节点；
辅助->核心=要素；
如果（siz==0）{
aux->next=NULL；
启动=辅助；
结束=辅助；
}
否则{
如果（位置==结束）{
aux->next=NULL；
结束->下一步=辅助；
结束=结束->下一步；
}
否则如果（位置==0）{
辅助->下一步=开始；
启动=辅助；
}
否则{
节点*pesq=开始；
对于（inti=1；（inext！=NULL）；i++）{
pesq=pesq->next；
}
aux->next=pesq->next；
pesq->next=aux；
}
}
siz++；
}
//调试
模板
作废列表：：显示（作废）{
节点*pesq=开始；
while（pesq！=NULL）{
下一步不能取芯；
}
cin.get（）；
}
// +-*/
模板
列表：：运算符+（常量列表和nimda）{
列出aux=*这个；
辅助结束->下一步=nimda.start；
aux.end=nimda.end；
aux.siz+=nimda.siz；
返回aux；
}
模板
列表和列表：：运算符=（常量列表和nimda）{
如果（&nimda！=此）{
start=nimda.start；
end=nimda.start；
siz=nimda.siz；
}
} 
模板
列表和列表：：运算符+=（常量列表和nimda）{
*this=*this+nimda；
归还*这个；
}
//--/MAIN（）/--//
int main（）{
列出阿达博；
列出INAKO；
阿达博推（1）；
阿达波推（2）；
稻谷推（3）；
稻谷推（4）；
阿达博=阿达博+伊纳科斯；
adabo.show（）；
}

以下是重载运算符：

template <class Type>
List<Type> List<Type>::operator+ (const List<Type>& nimda) {
    List<Type> aux = *this;

    aux.end->next = nimda.start;
    aux.end = nimda.end;

    aux.siz += nimda.siz;

    return aux;
}

template <class Type>
List<Type>& List<Type>::operator= (const List<Type>& nimda) {
    if (&nimda != this) {
        start = nimda.start;
        end = nimda.start;
        siz = nimda.siz;
    }
} 

template <class Type>
List<Type>& List<Type>::operator+= (const List<Type>& nimda) {
    *this = *this + nimda;  
    return *this;
}

模板
列表：：运算符+（常量列表和nimda）{
列出aux=*这个；
辅助结束->下一步=nimda.start；
aux.end=nimda.end；
aux.siz+=nimda.siz；
返回aux；
}
模板
列表和列表：：运算符=（常量列表和nimda）{
如果（&nimda！=此）{
start=nimda.start；
end=nimda.start；
siz=nimda.siz；
}
} 
模板
列表和列表：：运算符+=（常量列表和nimda）{
*this=*this+nimda；
归还*这个；
}

以下是用于测试的main（）

// ---/ MAIN() /--- //

int main() {
    List<int> adabo;
    List<int> inakos;
    List<int> foo;

    adabo.push(1);
    adabo.push(2);

    inakos.push(3);
    inakos.push(4);

    foo = adabo + inakos;

    foo.show();
}

/--/MAIN（）/--//
int main（）{
列出阿达博；
列出INAKO；
罗列富；
阿达博推（1）；
阿达波推（2）；
稻谷推（3）；
稻谷推（4）；
foo=adabo+inakos；
foo.show（）；
}

它的输出应该是值1、2、3和4，当我在aux返回之前将show函数放入+运算符时，确实会发生这种情况：

template <class Type>
List<Type> List<Type>::operator+ (const List<Type>& nimda) {
    List<Type> aux = *this;

    aux.end->next = nimda.start;
    aux.end = nimda.end;

    aux.siz += nimda.siz;

    aux.show() // Putting it here shows everything as expected

    return aux;
}

模板
列表：：运算符+（常量列表和nimda）{
列出aux=*这个；
辅助结束->下一步=nimda.start；
aux.end=nimda.end；
aux.siz+=nimda.siz；
aux.show（）//将其放在此处会按预期显示所有内容
返回aux；
}

然而，“aux”似乎在函数返回和main（）中的“foo”接收到的实际值之间的某个位置丢失，导致foo.show（）无限显示随机数据

---

我做错了什么？

没关系，找到问题了

发生的事情是operator=正在对要传递的列表进行“复制”，如果可以这样说的话。“重复”列表在修改时也会修改原始列表，因此在这里

template <class Type>
List<Type> List<Type>::operator+ (const List<Type>& nimda) {
    List<Type> aux = *this; // ...aux, which would become a duplicate of the class...

    aux.end->next = nimda.start;
    aux.end = nimda.end;

    aux.siz += nimda.siz;

    return aux;
} // ...when destructed here, would destruct *this just as well, making all data be lost.

模板
列表：：运算符+（常量列表和nimda）{
List aux=*this；//…aux，它将成为类的副本。。。
辅助结束->下一步=nimda.start；
aux.end=nimda.end；
aux.siz+=nimda.siz；
返回aux；
}//…在这里销毁时，也会销毁*这一点，使所有数据丢失。

为了解决这个问题，与其在重载=

template <class Type>
List<Type>& List<Type>::operator= (const List<Type>& nimda) {
    if (&nimda != this) {
        start = nimda.start;
        end = nimda.start;
        siz = nimda.siz;
    }
} 

模板
列表和列表：：运算符=（常量列表和nimda）{
如果（&nimda！=此）{
start=nimda.start；
end=nimda.start；
siz=nimda.siz；
}
} 

…现在，列表中的每个元素都被一个接一个地复制：

template <class Type>
List<Type>& List<Type>::operator= (const List<Type>& nimda) {
    if (&nimda != this) {
        kill();

        Node<Type> *aux = nimda.start;
        while (aux != NULL) {
            push(aux->core);
            aux = aux->next;
        }
    }
}

模板
列表和列表：：运算符=（常量列表和nimda）{
如果（&nimda！=此）{
杀死（）；
Node*aux=nimda.start；
while（aux！=NULL）{
推送（辅助->核心）；
aux=aux->next；
}
}
}

这样，接收列表就可以获得原始列表中所有元素的副本，而不会变成它自己