我能用这个进程做什么返回-1073741819

Question

我的问题是它的进程返回-1073741819。我该怎么做才能更快地编译它？

#include "Queue.h"
#include <iostream>

Queue::Queue()
{
   topPtr = NULL;
   tailPtr = NULL;
}

bool Queue::isEmpty()
{
  if(topPtr == NULL && tailPtr == NULL)
    return true;
  else
    return false;
}   

void Queue::enqueue(int data)
{
    Node *newNodePtr = new Node;
    newNodePtr->data = data;

    if(topPtr == NULL)
    {
        topPtr = tailPtr = newNodePtr;
        tailPtr->nextPtr = NULL;
    }
    else
    {
        tailPtr->nextPtr = newNodePtr;
        tailPtr = newNodePtr;
        tailPtr->nextPtr = NULL;
    }
}

int Queue::dequeue()
{
    if (isEmpty())
    {
        cout << "empty" <<endl;
    }
    else
    {
        int dataToReturn = topPtr->data;
        Node *nodeToDeletePtr = topPtr;
        dataToReturn = nodeToDeletePtr->nextPtr;
        topPtr = topPtr->nextPtr;
        delete nodeToDeletePtr;

        return dataToReturn;  
    }
}

#ifndef QUEUE_H
#define QUEUE_H

struct Node
{
    int data;
    Node *nextPtr;
};

class Queue
{
public:
    Queue();

    void enqueue(int data);
    int dequeue();
    bool isEmpty();

private:
    Node *topPtr;
    Node *tailPtr;
};

#endif

#include <iostream>
#include <string.h>
#include <cstdlib>
#include "Queue.h"

using namespace std;

int main(int argc, char const *argv[])
{
    Queue integers;
    string seriesIntegers;

    cout << "Enter integers: ";
    getline(cin, seriesIntegers);
    char *seriesIntegersCStr = new char[seriesIntegers.length() + 1];
    strcpy(seriesIntegersCStr, seriesIntegers.c_str());
    char *tokens = strtok(seriesIntegersCStr, " ");

    while(tokens != NULL)
    {
        integers.enqueue(atoi(tokens));
        tokens = strtok(NULL, " ");
    }

    while(!integers.isEmpty())
    {
        cout << " " << integers.dequeue() << "\n";
    }
}

Answer 1

其中一些错误：

• 在清空队列的出队操作期间，您永远不会将 tailPtr 重置为 null。
• 由于第一项，您的isEmpty 成员错误地报告队列仍然有数据，因为两个条件之一 (tailPtr == nullptr) 不正确，因此即使队列不是“空的”是。
• 由于上述两项，main 中的 while 循环超出了队列的末尾。
• 您的出队操作有一个不返回值的主要控制路径，尽管您在返回声明中承诺-int 会这样做。至少这应该引发异常；理想情况下，一开始就不允许这样做。
• Queue 应该在销毁时自我清理，而不是在非空状态下泄漏节点链。
• 作为一个添加自定义析构函数来清理动态内容的过程，Queue 应该符合rule-of-three 的要求，方法是为 copy-ctor 和赋值运算符定义正确的操作，或者将它们指定为已删除（如下所示）

修复所有这些问题，并进行一些其他修改，包括进入现代 C++ 的现实世界以利用字符串流读取整数，而不是像以前那样使用 strtok 和泄漏内存，请参见下面的代码：

#include <iostream>
#include <sstream>
#include <string>

struct Node
{
    int data;
    Node *nextPtr;

    Node(int val, Node *next = nullptr)
        : data(val)
        , nextPtr(next)
    {
    }
};

class Queue
{
public:
    Queue();
    virtual ~Queue();

    Queue(const Queue&) = delete;
    Queue& operator =(const Queue&) = delete;

    void enqueue(int data);
    int dequeue();
    bool isEmpty() const;

private:
    Node *topPtr;
    Node *tailPtr;
};

Queue::Queue()
    : topPtr(nullptr)
    , tailPtr(nullptr)
{
}

Queue::~Queue()
{
    while (topPtr)
        dequeue();
}

bool Queue::isEmpty() const
{
    return topPtr == nullptr;
}

void Queue::enqueue(int data)
{
    Node *newNodePtr = new Node(data);

    if (topPtr == NULL)
    {
        topPtr = newNodePtr;
    }
    else
    {
        tailPtr->nextPtr = newNodePtr;
    }
    tailPtr = newNodePtr;
}

int Queue::dequeue()
{
    if (isEmpty())
    {
        throw std::runtime_error("'dequeue' called on an already-empty queue");
    }

    // get top data
    int dataToReturn = topPtr->data;

    // advance top, retaining pointer to old node
    Node *tmp = topPtr;
    topPtr = topPtr->nextPtr;

    // now delete the node
    delete tmp;

    // and reset tail if top hit end-of-queue
    if (topPtr == nullptr)
        tailPtr = nullptr;

    // finally, return data
    return dataToReturn;
}

int main()
{
    std::cout << "Enter integers: ";
    std::string line;
    if (getline(std::cin, line) && !line.empty())
    {
        Queue integers;
        std::istringstream iss(line);
        int value;
        while (iss >> value)
            integers.enqueue(value);

        while (!integers.isEmpty())
            std::cout << integers.dequeue() << '\n';
    }
}

输入

1 2 3 4 5

输出

Enter integers: 1 2 3 4 5
1
2
3
4
5