Debug Assertionsfehler, Vektor-Index außerhalb des zulässigen Bereichs

Question

mein Programm einen Thread-Stapel in c implementieren sollte ++ ich eine Fehlermeldung erhalten, wenn ich das Programm gestartet werden soll:

Debug Assertion Failed! ... \ Vektor Linie 1201

Expression: Vektor-Index außerhalb des zulässigen Bereichs

ich absolut nicht weiß, was mit dem Code falsch

#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; 
} 

Answer 1

Ihr vector<int> stack Mitglied mit der Größe erstellt wird 0 und hält für immer diese Größe 0. Ich sehe keine Versuche, die Größe Ihres Codes zu ändern. Kein Wunder, dass jeder Indexzugriff auf stack zu undefiniertem Verhalten führt, einschließlich dieses Fehlers "außerhalb des Bereichs".

Hinweis: Wenn Sie die Größe einer std::vector ändern möchten, heißt die entsprechende Methode resize, nicht reserve. Letzteres ändert die Kapazität, nicht die Größe eines Vektors.