C++ vector segmentation fault causes crash if vector is called - c++

Question

I am new and really unexperienced with coding, but we got a task at the university where I ran into a problem I could not solve by myself. In one class a vector causes a problem I do not understand. After hours of trial and error I am a bit tired of guessing... So, I try it here and hope for some help.
The program is supposed to draw an diagram based on some Input variables the user can change. At the moment I am trying to implement the painting of the graph. The Input and the calculation of the data works.
One aspect of the task is that we have to safe the calculated data in a vector and pass this vector as a pointer to other functions, for example the painter.
Now, here the problem occures. Any interaction with the vector m_punkte I passed to paintEvent causes a crash of the program. I could narrow the problem down to commands like: vector->begin() or vector->end(). In the instant the program tries to execute them, windows stops the program.
At first I thought the vector could be somehow passed wrong and I am trying to call an empty vector or the address is undefined, but even commands like vector->emty() causing the crash. So I believe it is a more general error which is caused by the framework or something like that.
After running the debugging tool, it also told me that the error is caused by the mentioned commands and further more told me this:
Der Prozess wurde wegen eines Signals vom Betriebssystem angehalten.
Name des Signals : SIGSEGV
Bedeutung : Segmentation fault
I guess that's some kind of memory problem, right?
I would be really happy if someone could help me, so I can work again on the actual task and not guessing why this vector is somehow broken
What I can also tell is that I am working with Qt Creator and the program is running as an QtWidget program if that helps.
Dropbox link to a copy of the programm:
https://www.dropbox.com/sh/l5e220lk5y7jx2z/AAAdG7AjHiiKJxOKWT-zrP8ia?dl=0
I Hope now my question is clear and this helps more to find the origin of the error.
datenpunkt.h
#ifndef DATENPUNKT_H
#define DATENPUNKT_H
#include <vector>
struct datenpunkt
{
float temperatur;
float widerstand;
float laenge;
};
typedef std::vector<datenpunkt> PunktVektor;
#endif // DATENPUNKT_H
diagrammwidget.h
#ifndef DIAGRAMMWIDGET_H
#define DIAGRAMMWIDGET_H
#include "datenpunkt.h"
#include <QWidget>
namespace Ui {
class DiagrammWidget;
}
class DiagrammWidget : public QWidget
{
Q_OBJECT
public:
explicit DiagrammWidget( QWidget *parent = 0);
~DiagrammWidget();
void setPunkte (PunktVektor *punkte);
void setUntere_temp(int untere_temp);
void setObere_temp(int obere_temp);
void setAufloesung(int aufloesung);
PunktVektor *punkte() const;
protected:
void paintEvent(QPaintEvent *event);
private:
Ui::DiagrammWidget *ui;
PunktVektor *m_punkte;
int m_untere_temp = 0;
int m_obere_temp = 0;
int m_aufloesung = 0;
};
#endif // DIAGRAMMWIDGET_H
dialog.h
#ifndef DIALOG_H
#define DIALOG_H
#include "datenpunkt.h"
#include <string.h>
#include <QDialog>
#include <QString>
namespace Ui {
class Dialog;
}
class Dialog : public QDialog
{
Q_OBJECT
public:
explicit Dialog(QWidget *parent = 0);
~Dialog();
void werteberechnung(PunktVektor *m_PunktListe);
float untere_temp() const;
void setUntere_temp(float untere_temp);
float obere_temp() const;
void setObere_temp(float obere_temp);
int aufloesung() const;
void setAufloesung(int aufloesung);
QString werkstoff() const;
void setWerkstoff(QString werkstoff);
float materialkonstante() const;
void setMaterialkonstante(float materialkonstante);
float bezugswiderstand() const;
void setBezugswiderstand(float bezugswiderstand);
float wiederstand() const;
void setWiederstand(float wiederstand);
float temperatur() const;
void setTemperatur(float temperatur);
private slots:
void on_speichern_clicked();
void on_verwerfen_clicked();
void on_zuruecksetzen_clicked();
private:
Ui::Dialog *ui;
PunktVektor *m_PunktListe;
QString m_werkstoff = "A 34-2/30 (SIEMENS)";
float m_materialkonstante = 3440; // B/ K
float m_bezugswiderstand = 5000; // Rto/ Ohm
float m_untere_temp = 0 + 272.15;
float m_obere_temp = 300 + 272.15;
int m_aufloesung = 10;
float m_RT= 0; // Rt/ Ohm
float m_To = 20 + 272.15;
float m_T = 0; // T/ C°
float m_UD; //Untere Dekadengrenze
float m_OD; //Obere Dekadengrenze
};
#endif // DIALOG_H
diagrammwidget.cpp
#include "diagrammwidget.h"
#include "ui_diagrammwidget.h"
#include "datenpunkt.h"
#include <vector>
#include <QtCore>
#include <QtGui>
DiagrammWidget::DiagrammWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::DiagrammWidget){
ui->setupUi(this);
m_punkte = 0;
}
DiagrammWidget::~DiagrammWidget(){
delete ui;
}
void DiagrammWidget::setPunkte(PunktVektor *punkte){
m_punkte = punkte;
}
void DiagrammWidget::paintEvent(QPaintEvent *event)
{
QPainter myPainter (this);
/*if((m_punkte == 0|| m_punkte->size() == 0)){
myPainter.drawText(100,100,"No Points found!");
return;
}*/
datenpunkt ersterPunkt=*m_punkte->begin();
datenpunkt startPunkt = ersterPunkt;
PunktVektor::iterator it;
for( it = m_punkte->begin()++; it != m_punkte->end(); it++){
datenpunkt p = *it;
myPainter.drawLine(startPunkt.temperatur,startPunkt.laenge,
p.temperatur,p.laenge);
startPunkt = p;
}
}
PunktVektor *DiagrammWidget::punkte() const{
return m_punkte;
}
void DiagrammWidget::setAufloesung(int aufloesung){
m_aufloesung = aufloesung;
}
void DiagrammWidget::setObere_temp(int obere_temp){
m_obere_temp = obere_temp;
}
void DiagrammWidget::setUntere_temp(int untere_temp){
m_untere_temp = untere_temp;
}
dialog.cpp
#include "dialog.h"
#include "ui_dialog.h"
#include "datenpunkt.h"
#include "diagrammwidget.h"
#include <QtCore>
#include <QtGui>
#include <QString>
#include <math.h>
#include <iostream>
using namespace std;
Dialog::Dialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::Dialog)
{
ui->setupUi(this);
m_PunktListe = new PunktVektor;
//Standarteinstellungen
ui->werkstoff->setText("A 34-2/30 (SIEMENS)");
ui->materialkonstante->setValue(3440);
ui->materialkonstante->setSuffix(" K");
ui->bezugswiderstand->setValue(5000);
ui->bezugswiderstand->setSuffix(" Ω");
ui->unteretemperatur->setValue(0);
ui->unteretemperatur->setSuffix(" °C");
ui->oberetemperatur->setValue(300);
ui->oberetemperatur->setSuffix(" °C");
ui->aufloesung->setValue(10);
ui->aufloesung->setSuffix(" Δ°C");
ui->unteretemperatur->setMaximum(ui->oberetemperatur->value());
ui->oberetemperatur->setMinimum(ui->unteretemperatur->value());
ui->unteretemperatur->setSingleStep(ui->aufloesung->value());
ui->oberetemperatur->setSingleStep(ui->aufloesung->value());
werteberechnung(m_PunktListe);
//Diagramm aktualisieren und Anzeigen
DiagrammWidget dg;
dg.setUntere_temp(m_untere_temp);
dg.setObere_temp(m_obere_temp);
dg.setAufloesung(m_aufloesung);
dg.setPunkte(m_PunktListe);
dg.show();
}
Dialog::~Dialog()
{
delete m_PunktListe;
delete ui;
}
void Dialog::werteberechnung(PunktVektor *m_PunktListe)
{
datenpunkt p;
float temp = m_untere_temp;
//Anzahl der zu bestimmenden Datenpunkte
int anzahl = (m_obere_temp-m_untere_temp)/m_aufloesung;
//Bestimmen der Dekadengrenzen UD und OD
m_RT = m_bezugswiderstand * pow(M_E, (m_materialkonstante*
((1/m_obere_temp)-(1/m_To))));
m_UD = (int(log10(m_RT)));
m_RT = m_bezugswiderstand * pow(M_E, (m_materialkonstante*
((1/m_untere_temp)-(1/m_To))));
m_OD = (int(log10(m_RT))+1);
//Füllen des Datenvectors
for (int i = 0; i <= anzahl; i++){
m_RT = m_bezugswiderstand * pow(M_E, (m_materialkonstante*
((1/temp)-(1/m_To))));
p.widerstand = m_RT;
p.temperatur = temp;
float x = log10(m_RT);
if(m_UD != 0){
p.laenge = ((x-m_UD)*5);
}
else
p.laenge = x*5;
m_PunktListe->push_back(p);
temp = temp + m_aufloesung;
}
}
void Dialog::on_speichern_clicked()
{
setWerkstoff(ui->werkstoff->text());
setMaterialkonstante(ui->materialkonstante->value());
setBezugswiderstand(ui->bezugswiderstand->value());
setUntere_temp(ui->unteretemperatur->value()+ 272.15);
setObere_temp(ui->oberetemperatur->value()+ 272.15);
setAufloesung(ui->aufloesung->value());
ui->unteretemperatur->setMaximum(ui->oberetemperatur->value());
ui->oberetemperatur->setMinimum(ui->unteretemperatur->value());
ui->unteretemperatur->setSingleStep(ui->aufloesung->value());
ui->oberetemperatur->setSingleStep(ui->aufloesung->value());
//Berechnung des Datenvectors
werteberechnung(m_PunktListe);
//Diagramm aktualisieren
DiagrammWidget dg;
dg.setUntere_temp(m_untere_temp);
dg.setObere_temp(m_obere_temp);
dg.setAufloesung(m_aufloesung);
dg.setPunkte(m_PunktListe);
dg.show();
}
float Dialog::temperatur() const{
return m_T;
}
void Dialog::setTemperatur(float temperatur){
m_T = temperatur;
}
float Dialog::wiederstand() const{
return m_RT;
}
void Dialog::setWiederstand(float wiederstand){
m_RT = wiederstand;
}
float Dialog::bezugswiderstand() const{
return m_bezugswiderstand;
}
void Dialog::setBezugswiderstand(float bezugswiderstand){
m_bezugswiderstand = bezugswiderstand;
}
float Dialog::materialkonstante() const{
return m_materialkonstante;
}
void Dialog::setMaterialkonstante(float materialkonstante){
m_materialkonstante = materialkonstante;
}
QString Dialog::werkstoff() const{
return m_werkstoff;
}
void Dialog::setWerkstoff(QString werkstoff){
m_werkstoff = werkstoff;
}
int Dialog::aufloesung() const{
return m_aufloesung;
}
void Dialog::setAufloesung(int aufloesung){
m_aufloesung = aufloesung;
}
float Dialog::obere_temp() const{
return m_obere_temp;
}
void Dialog::setObere_temp(float obere_temp){
m_obere_temp = obere_temp;
}
float Dialog::untere_temp() const
{
return m_untere_temp;
}
void Dialog::setUntere_temp(float untere_temp)
{
m_untere_temp = untere_temp;
}
void Dialog::on_verwerfen_clicked()
{
ui->werkstoff->setText(m_werkstoff);
ui->materialkonstante->setValue(m_materialkonstante);
ui->bezugswiderstand->setValue(m_bezugswiderstand);
ui->unteretemperatur->setValue(m_untere_temp);
ui->oberetemperatur->setValue(m_obere_temp);
ui->aufloesung->setValue(m_aufloesung);
ui->unteretemperatur->setMaximum(ui->oberetemperatur->value());
ui->oberetemperatur->setMinimum(ui->unteretemperatur->value());
ui->unteretemperatur->setSingleStep(ui->aufloesung->value());
ui->oberetemperatur->setSingleStep(ui->aufloesung->value());
}
void Dialog::on_zuruecksetzen_clicked()
{
//Standarteinstellungen
ui->werkstoff->setText("A 34-2/30 (SIEMENS)");
ui->materialkonstante->setValue(3440);
ui->bezugswiderstand->setValue(5000);
ui->unteretemperatur->setValue(0);
ui->aufloesung->setValue(10);
ui->oberetemperatur->setValue(300);
setWerkstoff(ui->werkstoff->text());
setMaterialkonstante(ui->materialkonstante->value());
setBezugswiderstand(ui->bezugswiderstand->value());
setUntere_temp(ui->unteretemperatur->value()+ 272.15);
setObere_temp(ui->oberetemperatur->value()+ 272.15);
setAufloesung(ui->aufloesung->value());
ui->unteretemperatur->setMaximum(ui->oberetemperatur->value());
ui->oberetemperatur->setMinimum(ui->unteretemperatur->value());
ui->unteretemperatur->setSingleStep(ui->aufloesung->value());
ui->oberetemperatur->setSingleStep(ui->aufloesung->value());
werteberechnung(m_PunktListe);
}
main.cpp
#include "dialog.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Dialog w;
w.show();
return a.exec();
}

Answer 1

As noted in the comments, your example is not MCVE. But guessing, there are a couple of clues:
PunktVektor *m_punkte; //This is the mentioned vector
and
datenpunkt test = *m_punkte->begin(); <- //The programm crashs
Unless PunktVector overloads operator->(), your access of the vector should probably be
datenpunkt test = m_punkte->begin(); <- //no dereference (*)
REVISION:
With your updated example, the basic problem is dereferencing the end() iterator, which is a marker and does not refer to an element
datenpunkt test = *m_punkte->begin();
datenpunkt test2 =*m_punkte->end();
*m_punkte->empty();
m_punkte->begin() returns an iterator to the first element (if there is one; the vector could be empty). *( m_punkte->begin() ) accesses the element the iterator refers to.
m_punkte->end() return an iterator marking the end of the container. * (m_punkte->end() ) is undefined.
m_punkte->empty() returns a bool reflecting whether the container is empty or not. *( m_punkte->empty() ) will access either memory location 0 or 1 (both of which are likely to be very bad.
REVISION 2:
When working with containers, it is important to understand how you can hurt yourself. In particular, look here:
void DiagrammWidget::paintEvent(QPaintEvent *event)
{
QPainter myPainter (this);
/*if((m_punkte == 0|| m_punkte->size() == 0)){
myPainter.drawText(100,100,"No Points found!");
return;
}*/
datenpunkt ersterPunkt=*m_punkte->begin();
datenpunkt startPunkt = ersterPunkt;
PunktVektor::iterator it;
for( it = m_punkte->begin()++; it != m_punkte->end(); it++){
datenpunkt p = *it;
myPainter.drawLine(startPunkt.temperatur,startPunkt.laenge,
p.temperatur,p.laenge);
startPunkt = p;
}
}
If you are going to do this: datenpunkt ersterPunkt=*m_punkte->begin();
then you must first check to see of the container is empty.
Container.begin() returns an iterator to the first element of the container. If the container is empty, this iterator is equal to Container.end(). Dereferencing this iterator is a good way to crash your program.
Try refactoring your program like this:
void DiagrammWidget::paintEvent(QPaintEvent *event)
{
QPainter myPainter (this);
if( m_punkte == nullptr || m_punkte->empty() ){
// myPainter.drawText(100,100,"No Points found!");
return;
}
auto startPunkt = m_punkte->begin();
for( auto it = ++(m_punkte->begin()); it != m_punkte->end(); ++it){
auto const& p = *it;
myPainter.drawLine(startPunkt->temperatur,startPunkt->laenge,
p.temperatur,p.laenge);
startPunkt = it;
}
}
You see that this properly protects against your allowed condition of a null pointer or an empty container before making assumptions about the contents of the container. It also uses iterators as intended, rather than making unnecessary copies of the elements of the container.