Expression: BLOC_TYPE_IS_VALIDE????

Expression: BLOC_TYPE_IS_VALIDE???? - C++ - Programmation

Marsh Posté le 09-12-2002 à 12:01:00    

j'ai un projet à remettre pour 16H et j'ai une de ces fucking erreur à l'execution ke je sais pas du tout d'où elle vient??? :fou:  
 
si kelk'un peu m'aider ce s'rai trop cool
http://www.imchat.be/test.gif
 
(compile avec VC++ 6.0 (j'utilise fstream.h; je sais pas si ça à kelke chose à voir) )

Reply

Marsh Posté le 09-12-2002 à 12:01:00   

Reply

Marsh Posté le 09-12-2002 à 12:03:09    

je crois que ton screenshot est bien placé pour le concours du screenshot le plus dégueux de l'année. C'était tout juste, il restait à peine trois semaines pour 2002.


---------------
mes programmes ·· les voitures dans les films ·· apprenez à écrire
Reply

Marsh Posté le 09-12-2002 à 12:03:29    

:ouch:  (vive les picts de kalité :ange: )

Reply

Marsh Posté le 09-12-2002 à 12:04:02    

lol, c'est ke je suis à la bourre....

Reply

Marsh Posté le 09-12-2002 à 12:04:18    

Comment veux tu qu'on t'aide si tu postes pas ton code ? :sarcastic:


---------------
J'ai un string dans l'array (Paris Hilton)
Reply

Marsh Posté le 09-12-2002 à 12:11:55    

ben me disait ke c'tai p'têtre une erreur tipike...?
 
(le prob c'est ke ce'st pas mega commenté)
 

Code :
  1. typedef unsigned short Piece;
  3. #include<fstream.h>
  4. #include<iostream.h>
  7. unsigned Load_next_unsigned(ifstream& file);
  9. //-----------------------------------------------------------------Graphe<Couloir>-------------------------------------------------
  11. template <class Couloir>
  12. class Graphe {
  13.    Piece N_Piece;
  14.    unsigned N_Couloir;
  15.    unsigned N_Escalier;
  16.    Piece *Escalier;
  17.    Couloir **M;
  19. public:
  20.    Graphe (ifstream&);
  21.    ~Graphe ();
  22.    Piece NB_PIECES () const { return N_Piece; }
  23.    unsigned NB_COULOIRS () const { return N_Couloir; } //unisgned != Piece  (NB_COULOIRS <= NB_PIECE^2)
  24.    Piece NB_ESCALIERS () const { return N_Escalier; }
  25.  
  26.    void Ins_Couloir (Piece s, Piece t, Couloir val = 1) { if(s<t) M[s][t] = val; else if(t>s && t<N_Piece) M[t][s]=val;}
  27.    void Ins_Escalier (Piece s, Piece t) {Escalier[s]=t;}
  28.    void Sup_Couloir (Piece s, Piece t) { M[s][t] = 0; }
  29.  
  30.    Piece Voisin_1er (Piece) const;
  31.    Piece Voisin_Svt (Piece, Piece) const;
  32.    bool Est_Piece (Piece s) const { return s < N_Piece; }
  34.    bool  Est_Couloir (Piece s, Piece t) { return ((s<t) ? M[s][t] : (t>s && t<N_Piece) ? M[t][s] : false;) }
  35.    Couloir POID (Piece s, Piece t) { return ((s<t) ? M[s][t] : (t>s && t<N_Piece) ? M[t][s]); }
  37.    Piece ESACLIER (Piece s) { return Escalier[s]; }   
  38.  
  39. };
  42. template <class Couloir>
  43. Graphe<Couloir>::Graphe (ifstream& file) : N_Piece(Load_next_unsigned(file))/*3*/, N_Couloir(Load_next_unsigned(file))/*4*/, N_Escalier(Load_next_unsigned(file))/*5*/, M(new Couloir*[N_Piece]), Escalier(new Piece[N_Piece]) {
  44.    for (Piece s=0; s<N_Piece-1; ++s) {
  45.       M[s] = new Couloir[s+1];
  46.       for (Piece t=0; t<s+1; ++t) M[s][t] = 0;
  47.  
  48.    }
  49.    for (Piece i=0; i<N_Piece; ++i) Escalier[i]=0;
  50. }
  52. template <class Couloir>
  53. Graphe<Couloir>::~Graphe () {
  54.    for (Piece s=0; s<N_Piece; ++s) delete[] M[s];
  55.    delete[] M;
  56.    delete[] Escalier;
  57. }
  59. template <class Couloir>
  60. Piece Graphe<Couloir>::Voisin_1er (Piece s) const {
  61.    Piece t = 0;
  62.    for ( ; t<s && !M[s][t]; ++t);
  63.    if(t=>s){
  64.    if(t==s) t++;
  65.    for(;t<N_Piece && !M[t][s]; ++t);
  66. }
  67.    return t;
  68. }
  70. template <class Couloir>
  71. Piece Graphe<Couloir>::Voisin_Svt (Piece s, Piece t) const {
  72.    for (++t ; t<s && !M[s][t]; ++t);
  73.    if(t=>s){
  74.    if(t==s) t++;
  75.    for(; t<N_Piece && !M[t][s]; ++t);
  76.    }
  77.    return t;
  78. }
  80. //I
  82. template <class Couloir>
  83. class Etage: public Graphe<Couloir> {
  84. Piece JBgirl;
  85. unsigned *difficulte;
  86. unsigned Pieces_Distrib;
  87. public:
  88. Etage (ifstream&, unsigned, bool);
  90.    ~Etage () { delete[] difficulte; };
  91.    unsigned NB_PIECES_DISTRIB() {return Pieces_Distrib;}
  92.  
  93.    unsigned DIFFICULTE  (Piece s) const { return difficulte[s]; }
  94.    Piece JBGIRL (Piece s) const { return JBgirl; }
  95.  
  96. };
  99. template<class Couloir>
  100. Etage<Couloir>::Etage (ifstream& file, unsigned n, bool Last_Graphe): Graphe<Couloir>(file), JBgirl(Load_next_unsigned(file)-1/*6*/), Pieces_Distrib(n), difficulte(new unsigned[NB_PIECES()]){
  101. cout<<endl<<"NB_PIECES() "<<NB_PIECES()<<endl;            //***Test
  102. for(unsigned i=0; i<NB_PIECES(); i++) difficulte[i]=Load_next_unsigned(file)/*6+N_Piece*/;
  103. cout<<endl<<"NB_COULOIRS() "<<NB_COULOIRS()<<endl;           //***Test
  104. for(unsigned j=0; j<NB_COULOIRS(); j++){
  105.  unsigned a,b,c;
  106.  a=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs-2*/
  107.  b=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs-1*/
  108.  c=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs*/
  109.  Ins_Couloir (a-(1+Pieces_Distrib),b-(1+Pieces_Distrib),c-(1+Pieces_Distrib));
  110. }
  111. cout<<endl<<"NB_ESCALIERS()= "<<NB_ESCALIERS()<<endl;          //***Test
  112. if(!Last_Graphe){
  113.  for(unsigned k=0; k<NB_ESCALIERS(); ++k){
  114.   unsigned a,b;
  115.   a=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs+2*N_Escalier-1*/
  116.   b=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs+2*N_Escalier*/
  117.   Ins_Escalier(a-(1+Pieces_Distrib),b-(1+Pieces_Distrib+NB_PIECES()));
  118.  }
  119. }
  120. else{
  121.  for(unsigned k=0; k<NB_ESCALIERS(); ++k){
  122.   unsigned a=Load_next_unsigned(file);/*6+N_Piece+3*N_Couloirs+2*N_Escalier-1*/
  123.   Ins_Escalier(a-(1+Pieces_Distrib), 1);   //1==sentinelle
  124.  }    
  125. }        
  126.  
  127. }
  129. //-----------------------------------------------------------------Prison<Couloir>-------------------------------------------------
  131. template <class Couloir>  
  132. class Prison{
  133. unsigned N_Graphe;
  134. unsigned N_TOTAL_Piece;
  135. Piece First;
  136. Etage<Couloir>** V;
  138. public:
  139. Prison(ifstream& file): N_Graphe (Load_next_unsigned(file)/*1*/), V(new Etage<Couloir>* [N_Graphe]) {
  140.  First=Load_next_unsigned(file/*2*/);
  141.  --First;
  142.  for(unsigned i=0; i<N_Graphe; i++){
  143.   V[i]=new Etage<Couloir> (file, (i?(V[i-1]->NB_PIECES_DISTRIB()+V[i-1]->NB_PIECES()) :0), (i==N_Graphe-1));
  144.  }
  145. }  
  146. ~Prison() { for(unsigned i=0; i<N_Graphe; i++) delete[] V[i]; delete[] V;}
  147. };
  149. //---------------------------------------------------------------------------------------------------------------------------
  151. unsigned c=0;               //***Test
  153. unsigned Load_next_unsigned(ifstream& file){
  154. if(!file.eof()){                  
  155.  unsigned res;
  156.  file>>res;
  157.  cout<<++c<<"-"<<res<<endl;          //***Test
  158.  return res;
  159. }
  160. cerr<<"eof"<<endl;         //on est jamais trop prudent
  161. return 0;
  162. }
  165. int main(char** argv, int argc)
  166. {
  167. char* inputfile_name = "exempleJames.txt";   //char* inputfile_name = argv[0];
  169. ifstream file (inputfile_name);    
  170. if (!file) {
  171.          cerr << "erreur ouverture en lecture : "<< inputfile_name << endl ;
  172. }
  173.  
  174. Prison<unsigned short> JB0075 (file);
  175. file.close();
  177. int p;
  178. cin>>p;
  180. return 1;
  181. }

Reply

Marsh Posté le 09-12-2002 à 12:12:44    

en fait le prob est à la fermeture de mon main()
 
exemplejames.txt:
3
1
4
3
2
2
50
100
25
10
1 2 5
2 3 10
2 4 9
3 9
4 7
5
4
2
8
40
80
40
50
30
7 8 8
8 9 5
5 8 6
6 8 9
5 10
6 11
3
3
1
11
15
20
30
10 11 12
10 12 2
11 12 15
12


Message édité par peak le 09-12-2002 à 12:17:04
Reply

Marsh Posté le 09-12-2002 à 13:20:00    

ben t'as juste une putain d'assertion qui merde c'est tout. tu sais lire?


---------------
du bon usage de rand [C] / [C++]
Reply

Marsh Posté le 09-12-2002 à 13:37:20    

Vive la convivialité!!!
Si ça te fait chier de répondre aux kestions personne te force!!
(ce style de réponses je m'en passerai!!)
 
je cherchai juste à avoir des renseignements sur  
"BLOCK_TYPE_IS_VALID(pHead->nBlockUse)"
et sur le style de couilles ki peuvent causer un problème d'assertion...

Reply

Marsh Posté le 09-12-2002 à 13:40:53    

ben tu vas dans le fichier indiqué à la ligne donné et tu réfléchis comment ca se fait que l'assertion echoue (en l'occurence que truc->chose soit egale à 0)
 
les assert, c'est bete et mechant, rien a dire de plus dessus. c'est de la programmation dégueulasse qui ne doit etre utiliser qu'en phase dev, apres le code doit etre blindé et tous les assert dégagés


---------------
du bon usage de rand [C] / [C++]
Reply

Marsh Posté le 09-12-2002 à 13:40:53   

Reply

Marsh Posté le 09-12-2002 à 13:45:31    

ok,  
je prefer ça! :)

Reply

Marsh Posté le 09-12-2002 à 14:04:24    

Taz@PPC a écrit :

ben tu vas dans le fichier indiqué à la ligne donné et tu réfléchis comment ca se fait que l'assertion echoue (en l'occurence que truc->chose soit egale à 0)


mais là en l'occurence, il se trouve que l'assertion est dans un fichier source qui ne lui appartient pas (surement un projet MFC, qui sont gavées d'ASSERT et autres ASSERT_VALID() )
 
hélas, la seule solution est effectivement de regarder la cause qui fait que l'assertion échoue, et sur un fichier qui ne t'appartient pas, c'est une merde sans nom...


---------------
J'ai un string dans l'array (Paris Hilton)
Reply

Marsh Posté le 09-12-2002 à 14:06:43    

:fou: j'y peux rien si les mecs de gros$oft utilsie meme pas le mode release de leur compilo buggé


---------------
du bon usage de rand [C] / [C++]
Reply

Marsh Posté le 09-12-2002 à 14:14:39    

m'engueule po, j'y suis pour rien moi [:serial coder]


---------------
J'ai un string dans l'array (Paris Hilton)
Reply

Marsh Posté le 09-12-2002 à 14:15:16    

Ca doit être pour terminer le debuggage auquel les acheteurs de leurs outils participent. Les remarques sont sagement exploitées (test en vrai grandeur) et permet de préparer la mouture de la prochaine version qui corrige les défauts de la précédente (ou prépérer un ServicePack).
?

Reply

Marsh Posté le 09-12-2002 à 15:00:10    

bon ben, je me resigne... avec un peu de bol ils le verront pas  :whistle:  
 
 
 

Reply

Marsh Posté le 09-12-2002 à 15:08:20    

carbon_14 a écrit :

Ca doit être pour terminer le debuggage auquel les acheteurs de leurs outils participent. Les remarques sont sagement exploitées (test en vrai grandeur) et permet de préparer la mouture de la prochaine version qui corrige les défauts de la précédente (ou prépérer un ServicePack).
?

nan je crois po  :non:


---------------
du bon usage de rand [C] / [C++]
Reply

Marsh Posté le 09-12-2002 à 15:31:59    

C'était ma rubrique langue de vipère. :ange:

Reply

Marsh Posté le 09-12-2002 à 16:27:06    

peak a écrit :

bon ben, je me resigne... avec un peu de bol ils le verront pas  :whistle:  
 
 
 


:heink:
je veux pas te faire peur, mais une assertion qui échoue en mode debug conduit le plus souvent à une segmentation fault ou à une lecture/écriture dans une zone mémoire interdite en mode release !
et là, pas bon du tout !!! je serais toi, je me démerderais à corriger ça !!


---------------
J'ai un string dans l'array (Paris Hilton)
Reply

Marsh Posté le 10-12-2002 à 02:23:16    

Ça veut dire que tu passe à une fonction système une zone mémoire corrompue.
Il n'y a pas de doute, ton programme écrases, mélange, ou n'alloue pas la mémoire.
 
1) Clique Retry
2) Active menu "View/Debug Windows/Call Stack"
3) Double cliques dans cette fenêtre la plus haute fonction appartenant à ton application.
 
Tu sais maintenant depuis où se fait un appel corrompu.
Reste à placer des points d'arrêts, assertions, traces...
 
PS: Si tu programmes comme tu postes des images, j'ai peur.


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed