c++ et delete

Bonjour !

voila, j'ai un probleme lorsque je veux faire des delete sur des tableauz.

J'ai une fonction du type :
float* function(param, int n){
   float* l = new float[n];
   float* m = new float[n];
   float* y = new float[n];
   float* u = new float[n];

   corps de la fonction ou je manipule tout ca

   delete[] l;
   delete[] m;
   delete[] y;
   return u;
}
Ceci compile mais donne une erreur a l'execution : Debug Error, damage after normal block ...
Ca vient des delete mais je ne sais pas pourquoi. Comment faire mon delete sans provoquer d'erreur ? Pourquoi ceci ne marche pas

salut,
donne le reste de ta fonction.
regarde aussi si t'as pas d'overflow (si tu fais float* m = new float[n], tu peux utiliser m[0] à m[n-1]. m[n] n'est pas valide !!!)

a+

je ne pense pas que le probleme se situe dans le corp de la fonction car sans les delete je n'ai pas de probleme d'execution et qu'avec les delete le probleme se pose dans plusieures de mes fonctions. Je pense que c'est plutot dans la declaration que ca se passe, cela dit, voici la fonction :

 float* function(float alpha[], float gamma_l[], float gamma_u[], float d[], int n, int nbrow,int nbcolumn)
 {
  float*l;
  float*m;
  float*y;
  l = new float[n-nbcolumn];
  m = new float[n];
  y = new float[n];
  float* u = new float[n];

  for(int x=0;x<nbcolumn;x++){
   m[x*nbrow+0]=alpha[x*nbrow+0];
   for(int i=0;i<nbrow-1;i++){
    l[x*nbrow+i] = gamma_l[x*nbrow+i]/m[x*nbrow+i];
    m[x*nbrow+i+1] = alpha[x*nbrow+i+1]-l[x*nbrow+i]*gamma_u[x*nbrow+i];
   }
   
   y[x*nbrow+0] = d[x*nbrow+0];
   for(int j =1;j<nbrow;j++){
    y[x*nbrow+j] = d[x*nbrow+j] - l[x*nbrow+j-1]*y[x*nbrow+j-1];
   }

   u[x*nbrow+nbrow-1] = y[x*nbrow+nbrow-1]/m[x*nbrow+nbrow-1];
   for(int k = nbrow-2;k>=0;k--){
    u[x*nbrow+k] = (y[x*nbrow+k]-gamma_u[x*nbrow+k]*u[x*nbrow+k+1])/m[x*nbrow+k];
   }
  }
  /*delete[] l;
  delete[] m;
  delete[] y;*/
  return u;
 }

comme prévu, ya sans doute overflow:
l[x*nbrow+i] = ...
que valent n, nbrow et nbcolumn ? j'ai supposé que n = nbrow * nbcolumn

essaye avec ce code la:

float* function(float alpha[], float gamma_l[], float gamma_u[], float d[], int n, int nbrow,int nbcolumn)
{
   float*l;
   float*m;
   float*y;
   l = new float[n-nbcolumn];
   m = new float[n];
   y = new float[n];
   float* u = new float[n];

   for(int x=0;x<nbcolumn;x++)
   {
      ASSERT(x*nbrow < n); // verifie les bornes pour m
      m[x*nbrow+0]=alpha[x*nbrow+0];
      for(int i=0;i<nbrow-1;i++)
      {
         ASSERT(x*nbrow+i < n-nbcolumn); // pour l
         l[x*nbrow+i] = gamma_l[x*nbrow+i]/m[x*nbrow+i];
         ASSERT(x*nbrow+i+1 < n); // pour m
         m[x*nbrow+i+1] = alpha[x*nbrow+i+1]-l[x*nbrow+i]*gamma_u[x*nbrow+i];
      }
      y[x*nbrow+0] = d[x*nbrow+0];
      for(int j =1;j<nbrow;j++)
      {
         ASSERT(x*nbrow+j < n); // pour y
         ASSERT(x*nbrow+j-1 < n-nbcolumn); // pour l
         y[x*nbrow+j] = d[x*nbrow+j] - l[x*nbrow+j-1]*y[x*nbrow+j-1];
      }
      ASSERT( x*nbrow+nbrow-1 < n);
      u[x*nbrow+nbrow-1] = y[x*nbrow+nbrow-1]/m[x*nbrow+nbrow-1];
      for(int k = nbrow-2;k>=0;k--)
      {
         ASSERT(x*nbrow+k < n);
         u[x*nbrow+k] = (y[x*nbrow+k]-gamma_u[x*nbrow+k]*u[x*nbrow+k+1])/m[x*nbrow+k];
      }
   }
   delete[] l;
   delete[] m;
   delete[] y;
   return u;
}


ca t'enverra une erreur Debug assertion failed si tu allais dépasser les bornes de tes tableaux de float.

au fait, quand tu manipules les tableaux de cette maniere, tu fais du C et non du C++ !!
en C++, il y a le type vector pour gerer les tableaux, qui permet notamment de controler si tu débordes, et qui libere tout seul la memoire.

#include <vector>
using namespace std;

vector<float> gamma_u;
...
gamma_u.resize(n);
gamma_u[i] = 3.14; // pas de controle des bornes
//ou bien:
gamma_u.at(i) = 3.14; // lance une exception si i dépasse n-1

etc.

il y avait effectivement un probleme dans les indices, merci !

Le plus etonnant c'est que malgre ce probleme, le programme avait des resultats coherents, j'ai donc pense a des problemes de declaration et non aux indices !
Merci !
Al