重载+运算符以连接2个双列表

您的operator+甚至还不是一个正确的实现。对于初学者来说，您返回的是对一个局部变量的引用，该变量在退出时超出了作用域，破坏了列表，并给调用者留下了对无效内存的悬空引用。但更糟糕的是，您将局部变量指向输入列表的节点，并操纵这些列表中的各种指针，破坏这两个列表。

operator+需要返回两个输入列表中数据的副本。这意味着为输出列表分配一组全新的节点。

试试类似的东西：

class nod
{
public:
    int data;
    nod *next;
    nod *prev;
    nod(int value = 0) :
        data(value), next(NULL), prev(NULL)
    {
    }
};

class Lista
{
private:
    nod *head;
    nod *tail;
    int size;
public:
    Lista() :
        head(NULL), tail(NULL), size(0)
    {
    }
    Lista(const Lista &src) :
        head(NULL), tail(NULL), size(0)
    {
        *this = src;
    }
    ~Lista()
    {
        Clear();
    }
    void Add(int value)
    {
        node *n = new nod(value);
        n->prev = tail;
        if (!head) head = n;
        if (tail) tail->next = n;
        tail = n;
        ++size;
    }
    void Clear()
    {
        nod *n = head;
        head = tail = NULL;
        size = 0;
        while (n)
        {
            nod *next = n->next;
            delete n;
            n = next;
        }
    }
    Lista& operator=(const Lista &rhs)
    {
        Clear();
        nod *n = rhs.head;
        while (n)
        {
            Add(n->data);
            n = n->next;
        }
        return *this;
    }
    Lista operator+(const Lista &rhs)
    {
        Lista temp;
        nod *n = head;
        while (n)
        {
            temp.Add(n->data);
            n = n->next;
        }
        n = rhs.head;
        while (n)
        {
            temp.Add(n->data);
            n = n->next;
        }
        return temp;
    }
    friend std::istream& operator >>(std::istream &input, Lista &a);
    friend std::ostream& operator <<(std::ostream &output, const Lista &a);
};
std::istream& operator >>(std::istream &input, Lista &a)
{
    // NOTE: this kind of code really does not
    // belong in an 'operator>>' implementation!
    int i, size, data;
    std::cout << "Size of the list: ";
    input >> size;
    for (i = 0; i < size; ++i)
    {
        std::cout << "nNode number " << i + 1 << ": ";
        input >> data;
        a.Add(data);
    }
    return input;
}
std::ostream& operator <<(std::ostream &output, const Lista &a)
{
    output << "nnNormal writing: ";
    nod *n = a.head;
    while (n)
    {
        output << n->data << " ";
        n = n->next;
    }
    n = a.tail;
    output << "nnReverse writing: ";
    while (n)
    {
        output << n->data << " ";
        n = n->prev;
    }
    return output;
}

int main()
{
    Lista a, b, c;
    std::cin >> a;
    std::cin >> b;
    c = a + b;
    std::cout << c;
    return 0;
}

现在，话虽如此，您应该认真摆脱手动链表实现，转而使用STL std::list类，该类管理节点的链表，并知道如何复制自己：

#include <list>
#include <algorithm>
#include <iterator>
class Lista
{
private:
    std::list<int> data;
public:
    void Add(int value)
    {
        data.push_back(value);
    }
    void Clear()
    {
        data.clear();
    }
    Lista operator+(const Lista &rhs)
    {
        Lista temp;
        std::copy(data.begin(), data.end(), std::back_inserter(temp));
        std::copy(rhs.data.begin(), rhs.data.end(), std::back_inserter(temp));
        return temp;
    }
    friend std::istream& operator >>(std::istream &input, Lista &a);
    friend std::ostream& operator <<(std::ostream &output, const Lista &a);
};
std::istream& operator >>(std::istream &input, Lista &a);
{
    // NOTE: this kind of code really does not
    // belong in an 'operator>>' implementation!
    int i, size, data;
    std::cout << "Size of the list: ";
    input >> size;
    for (i = 0; i < size; ++i)
    {
        std::cout << "nNode number " << i + 1 << ": ";
        input >> data;
        a.Add(data);
    }
    return input;
}
std::ostream& operator <<(std::ostream &output, const Lista &a)
{
    output << "nnNormal writing: ";
    for (std::list<int>::const_iterator iter = a.data.begin(), end = a.data.end(); iter != end; ++iter)
    {
        output << *iter << " ";
    }
    output << "nnReverse writing: ";
    for (std::list<int>::const_reverse_iterator iter = a.data.rbegin(), end = a.data.rend(); iter != end; ++iter)
    {
        output << *iter << " ";
    }
    return output;
}