C ++十六进制乘法分段错误[关闭]

Question

首先让我说我无权使用调试器，我使用 Nano 作为我的编辑器

目前，我的计算器正在用头撞砖墙（分段错误）。我试图通过我的指针来发现我的问题是什么，但我缺乏经验/知识只让我到目前为止。让我解释一下到目前为止我的程序中的工作原理。目前，我能够将十六进制数字存储在链表中并将它们加在一起。问题来自我的乘法方法。在乘法方法中，leftNode 以某种方式变为 NULL，从而引发分段错误。我想知道leftNode在什么时候变为NULL？

乘法：

LList Calculator::multiply(LList& left, LList& right) {
    LList prodSum;
    listnode *leftNode = (left.next());
    int zeros = 0;
    for(;;) {
        if(leftNode == NULL) break;
        int lval = leftNode->data;
        LList curList;
        for(int i = 0; i < zeros; i++) {
            curList.insertTail(0);
        }
        right.reset();
        listnode *rightNode = (right.next());
        int carry = 0;
        while(rightNode != NULL) {
            int rval = rightNode->data;
            int product = lval * rval + carry;
            carry = product / 16;
            product %= 16;
            curList.insertTail(product);
            rightNode = (right.next());
        }
        while(carry) {
            curList.insertTail(carry % 16);
            carry /= 16;
        }
        prodSum = *add(prodSum, curList);
        leftNode = (left.next()); // eventually causes a segmentation fault
        leftNode->data << endl;
        ++zeros;
    }

    return prodSum;
}

与乘法相关的类：

class listnode {
    public:
        element data;
        listnode * next;
};

class LList {
    private:
        listnode * head;
        listnode * tail;
        listnode * view;

    public:
        LList();
        ~LList();
        void read();
        listnode* next();
        void reset();
        void print();
        void insertTail(element val);
        void clean();

        element deleteHead();
};

class Calculator {
    public:
        Calculator();
        //inline LList* add(LList& left, LList& right); works
        inline LList multiply(LList& left, LList& right);
};

Calculator::Calculator() {

};

其他与遍历节点相关的方法：

listnode* LList::next() {
    listnode* temp = view;
    if(temp != NULL)
        view = view->next;

    if(view == NULL) {
    }
    return temp;
};

void LList::reset() {
    view = head;
}


LList::LList(){
    head = NULL;
    view = NULL;
};

void LList::insertTail(element val) {
    listnode * temp;
    temp = new listnode;
    temp -> data = val;
    temp -> next = NULL;

    if(head == NULL) {
        head = temp;
        view = head;
    }
    else
        tail -> next = temp;
    tail = temp;
};

void LList::clean() {
    while(head != NULL)
        deleteHead();
};

element LList::deleteHead() {
    listnode * temp;
    temp = head;
    head = head -> next;
    delete temp;
    return temp -> data;
};

LList::~LList(){
    delete head;
};

Answer 1

又是我。

在您标记的行之后发生了一个异常：// eventually causes a segmentation fault，似乎有一条部分形成的行用于将leftNode->data 发送到cout，但在通过左侧节点的最后一次迭代中，leftNode = (left.next()); 将设置@ 987654326@ 为 NULL，因此此处的取消​​引用可能会导致错误。

另一个问题是没有为 LList 定义复制构造函数或赋值运算符，因此这一行：prodSum = *add(prodSum, curList); 将为 prodSum 提供一组列表节点，这些节点将在之后立即删除。

但是，LList 的析构函数似乎只删除了头节点，而不是整个列表，所以有一个无效和有效的抓包。

此外，multiply 返回 prodSum，因此缺少复制构造函数会导致类似的情况发生。

我包含了一个似乎可以工作的代码版本。我不得不制作自己的 add 函数，只是因为我在这里看不到它。

我让析构函数删除了 LList 的所有节点。

我标记了默认的复制构造函数和赋值运算符=delete，因为默认实现做错了。

为了按值传递 LList 对象，我添加了一个移动构造函数和一个移动赋值运算符。这些将分配的节点从一个对象传递到另一个对象，并且只允许一个对象保留一组节点，因此您不必担心双重破坏。

#include <iostream>
#include <string>

typedef int element;

class listnode {
    public:
        element data;
        listnode * next;
};

class LList {
        listnode *head, *tail, *view;
    public:
        LList() { head = view = tail = NULL; }
        LList(LList&& src) : head(src.head), tail(src.tail), view(src.view) { src.head = src.tail = src.view = nullptr; }
        LList(const LList&) = delete;
        ~LList() { clean(); }
        LList& operator = (LList&& src) {
            clean();
            /* OK here */
            head = src.head;
            tail = src.tail;
            view = src.view;
            src.head = src.tail = src.view = nullptr;
            return *this;
        }
        LList& operator = (const LList&) = delete;
        listnode* next() {
            listnode* temp = view;
            if(temp) view = view->next;
            return temp;
        }
        void reset() { view = head; }
        void print();
        void insertTail(element val) {
            listnode* temp = new listnode;
            temp->data = val;
            temp->next = NULL;

            if(!head) { view = head = temp; }
            else      { tail->next = temp;  }
            tail = temp;
        }
        void clean() { while(head) deleteHead(); }

        element deleteHead() {
            listnode*  temp = head;
            head = head->next;
            const element data = temp->data;
            delete temp;
            return data;
        }
};

LList add(LList& left, LList& right) {
    LList sum;
    int carry = 0;
    left.reset();
    right.reset();
    for(;;) {
        const listnode* leftNode = left.next();
        const listnode* rightNode = right.next();
        if(!leftNode && !rightNode) break;
        if(leftNode) carry += leftNode->data;
        if(rightNode) carry += rightNode->data;
        sum.insertTail(carry % 16);
        carry /= 16;
    }
    if(carry) sum.insertTail(carry);
    return sum;
}

LList multiply(LList& left, LList& right) {
    LList prodSum;
    listnode *leftNode = left.next();
    int zeros = 0;
    for(;;) {
        if(!leftNode) break;
        int lval = leftNode->data;
        LList curList;
        for(int i = 0; i < zeros; i++) {
            curList.insertTail(0);
        }
        right.reset();
        listnode *rightNode = right.next();
        int carry = 0;
        while(rightNode) {
            int rval = rightNode->data;
            int product = lval * rval + carry;
            carry = product / 16;
            product %= 16;
            curList.insertTail(product);
            rightNode = right.next();
        }
        while(carry) {
            curList.insertTail(carry % 16);
            carry /= 16;
        }
        prodSum = add(prodSum, curList);
        leftNode = left.next(); // eventually causes a segmentation fault
        //std::cout << leftNode->data << std::endl;
        ++zeros;
    }
    return prodSum;
}

LList string_to_list(std::string hex_string) {
    LList list;
    for(size_t i=hex_string.length()-1; i+1; --i) {
        char c = hex_string[i] | 0x20;
        if     (c >= '0' && c <= '9') list.insertTail(c - '0');
        else if(c >= 'a' && c <= 'f') list.insertTail(c - 'a' + 10);
    }
    return list;
}

std::string list_to_string(LList& list) {
    std::string hex_string;
    list.reset();
    for(;;) {
        listnode* node = list.next();
        if(!node) return hex_string;
        static const char digits[] = "0123456789abcdef";
        hex_string = digits[node->data] + hex_string;
    }
}

int main() {
    //LList list = string_to_list("1234aBcd");
    //std::string s = list_to_string(list);
    //std::cout << s << '\n';

    LList left = string_to_list("111");
    LList right = string_to_list("333");
    LList prod = multiply(left, right);
    std::cout << list_to_string(prod) << '\n';
}