.exe 触发了断点，并且到处抛出异常答案

【问题标题】：.exe has triggered a breakpoint and exception thrown everywhere.exe 触发了断点，并且到处抛出异常
【发布时间】：2021-04-14 12:33:08
【问题描述】：

希望你们一切都好我正在做一项任务，我已经被困在这里很久了，我的代码中没有错误或警告我不知道有什么问题。我会很感激帮助我检查了所有指针和 null 相关的东西，但我仍然无法找出问题所在

#pragma once
#include<iostream>
using namespace std;

struct Node {
public:
    int coefficient;
    int power;
    Node* Next;
    int getcoefficient()
    {
        return this->coefficient;
    }
    int getpower()
    {
        return this->power;
    }
};
class Polynomial {
private:
    Node* Head;
    Node* Tail;
public:
    Polynomial();
    int getco();
    int getpow();
    Polynomial(int arraycoefficients[], int arraypower[], int n);
    ~Polynomial();
    void insert(int coefficient1, int power1);
    void remove(int power1);
    double Evaluate(double value);
    Polynomial operator+(Polynomial O2);
    /*Polynomial& operator=(Polynomial& p);*/
    int degree()const;
    void merge(Polynomial p);
    void removeAll();
    friend istream& operator>>(istream& in, Polynomial& P);
    friend ostream& operator<<(ostream& out, const Polynomial& P);
};

这是头文件的cpp

#include "Polynomial.h"
#include<math.h>
#include <iostream>
using namespace std;
Polynomial::Polynomial()
{
    Head = Tail = NULL;
}
int Polynomial::getco()
{
    return Head->coefficient;
}
int Polynomial::getpow()
{
    return Head->power;
}
Polynomial::Polynomial(int arraycoefficients[], int arraypower[], int n)
{
    Head = NULL;
    Tail = NULL;
    for (int i = 0; i < n; i++) {
        insert(arraycoefficients[i], arraypower[i]);
    }
}

Polynomial::~Polynomial()
{

    removeAll();
}

void Polynomial::insert(int coefficient1, int power1)
{
    Node* node = new Node;
    node->coefficient = coefficient1;
    node->power = power1;
    node->Next = NULL;

    if (Head == NULL) {
        Head = Tail = node;
        return;
    }
    //addition at head
    if (power1 == Head->power) {
        Head->coefficient = Head->coefficient + coefficient1;
        return;
    }
    //insert at head
    if (power1 < Head->power) {
        node->Next = Head;
        Head = node;
        return;
    }
    Node* temporary = Head;
    while (temporary->Next != NULL) {
        if (temporary->power == power1) {
            temporary->coefficient = temporary->coefficient + coefficient1;
            return;
        }
        if (power1 > temporary->power && power1 < temporary->Next->power) {
            node->Next = temporary->Next;
            temporary->Next = node;
            return;
        }
        temporary = temporary->Next;
    }
    //insert at last
    if (temporary->power == power1) {
        temporary->coefficient = temporary->coefficient + coefficient1;
        return;
    }
    temporary->Next = node;
    Tail = node;
}

void Polynomial::remove(int pw)
{
    if (Head == NULL)
        return;
    //only one node
    if (Head->power == pw && Head == Tail) {
        delete Head;
        Head = Tail = NULL;
        return;
    }

    Node* temporary = Head;
    while (temporary->Next != NULL) {
        if (pw == temporary->Next->power) 
        {
            Node* node = temporary->Next;
            temporary->Next = temporary->Next->Next;
            if (temporary->Next == NULL)
                Tail = temporary;
            delete node;
            return;
        }
        temporary = temporary->Next;
    }
}

double Polynomial::Evaluate(double value)
{
    Node* temporary = Head;
    double result = 0.0;
    while (temporary != NULL) {
        result =result+ (temporary->coefficient * pow(value, temporary->power));
        temporary = temporary->Next;
    }
    return result;
}

/*Polynomial& Polynomial::operator=(Polynomial& p)
{
    Node* temporary = p.Head;
    int pp;
    int cc;
    removeAll();
    while (temporary != nullptr) {
        pp = temporary->getpower();
        cc = temporary->getcoefficient();
        insert(cc,pp);
        temporary = temporary->Next;
    }
    return *this;
}*/

int Polynomial::degree() const
{
    if (Head == NULL)
    {
        cout << "Empty polynomial\n";
        return -1;
    }
    return Tail->power;
}

void Polynomial::merge(Polynomial p)
{
    int count = 0;
    Node* temporary = p.Head;
    while (temporary != NULL) {
        insert(temporary->coefficient, temporary->power);
        temporary = temporary->Next;
    }
    p.removeAll();
    return;
}

void Polynomial::removeAll()
{
    if (Head == NULL)
        return;
    Node* CurrentNode = Head;
    Node* NextNode = NULL;

    while (CurrentNode != NULL)
    {
        NextNode = CurrentNode->Next;
        delete CurrentNode;
        CurrentNode = NextNode;
    }
    Head = Tail = NULL;
}
istream& operator>>(istream& in, Polynomial& P)
{
    int num;
    cout << "Please enter number of nodes\n";
    cin >> num;
    int c, p;
    for (int i = 0; i < num; i++)
    {
        cout << "Please enter the pair of (coefficient,power)\n";
        in >> c >> p;
        P.insert(c, p);
    }
    return in;
}

ostream& operator<<(ostream& out, const Polynomial& P)
{
    Node* temporary = P.Head;
    if (temporary == NULL)
    {
        out << "Empty polynomial\n";
        return out;
    }
    
    else  {
        out << "Polynomial is:\n";
        while (temporary != NULL) {
            if (temporary->power == 0)
                out << temporary->coefficient << " + ";
            else if (temporary->Next == NULL)
                out << temporary->coefficient << "x^" << temporary->power;
            else
                out << temporary->coefficient << "x^" << temporary->power << " + ";
            temporary = temporary->Next;
        }
    }
    out << endl;
    return out;
}
//Polynomial operator+(Polynomial& p1, Polynomial& p2)
Polynomial Polynomial::operator+(Polynomial O2)
{
    Polynomial SumOfPolies;
    Node* temporary = Head;
    while (temporary != NULL) {
        SumOfPolies.insert(temporary->coefficient, temporary->power);
        temporary = temporary->Next;
    }
    temporary = O2.Head;
    while (temporary != NULL) {
        SumOfPolies.insert(temporary->coefficient, temporary->power);
        temporary = temporary->Next;
    }
    return SumOfPolies;
}

这是主要的

#include <iostream>
#include "Polynomial.h"
using namespace std;
int main()
{

    int X[] = { 2,4,1,3,5 };
    int Z[] = { 1,2,0,3,4 };
    Polynomial F1(X, Z, 5);
    cout << F1 << endl;
    cout << F1.degree() << endl;
    Polynomial F2;
    F2.insert(3, 2);
    F2.insert(1, 6);
    F2.insert(2, 7);
    cout << F2 << endl;
    Polynomial F3;
    cout << "Here\n";
    F3 = F1 + F2;
    cout << "Here\n";
    cout << F3;
    return 0;
}

【问题讨论】：

流提取 (>>) 不应该与用户交互。考虑一下如果你从一个文件中读取 1000 个多项式会发生什么——你真的想先输入节点的数量，然后看着一堆提示滚动显示吗？
你需要阅读“三法则”和深拷贝的概念。

标签： c++ exception linked-list

【解决方案1】：

恕我直言，是时候学习使用调试器了。

但如果我不得不猜测的话，我会说到目前为止我在你的代码中看到的最可疑的部分是这条指令：

    return SumOfPolies;

在Polynomial Polynomial::operator+(Polynomial O2).

有了这个return，程序就会复制一个局部变量SumOfPolies。但是，您没有为 Polynomial 类提供复制构造函数，因此编译器会逐个成员创建默认副本。这意味着应返回的复制对象与SumOfPolies 共享相同的Nodes 列表。但是SumOfPolies 将在之后立即被销毁，因为这只是从方法返回——并且在析构函数中，如果将删除其所有Nodes，从而使返回副本中的Head 和Tail 指针无效。

还有其他错误和不完美之处，与你现在的经历无关。

例如，您在insert 方法中创建了一个新的Node 对象，即使如果power1 == Head->power 可能没有必要，但您不删除它，并且废弃的Node 对象将永远保留在内存中（或者更确切地说，直到您的程序终止）。

您将NULL 和nullptr 混合使用。

您还声明了一些不需要的变量。例如，在removeAll() 中，NextNode 在函数范围内不是必需的，它可以很好地在循环中定义。您也可以删除CurrentNode：

void Polynomial::removeAll()
{
    while (Head != NULL)
    {
        Node* NextNode = Head->Next;
        delete Head;
        Head = NextNode;
    }
    Tail = NULL;
}

您也可以使用Tail 成员放弃。据我所知，您需要在程序的七个地方初始化或修改它，但您只在两个地方使用它——您可以轻松地在两个地方都摆脱它！

一个在remove(int pw) 中，您将Tail 与Head 进行比较以检查列表是否仅为单个节点。请注意，这可以通过测试 Head->Next == NULL 来完成。
另一个在degree()，需要访问最高功率节点。但是你可以测试Head节点，只要你颠倒存储权力的顺序。
通过这个简单的更改，您将简化九段代码！我想这值得将一个< 和两个> 运算符的方向颠倒过来。

【讨论】：

看看我放的照片（编辑了帖子），我已经声明了一个复制构造函数，但我仍然不知道每次使用 F3=F2+1; 时是什么让这段代码变得疯狂；
您在访问this->Head 指示的内存位置时收到一条明确的消息：“读取访问冲突”。您使用尚未构造的*this 对象的Head 成员。你期望它有什么有意义的价值？
此外，屏幕截图上可见的代码确实NOT复制列表，所以——尽管你使用未初始化变量（Head）引入了新错误——程序仍然容易出错到我描述的错误。

【解决方案2】：

您需要一个如下所示的复制构造函数：

Polynomial::Polynomial(Polynomial const& other)
{
   Node* head = other.Head;
   while (head != nullptr)
   {
      insert(head->coefficient, head->power);
      head = head->Next;
   }
}

当您提供用户定义的实现时，您还应该实现复制赋值运算符、移动构造函数和移动赋值运算符。请参阅五法则和零法则：https://en.cppreference.com/w/cpp/language/rule_of_three。

【讨论】：