run time error while destroying a vector

[GironAntoine]

The following code means to destroy a vector defined with unique_ptr to objects.
Oddly enough it works smoothly on the computer of a friend, but abends on mine.
To be precise, with a vector pointing to three objects, the first iteration works, poping back the last pointer, and the program abends with the second pop_back.

Any idea ?

Many thanks

//Destructeur
Systeme::~Systeme() {
	
	supprime();
	
}

void Systeme::supprime(){
	
	while (!Is_collec_part.empty()){
		
		Is_collec_part.pop_back();
		}
	
}

[ne555]

you may simply use the default destructor, and to clear a vector you could call the .clear() method.
apart from that there isn't something clearly wrong in the 15 lines that you posted.

[GironAntoine]

I'm still having the same problem with destruction. The program uses 3 classes.
A virtual class Particule
A sub class TxtNeon
A class Systeme wich contains a vector, named Is_collec_part, with unique_ptr pointing to Particule.

The main program does the following :
- creates two Particule-Neon objects
- adds unique_pointers to them in the Is_collec_part vector
- displays the objects
- destroys the two Particule-Neon objects
- calls a function named Supprime from the Systeme destructor
in wich there is a loop to pop_back the unique-pointers. First pop_back works, second abends.

NB: using clear abends as well.

1) Is it normal to have the objects destroyed before the unique pointers ?
2) What is wrong ?

Many thanks

//FILE testSysteme.cc ===============

using namespace std;

int main()
{	Systeme systeme(2,4,5);
	
	Vecteur p(1,2,3);
	Vecteur q(4,5,6);
	TxTNeon a( p, q, 4.002602);
	cout<<"a en t0 "<<a<<endl;

	Vecteur p2(2,2,3);
	Vecteur q2(4,5,6);
	TxTNeon b( p2, q2, 4.002602);
	cout<<"b en t0 "<<b<<endl;
	cout<<endl;
	
	a.evolue(1);
	cout<<"a en t1 "<<a<<endl;
	b.evolue(1);
	cout<<"b en t1 "<<b<<endl;
	cout<<endl;
	
	a.dessine();
	cout<<endl;


	systeme.ajoute(a);
	systeme.ajoute(b);
	systeme.dessine();
	cout<<endl;
	
	return 0;
	
}
//FILE Systeme.h 
============

class Systeme: public Dessinable {
	
	public:
	
	Systeme();										//Constructeur par défaut
	Systeme(double hauteur,double largeur,double profondeur);//Constructeur

	~Systeme();										//Destructeur
	void supprime();

//Méthodes publiques de la classe	
	void ajoute(Particule& b);		//Ajoute une particule dans Is_collec_part
	void evolue(double dt);			//Fait avancer le systeme d'un pas de temps(mouvement, rebonds, collisions)
	
//Polymorphisme hérité de Dessinable
	void dessine();					// METHODE A REVOIR QUAND ON SAURA CE QU'ON VEUT
		
	protected:
	
	vector<unique_ptr<Particule>> Is_collec_part; //vecteur de ptr uniques vers les particules
	Enceinte enceinte;
	Systeme(Systeme const& b)=delete;	//constructeur de copie interdit
	bool Is_dessinable;	
	
//Methodes privées de la classe
	
	Systeme operator=(Systeme const& a)=delete;
	
	
};

#endif

//FILE Systeme.cc 
=============
//Constructeurs
Systeme::Systeme(){
	
	Enceinte();			// appel au constructeur par défaut de la classe enceinte
	
	for(size_t i(0); i<Is_collec_part.size(); i++){
		
		Is_collec_part[i]=nullptr;
		
	}

	Is_dessinable=false;
}

Systeme::Systeme(double hauteur, double largeur, double profondeur){
	
	Enceinte(hauteur, largeur, profondeur);// constructeur d'enceinte
	
	for(size_t i(0); i<Is_collec_part.size(); i++){
		
		Is_collec_part[i]=nullptr;
		
	}

	Is_dessinable=false;
}

//Destructeur
Systeme::~Systeme() {
		
	supprime();
	
}

void Systeme::supprime(){
	
	cout<<"destruction systeme"<<endl;
	int	s=Is_collec_part.size();
	cout<<"Destruction systeme. Size : "<<s<<" particules."<<endl;
	
	while (!Is_collec_part.empty()){
		int	s=Is_collec_part.size();
		cout<<"Size : "<<s<<endl;		
		Is_collec_part.pop_back();
		cout<<"Next : "<<endl;				
		}
}
	
	
//Méthodes publiques de la classe	
void Systeme::ajoute(Particule& b){
 
	unique_ptr<Particule> p1(&b);
	Is_collec_part.push_back(move(p1));

}

void Systeme::evolue(double dt){
	
	for(size_t i(0); i<Is_collec_part.size(); i++){
		
		Is_collec_part[i]->evolue(dt);
		
	}
	
}

//Polymorphisme hérité de Dessinable

void Systeme::dessine(){
	
	int s;
	int i;

	cout<<"dessine systeme "<<endl;
	s=Is_collec_part.size();
	cout<<"Size : "<<s<<endl;
	for (i=0; i<s; i++) {
		cout<<*Is_collec_part[i]<<endl;
		}
}

//FILE Particule.h 
============
#ifndef PRJ_PARTICULE_H
#define PRJ_PARTICULE_H
#include <iostream>
#include <cmath>	
#include "Vecteur.h"
#include "Dessinable.h"

using namespace std;


class Particule : public Dessinable {
	public:

//Constructeurs-Destructeur
	Particule();							//Constructeur par défaut (0, 0, 0)
	Particule(Vecteur position, Vecteur vitesse, double masse);//Constructeur
	Particule(const Particule& Old_Particule);//Constructeur de copie
	
	~Particule(){	cout<<"destruction particule"<<endl;};							//Destructeur	
	
//Méthodes publiques de la classe	
	Vecteur getposition() const;			//Lecture et mise à jour des données privées
	void setposition(Vecteur v);
	Vecteur getvitesse() const;
	void setvitesse(Vecteur v);
	double getmasse() const;
	void setmasse(double d);
	void evolue(double dt);					//Déplace la particule mvt rectiligne uniforme
	void affiche(ostream& sortie) const;	// Méthode remplacée par une surcharge d'opérateur


											//Méthodes virtuelles
	virtual void dessine()=0;				


	protected:
	
	Vecteur Is_position;
	Vecteur Is_vitesse;
	double Is_masse;
	bool Is_dessinable;						// PROPRIETE A REVOIR QUAND ON SAURA CE QU'ON VEUT
	
};

ostream& operator<<( ostream& sortie, const Particule& p);  //Surcharge de l'affichage
#endif // PRJ_PARTICULE_H
//FILE Particule.cc =======================================================
#include "Particule.h"
#include "TxTNeon.h"

//Constructeurs
Particule::Particule(){
	
	Is_position.setx(0);
	Is_position.sety(0);
	Is_position.setz(0);
	
	Is_vitesse.setx(0);
	Is_vitesse.sety(0);
	Is_vitesse.setz(0);
	
	Is_masse=0;
	
	Is_dessinable=false;
	
}

Particule::Particule(Vecteur position, Vecteur vitesse, double masse){
	
	Is_position.setx(position.getx());
	Is_position.sety(position.gety());
	Is_position.setz(position.getz());
	
	Is_vitesse.setx(vitesse.getx());
	Is_vitesse.sety(vitesse.gety());
	Is_vitesse.setz(vitesse.getz());
	
	Is_masse=masse;

	Is_dessinable=false;
	
}

Particule::Particule(const Particule& Old_Particule){

	Is_position=Old_Particule.getposition();
	Is_vitesse=Old_Particule.getvitesse();
	Is_masse=Old_Particule.getmasse();
	
	Is_dessinable=false;
	
}
	
//Méthodes publiques de la classe	
//Get et set position, vitesse, masse
 Vecteur Particule::getposition() const{
	return Is_position;
}

void Particule::setposition(Vecteur v){

	Is_position.setx(v.getx());
	Is_position.sety(v.gety());
	Is_position.setz(v.getz());
}
	
Vecteur Particule::getvitesse() const{
	return Is_vitesse;
}

void Particule::setvitesse(Vecteur v){

	Is_vitesse.setx(v.getx());
	Is_vitesse.sety(v.gety());
	Is_vitesse.setz(v.getz());
}
	
double Particule::getmasse() const{
	return Is_masse;
}

void Particule::setmasse(double d){
	Is_masse=d;
}

//Déplace la particule mvt rectiligne uniforme
void Particule::evolue(double dt){
	
	Is_position.setx( Is_position.getx() + Is_vitesse.getx()*dt);
	Is_position.sety( Is_position.gety() + Is_vitesse.gety()*dt);
	Is_position.setz( Is_position.getz() + Is_vitesse.getz()*dt);
	
}
		 
// Méthodes remplacées par des surcharges d'opérateurs extérieures à la classe
//Affichage
void Particule::affiche(ostream& sortie) const{

		    sortie<<"position: "<<Is_position.getx()<<" "<<Is_position.gety()<<" ";
		    sortie<<Is_position.getz()<<"  "<<"vitesse: "<<Is_vitesse.getx()<<" ";
		    sortie<<Is_vitesse.gety()<<" "<<Is_vitesse.getz();
		    sortie<<"  "<<"masse: "<<Is_masse;
		    
		     }
			     
// Méthode extérieure à la classe		 
ostream& operator<<( ostream& sortie,const Particule& p){

			 p.affiche(sortie);
			 return sortie;
			 }		
//FILE TxtNeon.h =======================================================
#ifndef PRJ_TXTNEON_H
#define PRJ_TXTNEON_H
#include "Particule.h"
#include <iostream>
#include <cmath>

using namespace std;

class TxTNeon:public Particule{
	public:
	
	TxTNeon();														//constructeur par defaut (0,0,0)
	TxTNeon(Vecteur vitesse, Vecteur position, double masse);		//constructeur 
	
	~TxTNeon(){	cout<<"destruction neon"<<endl;};													//destructeur
	
//Polymorphisme
	void dessine();							// METHODE A REVOIR QUAND ON SAURA CE QU'ON VEUT

	
};

#endif	 
//FILE TxtNeon.cc =======================================================
#include "TxTNeon.h"

//Constructeurs
TxTNeon::TxTNeon():Particule(){
		
	}
	
TxTNeon::TxTNeon(Vecteur vitesse, Vecteur position, double masse):
	Particule (vitesse, position, masse){

	}

//Polymorphisme
void TxTNeon::dessine() {

	cout<<"Neon "<<*this<<endl;
		    
    }

[JLBorges]

> What is wrong ?

class Particule : public Dessinable

Is the destructor of Dessinable virtual? If not, make it virtual.

[GironAntoine]

Thank you,

But the destructor of Dessinable is virtual.
I still have the abend.

#ifndef PRJ_DESSINABLE_H
#define PRJ_DESSINABLE_H

using namespace std;

class Dessinable {
	public:
		Dessinable(){};				//Constructeur
		virtual ~Dessinable(){};	//Destructeur
		virtual void dessine()=0;	//Methode publique
	
};
#endif // PRJ_DESSINABLE_H

[cire]

Neither a, nor b in main are allocated with new, so why are you feeding them to std::unique_ptr via Systeme::ajoute with the default deleter (which assumes they were allocated by new?)

[GironAntoine]

Thank you,

I made the change you suggested.

As well, I move to another environment (Linux). I still have the error, but it gives a message now : invalid pointer.
This happens in member supprime with the pop_back instruction.

Thanks for your help.

#include <iostream>
#include <cmath>	
#include "Vecteur.h"
#include "Particule.h"
#include "Enceinte.h"
#include "Dessinable.h"
#include "Systeme.h"
#include "TxTNeon.h"
#include <vector>
#include <memory>

using namespace std;

int main()
{	Systeme systeme(2,4,5);
	
	TxTNeon a;
	TxTNeon b;
	
	Vecteur p(1,2,3);
	Vecteur q(4,5,6);
	//TxTNeon a( p, q, 4.002602);
	a = *new TxTNeon (p, q, 4.002602);
	cout<<"a en t0 "<<a<<endl;

	Vecteur p2(2,2,3);
	Vecteur q2(4,5,6);
	//TxTNeon b( p2, q2, 4.002602);
	b = *new TxTNeon (p2 , q2, 4.002602);
	cout<<"b en t0 "<<b<<endl;
	
	//TxTNeon c(Vecteur (0,1,2), Vecteur (3,4,5), 6);
	//cout<<c<<endl;

	a.evolue(1);
	cout<<"a en t1 "<<a<<endl;
	b.evolue(1);
	cout<<"b en t1 "<<b<<endl;
	
	a.dessine();


	systeme.ajoute(a);
	systeme.ajoute(b);
	//systeme.ajoute(c);
	systeme.dessine();
	
	systeme.supprime();
	
	return 0;
	
}