Runtime termination

Marsh Posté le 05-04-2009 à 15:32:26

Bonjour,

Je travaille sur un projet d'optimisation de reseau de distribution et tout allait bien jusqu'a hier, depuis le programme ne s'execute plus et c'est assez surprenant.

La compilation se passe sans soucis, le probleme survient a l'execution ou le programme s'arrete brusquement.

Ci-dessous le code du programme principal:

Code :

#include "Vector.hpp"
#include "Population.hpp"
#include <string>
#include <math.h>
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
// Declare and initialize the parameters
int popSize = 4;
int numMaxWHS = 9;
ifstream file;
file.open("Data/Demand.TXT" );
char buffer[12];
// Number of customers
file.getline(buffer, 12);
int numCS = (int)strtod(buffer, NULL);
cout << numCS;
// Total volume
file.getline(buffer, 12);
double supply = strtod(buffer, NULL);
cout << " " << supply << endl;
// Customers' demand
Vector<int, int> demand = Vector<int, int>(numCS);
for(int i=0;i<numCS;i++)
{
file.getline(buffer, 12);
demand[i] = (int)strtod(buffer, NULL);
}
file.close();
// Create population of Solutions
cout << "test1" << endl;
Datasim::Population pop(popSize, numMaxWHS, numCS, supply, demand);
return 0;
}

Et de la classe population:

Code :

#ifndef POPULATION_CPP
#define POPULATION_CPP
#include "Population.hpp"
#include <cmath>
#include <iostream>
using namespace std;
namespace Datasim
{
// Constructors and destructor
Population::Population()
{
}
Population::Population(int popSize, int maxNumWHS, int numCS, double supply, Vector<int, int> demand)
{
cout << "test2" << endl;
size = popSize;
pop = Vector<Solution, int>(size);
Solution sol(maxNumWHS, numCS);
for (int n=size-1; n>=0;n--)
{
sol.Init(supply, demand);
pop[n]= Solution(sol);
}
}
}
// End of name space Datasim
#endif // POPULATION_CPP

Le resultat:

le message Test1 s'affiche mais pas Test2 ce qui veut dire que l'execution s'arrete entre ces deux lignes (la console se ferme toute seule). J'ai lance le programme en ligne de commande pour voir si il y avait un message d'erreur, il y en a un et c'est le suivant:
"This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information"... pas tres parlant.

Ce qui m'etonne le plus est que mon programme fonctionnait super bien jusqu'a hier et tout d'un coup j'ai ce probleme alors que je n'ai pas touche au bout de code que je vous ai c/c.

Merci d'avance pour votre aide.

Bonne journee,

Jean

Reply

Marsh Posté le 05-04-2009 à 15:32:26

Reply

Marsh Posté le 05-04-2009 à 21:19:39

c'ets quoi ces Vector moche ?
Deja tu le passerais par reference et non par copie, selon ca taille, ca serait deja pas mal. Parce que , genre, t'as combien d'entrée dans ton ficheir ?

Message édité par Joel F le 05-04-2009 à 21:19:54

Reply

Marsh Posté le 05-04-2009 à 21:41:50

et utilise std::string et std::getline

Reply

Marsh Posté le 05-04-2009 à 22:12:15

Ouaip, ton problème à l'air définitivement dans ton constructeur Vector<int, int>.
Le mieux est d'utiliser (ou d'apprendre à utiliser) un debuggeur.

Reply

Marsh Posté le 06-04-2009 à 07:40:09

Bonjour,

Je vous remercie pour vos reponses, malheureusement je n'ai pas reussit a resoudre mon probleme.

J'ai modifie le code de la classe Population:

Code :

#include "Population.hpp"
#include <cmath>
#include <iostream>
using namespace std;
namespace Datasim
{
// Constructors and destructor
Population::Population()
{
}
Population::Population(int popSize, int maxNumWHS, int numCS, double supply, const Vector<double, int> &demand)
{
cout << "test2" << endl;
int j;
cin >> j;
/*size = popSize;
pop = Vector<Solution, int>(size);
Solution sol(maxNumWHS, numCS);
for (int n=size-1; n>=0;n--)
{
sol.Init(supply, demand);
pop[n]= Solution(sol);
}*/
}
}
// End of name space Datasim
#endif // POPULATION_CPP

mais j'ai toujours le probleme a l'execution. Dans mon fichier Demand.txt je lisais 350 valeurs (sur 350 lignes differentes) mais j'ai reduit a 10 valeurs pour voir si cela changeait quelque chose. Cela ne fonctionne pas non plus, je n'y comprend rien car mon programme tournait tres bien jusqu'a cette semaine sans que je ne modifie rien dans ces deux fichiers (main et Population), j'ai surtout travaille sur ma classe Solution qui ne sert a rien a ce niveau du programme.

J'ai essaye d'utiliser std::getline mais cela ne fonctionne pas, est-ce vraiment important ? Mon programme fonctionnait avant avec cette structure.

Pour l'utilisation d'un debugger je suis interesse si vous pensez que cela peut etre utile pour comprendre ce qui se passe dans mon cas, je ne vois pas comment je peux faire (J'utilise Dev-C++).

Merci et bonne journee,

Jean

Reply

Marsh Posté le 06-04-2009 à 07:41:33

PS: la classe Vector ne pose pas de probleme, je l'ai recuperee dans un bouquin de C++ et utilisee dans d'autres projets sans souci. Je ne dis pas que c'est la solution la plus efficace mais elle m'a bien rendu service jusqu'a present.

Reply

Marsh Posté le 06-04-2009 à 09:42:13

c'est surtout que moi le strucs sorties d'un bouqin de C++, j'y crois moyen comparait à la solution équivalente testée et stadnardisée masi bon ...

Je mets 10€ sur le fait que Vector n'est pas implanter correctement et que son constructeur par defaut est foireux. Alor spour etre sur, montre le code de Vector
Montre aussi la declaration de Population.

Reply

Marsh Posté le 06-04-2009 à 09:52:43

Bonjour,

Voici la declaration de Population:

Code :

#ifndef POPULATION_HPP
#define POPULATION_HPP
#include "Solution.hpp"
#include "Vector.hpp"
namespace Datasim
{
class Population
{
private:
int size;
Vector<Solution, int> pop;
Solution sol;
public:
Population();
Population(int popSize, int maxNumWHS, int numCS, double supply,
const Vector<double, int> &demand);
};
} // End of namespace Datasim
#endif // POPULATION_HPP

Le debut du fichier Vector.hpp:

Code :

#ifndef Vector_hpp
#define Vector_hpp
#include "Array.hpp"
#include "FullArray.hpp"
// Default structure is FullArray with default allocator. Default integral type is int.
template <class V, class I=int, class S=FullArray<V> >
class Vector: public Array<V, I, S>
{
private:
public:
// Constructors & destructor
Vector(); // Default constructor
Vector(I size); // Constructor with size. Start index=1.
Vector(I size, I start); // Constructor with size & start index
Vector(I size, I start, const V& val); // Constructor with size & start index + value
Vector(const Vector<V, I, S>& source); // Copy constructor
Vector(const Array<V, I, S>& source); // Copy with an array as argument
virtual ~Vector(); // Destructor
// Return the sum of the elements
// Operators
Vector<V, I, S>& operator = (const Vector<V, I, S>& source);
Vector<V, I, S> operator - () const; // Unary minus
template <class W, class J, class T>
friend Vector<W, J, T> operator + (const Vector<W, J, T>& v,const W& a); // Add v to every element
template <class W, class J, class T>
friend Vector<W, J, T> operator + (const W& a, const Vector<W, J, T>& v);
template <class W, class J, class T>
friend Vector<W, J, T> operator - (const Vector<W, J, T>& v, const W& a); // Subtract v from every element
template <class W, class J, class T>
friend Vector<W, J, T> operator - (const W& a, const Vector<W, J, T>& v);
template <class W, class J, class T>
friend Vector<W, J, T> operator * (const Vector<W, J, T>& v,
const W& a); // Multiply every element by v
template <class W, class J, class T>
friend Vector<W, J, T> operator * (const W& a, const Vector<W, J, T>& v);
Vector<V, I, S> operator / (const V& a) const; // Divide every element by a
Vector<V, I, S> operator + (const Vector<V, I, S>& v) const; // Add the elements
Vector<V, I, S> operator - (const Vector<V, I, S>& v) const; // Subtract the elements
Vector<V, I, S> operator * (const Vector<V, I, S>& v) const; // Multiply the elements
Vector<V, I, S> operator / (const Vector<V, I, S>& v) const; // Divide the elements
Vector<V, I, S>& operator += (const V& v); // Add v to every element
Vector<V, I, S>& operator -= (const V& v); // Subtract v from every element
Vector<V, I, S>& operator *= (const V& v); // Multiply every element by v
Vector<V, I, S>& operator /= (const V& v); // Divide every element by v
Vector<V, I, S>& operator += (const Vector<V, I, S>& v);// Add the elements
Vector<V, I, S>& operator -= (const Vector<V, I, S>& v);// Subtract the elements
Vector<V, I, S>& operator *= (const Vector<V, I, S>& v);// Multiply the elements
};
// Some 'command' type functions that are useful in some applications. Most functions
// are void and this promotes Efficiency. Usability is also enhanced.
//
template <class V, class I> void scale(Vector<V,I>& v, const V& a); // v * a
template <class V, class I> void scale(const V& a, Vector<V,I>& v); // a * v
template <class V, class I> void add(Vector<V,I>& v, const V& a); // v + a
template <class V, class I> void add(const V& a, Vector<V,I>& v); // a + v
template <class V, class I> void
scaleAndOffset(Vector<V,I>& v, const V& a, const V& b); // (a * v) + b
template <class V, class I> void subtract(Vector<V,I>& v, const V& a); // v - a
template <class V, class I> void subtract(const V& a, Vector<V,I>& v); // a - v
template <class V, class I> void divide(Vector<V,I>& v, const V& a); // v / a
template <class V, class I> void toggleSign(Vector<V,I>& v); // -v (unary minus)
template <class V, class I> void assign(Vector<V,I>& v, const V& RHS); // All elements = RHS
// Constructors & destructor
template <class V, class I, class S>
Vector<V, I, S>::Vector(): Array<V, I, S>()
{ // Default constructor
}
template <class V, class I, class S>
Vector<V, I, S>::Vector(I size): Array<V, I, S>(size)
{ // Constructor with size. Start index=1.
}

Et le debut du fichier Array.hpp:

Code :

#ifndef Array_hpp
#define Array_hpp
#include "arraystructure.hpp"
#include "fullarray.hpp"
#include <stddef.h>
// Default structure is FullArray with default allocator. Default integral type is int.
template <class V, class I=int, class S=FullArray<V> >
class Array
{
private:
S m_structure; // The array structure
I m_start; // The start index
public:
// Constructors & destructor
Array(); // Default constructor
Array(I size); // Constructor with size. Start index=1.
Array(I size, I start); // Constructor with size & start index
Array(I size, I start, const V& value); // Size, start and value
Array(const Array<V, I, S>& source); // Copy constructor
virtual ~Array(); // Destructor
// Selectors
I MinIndex() const; // Return the minimum index
I MaxIndex() const; // Return the maximum index
I Size() const; // The size of the array
// Operators
virtual V& operator [] (I index); // Subscripting operator
virtual const V& operator [] (I index) const; // Subscripting operator
Array<V, I, S>& operator = (const Array<V, I, S>& source);
};
// Constructors & destructor
template <class V, class I, class S>
Array<V, I, S>::Array()
{ // Default constructor
m_structure=S();
m_start=0;
}
template <class V, class I, class S>
Array<V, I, S>::Array(I size)
{ // Constructor with size. Start index=1.
m_structure=S(size_t(size));
m_start=0;
}

Je reconnais que ces Vector ne sont pas la meilleure solution pour des listes de double comme Demand[] mais je les trouve bien pratiques et simple a utiliser pour des listes d'objets plus complexes.

Desole de poster un message aussi long et merci beaucoup pour ton aide.

Jean

Reply

Marsh Posté le 06-04-2009 à 10:07:52

Bah si tu veux rester avec ta soupe et pas nous donner de code => apprend à utiliser un debugger et debug ta classe Vector

Reply

Marsh Posté le 06-04-2009 à 10:18:52

Bonjour Taz,

Desole il manquait le bout de code suivant:

Code :

#ifndef FullArray_hpp
#define FullArray_hpp
// Use the STL vector class
#include <vector>
#include "ArrayStructure.cpp"
template <class V, class TA=std::allocator<V> >
class FullArray: public ArrayStructure<V>
{
private:
std::vector<V, TA> m_vector; // Use STL vector class for storage
public:
// Constructors & destructor
FullArray();
FullArray(size_t size);
FullArray(const FullArray<V, TA>& source);
virtual ~FullArray();
// Selectors
virtual size_t Size() const;
// Modifiers
// Operators
V& operator[] (size_t index);
const V& operator[] (size_t index) const;
FullArray<V, TA>& operator = (const FullArray<V, TA>& source);
};
// Constructors & destructor
template <class V, class TA>
FullArray<V, TA>::FullArray(): ArrayStructure<V>()
{ // Default constructor
m_vector=std::vector<V, TA>(1); // vector object with 1 element
}
template <class V, class TA>
FullArray<V, TA>::FullArray(size_t size): ArrayStructure<V>()
{ // Constructor with size
m_vector=std::vector<V, TA>(size);
}

En fait le code des classes se trouve dans les fichiers .hpp (template).

Je suis certain que mon code n'est pas joli, je crois que j'ai choisit le metier le plus eloigne de l'informatique (la metallurgie). Ne croyez pas que je soutienne que mes programmes sont les plus efficaces au contraire, par contre une chose est sure. Ce programme a marche

Reply

Marsh Posté le 06-04-2009 à 10:18:52

Reply

Marsh Posté le 06-04-2009 à 11:02:01

v_v tout ce bordel pour encapsuler std::vector dnas une soupe infame ...
Utilise std::vector directement et regarde si ca marche pas mieux ...

Reply

Marsh Posté le 06-04-2009 à 12:32:47

Je viens de faire l'essai que tu preconises. Pas de probleme a la compilation mais toujours le meme probleme a l'execution.

Pour info le code utilise pour cet essai:

Fonction main:

Code :

#include "Population.hpp"
#include <string>
#include <math.h>
#include <fstream>
#include <iostream>
using namespace std;
int main()
{
// Declare and initialize the parameters
int popSize = 4;
int numMaxWHS = 9;
ifstream file;
file.open("Data/Demand.TXT" );
char buffer[12];
// Number of customers
file.getline(buffer, 12);
int numCS = (int)strtod(buffer, NULL);
cout << numCS;
// Total volume
file.getline(buffer, 12);
double supply = strtod(buffer, NULL);
cout << " " << supply << endl;
// Customers' demand
std::vector<double> demand = std::vector<double>(numCS);
for(int i=0;i<numCS;i++)
{
file.getline(buffer, 12);
demand[i] = strtod(buffer, NULL);
}
file.close();
// Create population of Solutions
cout << "test1" << endl;
Datasim::Population pop(popSize, numMaxWHS, numCS, supply, demand);
return 0;
}

Classe population:

Code :

#ifndef POPULATION_CPP
#define POPULATION_CPP
#include "Population.hpp"
#include <cmath>
#include <iostream>
using namespace std;
namespace Datasim
{
// Constructors and destructor
Population::Population()
{
}
Population::Population(int popSize, int maxNumWHS, int numCS, double supply, const std::vector<double> &demand)
{
cout << "test2" << endl;
}
}
// End of name space Datasim
#endif // POPULATION_CPP

Declaration de Population:

Code :

#ifndef POPULATION_HPP
#define POPULATION_HPP
#include "Solution.hpp"
//#include "Vector.hpp"
namespace Datasim
{
class Population
{
public:
Population();
Population(int popSize, int maxNumWHS, int numCS, double supply,
const std::vector<double> &demand);
};
} // End of namespace Datasim
#endif // POPULATION_HPP

Je suis desole que ce soit aussi laborieux... Merci pour votre patience.

Jean

Reply

Marsh Posté le 06-04-2009 à 13:44:22

Chez moi ce code marche tres bien :

Code :

#include <string>
#include <math.h>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;
namespace Datasim
{
class Population
{
public:
Population() {}
Population(int popSize, int maxNumWHS, int numCS, double supply, const std::vector<double> &demand) {
cout << "test2" << endl;
}
};
} // End of namespace Datasim
int main()
{
// Declare and initialize the parameters
int popSize = 4;
int numMaxWHS = 9;
ifstream file;
file.open("demand.txt" );
char buffer[12];
// Number of customers
file.getline(buffer, 12);
int numCS = (int)strtod(buffer, NULL);
cout << numCS;
// Total volume
file.getline(buffer, 12);
double supply = strtod(buffer, NULL);
cout << " " << supply << endl;
// Customers' demand
std::vector<double> demand = std::vector<double>(numCS);
for(int i=0;i<numCS;i++) {
file.getline(buffer, 12);
demand[i] = strtod(buffer, NULL);
}
file.close();
// Create population of Solutions
cout << "test1" << endl;
Datasim::Population pop(popSize, numMaxWHS, numCS, supply, demand);
return 0;
}

... Verifie que les valeurs retournees par ton fichier sont correctes.

Reply

Marsh Posté le 06-04-2009 à 13:56:05

Code :

std::vector<double> demand = std::vector<double>(numCS);

[:prozac] on est pas en JAVA

Code :

std::vector<double> demand(numCS);

Reply

Marsh Posté le 06-04-2009 à 14:36:01

Les deux syntaxes produisent le meme resultat :pt1cable:

Je sens que je ne vais jamais y arriver, le pire c'est que cela marchait jusqu'a samedi...

J'affiches demand[] avec des cout et les valeurs sont conformes a celles qui se trouvent dans mon fichier...

Reply

Marsh Posté le 06-04-2009 à 15:22:20

sors donc ton debugger pour voir où ça plante au moins ...

Reply

Marsh Posté le 06-04-2009 à 15:22:56

Et prie pour numCS soit >= 0;

Reply

Marsh Posté le 06-04-2009 à 15:40:29

Il n'y a pas de probleme avec numCS, il est egal a 15 et j'affiche aussi les 15 valeurs enregistrees dans demand[] : aucun probleme.

Il vient de se passer quelque chose de mystique, l'execution a marche deux fois donc j'ai enleve les commentaires que j'avais mis pour simplifier mon programme dans Population.cpp et la le programme n'a pas marche. Ce qui est bizarre c'est qu'en remettant les commentaires exactement au meme endroit l'execution ne fonctionne pas.

Le probleme peut-il venir de Dev-C++ ou d'un probleme de memoire dans mon ordinateur ?

Je suis maintenant certain qu'il n'y a pas de probleme de programmation, le programme fonctionnait avant et il vient de fonctionner deux fois.

C'est tres bizarre...

Une autre idee ?

Edit: Je ne sais pas comment utiliser le debugger pour ce probleme. Quel type de renseignements peut-il me fournir sachant que l'erreur se produit lors de l'appel au constructeur de la classe Population ?

Edit pour Taz: Pour rappel, mon message "Test1" s'affiche mais "Test2" ne s'affiche pas, le programme plante entre les deux.

Message édité par hurang le 06-04-2009 à 16:03:04

Reply

Marsh Posté le 06-04-2009 à 16:04:21

si ton programme a un comportement aleatoire, le premier truc à penser c'est une erreur du dit programme pas un pb de hardware ... Le truc ets que jusqu'ici tu as eu de la chance que ca marche c'est tout.

Le debugger te permettra de voir si tes données sont bien allouées, chargées et utiliser proprement. Si tes donner sont bien là, es tu sur de pas taper hors du tableau dans une qqconque boucle ?

Et le debugging a grand cout de cout ca marche rarement ou on veut vu que les i/o sont buffeirsées et que le plantage peut se produtre un peu avant/apres selon comment le compilo à reordonancer le bouzin.

Message édité par Joel F le 06-04-2009 à 16:07:39

Reply

Marsh Posté le 06-04-2009 à 19:09:50

Merci Joel F et les autres. Finalement le programme refonctionne mais je n'ai pas l'impression d'avoir change quelque chose, j'espere que ce n'est pas temporaire. Sachez seulement que j'ai change tous les Vector<,> en vector<> dans chacune de mes classes et que j'utilise des passages par reference.

J'ai juste un petit probleme, je ne sais pas comment utilise les donnees que je passe par reference. J'ai cherche sur Internet et je ne trouve pas la reponse.

Exemple avec ma classe Population:

Code :

Population::Population(int popSize, int maxNumWHS, int numCS, double supply, const std::vector<double> &demand)
{
cout << "Test" << endl;
for(int i=0;i<numCS;i++)
{
cout << demand[i] << " ";
}
}

Affiche:
Test

puis plante.

Quelle doit etre la syntaxe ?

Merci d'avance

Reply

Marsh Posté le 06-04-2009 à 19:12:21

la syntaxe est correct. Ton tableau demand a t il été initialisé avec le bon nb d'elements

Reply

Marsh Posté le 06-04-2009 à 19:28:33

pourquoi ne pas utiliser vector::size() pour obtenir la taille du vector plutot que de passer sa taille en argument ?

Reply

Marsh Posté le 07-04-2009 à 02:38:11

Joel F, xilebo,

Merci a tous les deux.

A l'initialisation de demand, j'utilise maintenant demand.size() et je n'ai plus de probleme dans Population.

A priori je n'ai plus de probleme d'autres problemes, merci beaucoup pour votre patience.

Bonne journee,

Jean

PS: je vis en Chine, d'ou le decalage horaire...

Reply

Marsh Posté le 07-04-2009 à 09:51:18

fais un demand.at(i); ça va lancer une exception

Reply

Marsh Posté le 07-04-2009 à 09:53:02

t'as quand même un gros problème puisque numCS est censé être égal à demand.size()

Reply

Marsh Posté le 07-04-2009 à 12:24:10

C'est justement ce qui est bizarre... D'autant plus qu'a l'affichage numCS a la valeur qu'il doit avoir.

Je ferai l'essai demand.at(i); pour voir ce que cela donne, merci du conseil.

Reply

Marsh Posté le

Reply

Runtime termination

Sujets relatifs:

Leave a Replay