调试断言失败，向量下标超出范围 [英] Debug Assertion Failed, vector subscript out of range

问题描述

我的程序应该在 C++ 中实现线程安全堆栈当我想启动程序时出现错误:

my program should implement a threadsafe stack in c++ I get an error when I want to start the programm:

调试断言失败！...\vector 第 1201 行

Debug assertion Failed! ...\vector Line 1201

表达式:向量下标超出范围

Expression: vector subscript out of range

我完全不知道代码有什么问题

I absolutely don't know what's wrong with the code

#include <condition_variable>
#include <iostream>
#include <memory>
#include <mutex>
#include <thread>
#include <vector>

#define NUM_ELEMENTS 10

using namespace std;

class Stack
{
protected:
    vector<int> stack;
    int topOfStack;    
    int maxSize;
    mutable mutex _mutex;
    mutable condition_variable cv;

public:
    Stack(int size);
    int top() const; 
    int pop(); 
    void push(int element); 

    bool isFull() const;  
    bool isEmpty() const; 
};

Stack::Stack(int size)
{
    stack.reserve(size); 
    maxSize = size;      
    topOfStack = 0;
}

int Stack::top() const
{
    unique_lock<mutex> lck(_mutex);     
    
    // sperren, solange kein Wert da ist
    while (isEmpty())
        cv.wait(lck);

    int val = stack[topOfStack - 1];

    return val;
}

int Stack::pop()
{
    // Kritischer Bereich - sperren
    unique_lock<mutex> lck(_mutex);

    // sperren, solange kein Wert am Stack ist
    while (isEmpty())
        cv.wait(lck);

    // Wert zwischenspeichern und Stack-Pointer -1
    // danach werden wartende Threads benachrichtigt
    topOfStack--;
    int val = stack[topOfStack];
    cv.notify_all();

    return val;
}
void Stack::push(int element)
{
    // Kritischer Bereich - sperren
    unique_lock<mutex> lck(_mutex);

    // sperren, solange der Stack voll ist
    while (isFull())
        cv.wait(lck);

    // Wert speichern und Stack-Pointer +1
    // danach werden wartende Threads benachrichtigt
    stack[topOfStack] = element;
    topOfStack++;
    cv.notify_all();
}
bool Stack::isEmpty() const
{
    return topOfStack == 0;
}
bool Stack::isFull() const
{
    return topOfStack == maxSize;
}

// PRODUCER
class Producer
{
protected:
    shared_ptr<Stack> stack;

public:
    Producer(shared_ptr<Stack> stack);

    void produce(size_t amount);
};

//CONSUMER
class Consumer
{
protected:
    shared_ptr<Stack> stack;

public:
    Consumer(shared_ptr<Stack> stack);

    void consume(size_t amount);
};

Producer::Producer(shared_ptr<Stack> stack)
    : stack(stack)
{}
void Producer::produce(size_t amount)
{
    for (size_t i = 0; i < amount; i++)
    {
        cout << "Produce: " << i << endl;
        stack->push(i);
    }
}

Consumer::Consumer(shared_ptr<Stack> stack)
    : stack(stack)
{}
void Consumer::consume(size_t amount)
{
    for (size_t i = 0; i < amount; i++)
    {
        cout << "Consume: " << stack->pop() << endl;
    }
}

// ////////////////////////////////////////////////////////////////////////////

int main()
{
    shared_ptr<Stack> stack(new Stack(3));

    Producer producer(stack);
    Consumer consumer(stack);

    thread consumerThread(&Consumer::consume, &consumer, NUM_ELEMENTS);
    thread producerThread(&Producer::produce, &producer, NUM_ELEMENTS);

    consumerThread.join();
    producerThread.join();

    return 0;
}

推荐答案

Your vectorstack 成员以 0 大小创建，并永远保持该大小 0.我在您的代码中没有看到任何更改其大小的尝试.难怪对 stack 的任何索引访问都会产生未定义的行为，包括这个超出范围"的错误.

Your vector<int> stack member is created with size 0 and forever maintains that size 0. I don't see any attempts to change its size in your code. No wonder any index access to stack produces undefined behavior, including this "out of range" error.

提示:如果你想改变一个std::vector的大小，相应的方法叫做resize，而不是reserve.后者改变了容量，而不是矢量的大小.

Hint: if you want to change the size of an std::vector, the corresponding method is called resize, not reserve. The latter changes the capacity, not the size of a vector.

这篇关于调试断言失败，向量下标超出范围的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！