Bonjour,
 
J'ecris un programme sous vc++ mais j'ai un probleme que je n'arrive pas a resoudre.
 
En fait, dans mon programme, j'utilise bcp des pointeurs pour creer des tableaux a deux dimensions de taille variable. Je suis aussi oblige d'utiliser plusieurs boucles les unes dans les autres...
 
Le bug est au niveau d'un "new" d'apres le debugger qui s'arrete sur la fct _heap_alloc_dbg.
 
D'apres ce que l'on m'a deja dit le probleme viendrait peut etre d'un delete[] que j'aurai mal utilise...
 
J'ai tout verifie, mais je suis debutante et j'ai pu faire des erreurs en particulier avec les "delete"...
 
Par ex :  
int n = 3000;
int ** H = new int* [n];
for(j=0;j<400;j++)
{
     for ( i=0;i<n;i++)
     {
        //calcul de f ...
        H[i]=new int[f];
     }
//calcul se servant de H tel qu'il vient d'etre creer
     for ( i=0;i<n;i++)
     {
        delete [] H[i];
     }
}
delete [] H;  
 
Cette partie de code est elle correcte? Je ne sait pas trop qd utiliser delete []() et delete()...
 
Si vous pouviez me donner qq conseils...et surtout n'hesitez pas a detailler vos reponses...
Merci beaucoup.
Aurélie

ca semble correcte
 
si new[] alors delete[]
si new alors delete
 
mais ca sera infiniment moins casse gueule si tu utilise std::vector

ca marche comment en gros?

en gros (il y a peut etre plus simple)

 
apres tu t'en sers comme un tableau, la methode size() te donne la taille (H.size() == n, H[i].size() == f)
moi je ferais avec std::vector<int> H(n*f)

Merci je vais essayer de transformer les pointeurs en vecteurs. Les vecteurs n'ont pas besoin d'etre effaces??

aureliiie, so geehhhht das niieeeeee
 
regle simple
new => delete
new [] => delete []
pas de new => rien
 
donc vala, t'as la reponse a ta question

 
nul besoin, tu peux redimensionner, affecter... en toute securite
 
http://www.sgi.com/tech/stl/Vector.html

c marrant comment tout le monde est tout de suite plus gentil quand c'est une fille qui a des problemes :-)

tu nous prends pour des caves ? genre un pseudo de fille = une fille ?? nan mais hé, on a fait l'irc mon gars, on sait tres bien que y'a que des mecs sur l'net

heu...en fait j'suis bien une fille...
Mais je prefererai que vous repondiez a ma question plutot que de divaguer...
Je me demande si je peux faire avec les vecteurs (que j'utilise a la place des pointeurs, merci Skelter) un tableau de deux dim ou les lignes ne font pas toutes la meme taille...

dans un vecteur tu mets ce que tu veux
 

merci bcp.Je vais essayer!

Bon...
J'ai remplace tout les pointeurs par des vecteurs et mon programme a plante qd meme...
Donc le bugg ne devait pas venir de la...
Est ce que qq'un aurait une autre idee?

c'est quoi le code qui fait planter ?

Il y a une boucle de bootstrap dans le main qui appelle une fct nommee quadrillage qui appelle elle meme une fct nommee probaex2. Je te mets le code du bootstrap et celui de la fct probaex2. C'est dans probaex2 que le prog s'arrete...au niveau d'un des "new".
 
//Bootstrap (dans le main)//
 
//creation de 30 echantillons par tirage au sort avec remise
//creation de Hetoile, Retoile et nb_part_etoile
   
int itboot = 30;
double** resultat_bootstrap = new double* [itboot];
for(i=0;i<itboot;i++){resultat_bootstrap[i]=new double [4];}
int** Hetoile = new int*[nHommes2];
int ** Retoile = new int* [nHommes2];
int* nb_part_etoile = new int [nHommes2];
double* proba_res = new double [4];
double x3 [4] = {0.5,0.5,0.5,0.5};
 
 
for(int o=0;o<itboot;o++)//iteration du bootstrap (bugg pour itboot = 3)
{
  //Hetoile et Retoile echantillons obtenue par tirage avec remise
  //Hetoile contient des lignes de H, une ligne de H peut etre mise plusieurs fois dans Hetoile
  //nb_part_etoile = permutation de nb_part3
 
  for (i=0;i<nHommes2;i++)
 {
   int al=aleat(nHommes2);
   Hetoile[i] = new int [2*nb_rap2[al]+2];
   Retoile[i] = new int [2];
   Retoile[i][0] = R[al][0];
   Retoile[i][1] = R[al][1];
   nb_part_etoile[i] = nb_rap2[al];
   for (int k=0;k<2*nb_rap2[al]+2;k++)
   {  
      Hetoile[i][k]=H[al][k];
   }
 
 }
 
 //optimisation par la methode du quadrillage pour retrouver les 4 proba de transmissison p1, p2, p3, p4
   
 proba_res = quadrillage (Hetoile,nb_et_part,Retoile, nHommes2,nb_part_etoile,x3)  
 
 for (i=0;i<nHommes2;i++)
 {
    delete Hetoile[i];
    delete Retoile[i];
 }
 
 resultat_bootstrap[o] = proba_res;
}
    delete [] Retoile;
    delete [] Hetoile;
 
//fin du main
 
 
 
//fct probaex2
 
void proba_ex2(double* pexmoy,int nb_et_part,int** H,int** R,int* nb_rap2, int nHommes2,double p1,double p2,double p3,double p4)
{
   double* Pex = new double [nHommes2];
   int ** Hsimpl = new int* [nHommes2];
   int* nb_partsimpl= new int[nHommes2];
   int* N01=new int [nHommes2];
   int* N10=new int [nHommes2];
   int* N11=new int [nHommes2];
   int** Np01 = new int* [nHommes2];
   int** Np10 = new int* [nHommes2];
   int** Np11 = new int* [nHommes2];
 
   int i;
   for (i=0;i<nHommes2;i++)
   {
     pexmoy[i]=0;
     nb_partsimpl[i]=0;
   }
 
   int f;int l=1;
 
   //boucle 400 fois pour faire dans pexmoy une moyenne des proba obtenues dans Pex
     
   for(int j=0;j<nb_et_part;j++)
   {
     //fct qui remplit H
     tirage_etat_partenaire(H,nHommes2,nb_rap2);
 
     //simlification de H en Hsimpl et de nb_rap2 en nb_partsimpl et calcul de N01, N10 et N11
 
     for ( i=0;i<nHommes2;i++)
     {
        f=0;
        N01[i]=0;
        N10[i]=0;
        N11[i]=0;
 
        for( int k=1;k<=nb_rap2[i];k++)
        {
           if ((H[i][2*k]==0) && (H[i][2*k+1]==0))
            {;
            }
           else if ((H[i][2*k]==H[i][0]) && (H[i][2*k+1]==H[i][1]))
           {;}
           else{f++;}
        }
 
         Hsimpl[i] = new int[2*f+2];
         Hsimpl[i][0] = H[i][0];
         Hsimpl[i][1] = H[i][1];
         nb_partsimpl[i]=f;
         Np01[i] =  new int [f];
/*BUGG*/ Np10[i] =  new int [f];
         Np11[i] =  new int [f];
         l=1;
 
         for (int j1=1;j1<=nb_rap2[i];j1++)
         {    
            if ((H[i][2*j1]==0) && (H[i][2*j1+1]==0))
            {;
            }
            else if ((H[i][2*j1]==H[i][0]) && (H[i][2*j1+1]==H[i][1]))
            {;
            }
 
            else
            {
                Hsimpl[i][2*l]=H[i][2*j1];
                Hsimpl[i][2*l+1]=H[i][2*j1+1];
                l++;
 
                if ((H[i][2*j1]==1) && (H[i][2*j1+1]==0))
                {N10[i]++;
                }
                else if ((H[i][2*j1]==0) && (H[i][2*j1+1]==1))
               {N01[i]++;
               }
               else if ((H[i][2*j1]==1) && (H[i][2*j1+1]==1))
               {N11[i]++;
               }
            }
        }
 
    }
 
    //calcul de Np01
    for( i=0;i<nHommes2;i++)
    {
        for (int l1=0;l1<nb_partsimpl[i];l1++)
        {
             Np01[i][l1]=0;
             Np10[i][l1]=0;
             Np11[i][l1]=0;
 
        }
 
        for(int j3=1; j3<nb_partsimpl[i];j3++)
        {
           for (int k=1;k<=j3;k++)
           {
             if ((Hsimpl[i][2*k]==0) && (Hsimpl[i][2*k+1]==1))
             {
                   Np01[i][j3]++;
             }
           }
        }
 
    }
 
    //calcul de Np10
    for( i=0;i<nHommes2;i++)
    {
        for(int j3=1; j3<nb_partsimpl[i];j3++)
        {
            for (int k=1;k<=j3;k++)
            {    
               if ((Hsimpl[i][2*k]==1) && (Hsimpl[i][2*k+1]==0))
               {
                   Np10[i][j3]++;
               }
            }    
        }
    }
 
 
    //calcul de Np11
    for( i=0;i<nHommes2;i++)
    {
        for(int j3=1; j3<nb_partsimpl[i];j3++)
        {
            for (int k=1;k<=j3;k++)
            {
                if ((Hsimpl[i][2*k]==1) && (Hsimpl[i][2*k+1]==1))
                {
                    Np11[i][j3]++;
                }
            }
        }
    }
 
 
    //calcul des proba  
proba_ex(Pex,N01,N10,N11,Np01,Np10,Np11,Hsimpl,R,nHommes2, nb_partsimpl,p1,p2,p3,p4);
 
    for ( i=0;i<nHommes2;i++)
    {
    //suppression des pointeurs crees dans la boucle en j avant de commencer l'iteration suivante
            delete [] Hsimpl[i];
            delete [] Np01[i];              
            delete [] Np10[i];
            delete [] Np11[i];
            pexmoy[i]=pexmoy[i]+Pex[i];//somme des proba obtenues
    }
}
 
    //Moyenne des differentes proba obtenues
    for( i=0;i<nHommes2;i++)
    {
        pexmoy[i]=pexmoy[i]/nb_et_part;
    }    
 
    delete [] Pex;
    delete [] N01;delete [] N10;delete [] N11;
    delete [] Hsimpl;delete [] nb_partsimpl;
    delete [] Np01;delete [] Np10;delete [] Np11;
 
}
 
 
C'est un peu long mais vu que je ne sais pas d'ou peut venir le bug, je prefere t'ecrire la fct entiere...