problème avec un new[]

**f56bre** · 11/11/2006, 22h00

Salut,

J'ai une classe contenant un pointeur que j'initialise dans le constructeur à NULL. Une autre classe contient un pointeur vers ma première classe ainsi qu'une méthode dans laquelle j'alloue la mémoire nécessaire à mon premier pointeur. Cette allocation fonctionne très bien pour un tableau de 300 floats mais quand je passe à 3000 ça fait planter le programme. J'avoue que je ne vois pas où est le problème.

ps : voici la ligne qui plante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

buffer->ptr = new float[ 3000 ];

buffer étant bien sûr une istance de ma première classe.

Invité · 11/11/2006, 22h12

Cette ligne est évidemment juste. Tu t'attendais à quoi ? On n'est pas dans ta tête, on ne va pas indiquer les erreurs de ton code en lisant juste cette ligne.

Merci de réfléchir avant de poser une question, il est évident que dans l'état actuel ça sert à rien.

Pour ce qui est du "plantage" (sur lequel on ne sait rien non-plus), essaye un débuggeur.

**f56bre** · 11/11/2006, 22h19

Il est évident que j'attend ici des retours d'expériences sur ce genre d'erreurs pour ceux qui connaissent les problèmes qui peuvent advenir avec l'opérateur new et les compositions de classes. Si t'en as pas en stock tant pis je m'en passerais...

**thewho** · 11/11/2006, 23h02

Bonjour,

Envoyé par f56bre

Il est évident que j'attend ici des retours d'expériences sur ce genre d'erreurs pour ceux qui connaissent les problèmes qui peuvent advenir avec l'opérateur new et les compositions de classes. Si t'en as pas en stock tant pis je m'en passerais...

Et pourtant, quoi que tu puisses en penser, remram44 a raison.

A moins que tu nous prennes pour des devins, auquel cas, ce sera 60 € la réponse.

Je reprends donc la remarque de remram44 à mon compte : comment veux-tu qu'on t'aide à la vue de la seule ligne que tu daignes nous montrer, et qui, comme tu le sais très bien, est syntaxiquement correcte ?

**khayyam90** · 11/11/2006, 23h58

j'ai oublié ma boule de cristal mais je vais tenter : buffer est-il alloué ? S'il ne l'est pas, un appel à buffer->ptr donne un plantage.

**koala01** · 12/11/2006, 00h47

Salut,

Syntaxiquement, la ligne est des plus correcte...

En se basant sur cette seule ligne, il faut bien prendre conscience que l'on n'a aucune information qui nous permette de t'aider...

Comme indiqué par khayyam90

, une des premières idées qui viennent en tete est le fait que buffer n'est pas alloué...

La deuxième idée qui peut venir en tete est, tout simplement, l'impossiblité du système de trouver un espace mémoire contigu de 3000 floats... (ce qui fait, selon les compilateurs, pas loin de 3000*64 bits...soit... 187ko environ)

Maintenant, si tu veux plus de précision, sois sympa, et donne nous un code minimum compilable qui nous permette de reproduire le phénomène

**f56bre** · 12/11/2006, 09h59

Voici mon code

La classe Buffer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class Buffer
{
    public:
 
        float * ptr;
        int taille_ptr;
 
 
    public:
        Buffer();
        ~Buffer();
 
};

Le constructeur et le destructeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Buffer::Buffer()
{
    ptr = NULL;
    taille_ptr = 0;
}
 
 
Buffer::~Buffer()
{
    delete[] ptr;
}

Voici la classe Bloc qui contient le pointeur vers la classe Buffer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
class Bloc{
 
    private:
 
        /* les coordonnées en x et y servent à savoir ou est placé le bloc
           sur lequel on travail */
        unsigned int coordonnee_x;
        unsigned int coordonnee_y;
 
        SDL_Surface * heightmap;
 
        Buffer * buffer;
 
    public:
 
 
        Bloc( unsigned int coord_x = 0 , unsigned int coord_y = 0 );
        ~Bloc();
 
        int Rempli_buffer( unsigned int pas );
 
        int Charge_heightmap( char * source );
 
};

Et voici la fonction qui pose problème

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
int Bloc::Rempli_buffer( unsigned int pas )
{
    int nbr_mesh,i,j;
 
    if( buffer == NULL ) buffer = new Buffer;
 
    if( pas != 0 )
    {
        // calcul du nombre de mesh
        nbr_mesh = (int)heightmap->w/pas;
 
        buffer->ptr = new float[ (nbr_mesh+1)*(nbr_mesh+1)*3];
        buffer->taille_ptr = 0;
 
        for( j=0 ; j<=nbr_mesh ; j++ )
        {
            for( i=0 ; i<=nbr_mesh ; i++)
            {
                buffer->taille_ptr += 3;
 
                buffer->ptr[ 3*i + j*3*(nbr_mesh+1) ] = (float)i*pas;
                buffer->ptr[ 3*i + j*3*(nbr_mesh+1) + 1 ] = (float)j*pas;
                buffer->ptr[ 3*i + j*3*(nbr_mesh+1) + 2 ] = 0.0; 
            }
        }
 
    }
 
    return 0;
 
}

Lors de l'appel de cette dernière fonction une image .bmp de 1024*1024 est chargée dans heightmap et je prend un pas de 16, on a donc nbr_mesh = 64.
Sinon au niveau du constructeur de la classe Bloc rien de spécial, je met tous les pointeurs (dont buffer) à NULL.

**zenux** · 12/11/2006, 11h24

Salut,

A mon avis, il ne passe pas dans cette condition : if( buffer == NULL ) buffer = new Buffer;

Initialise buffer à NULL dans le constructeur de Bloc.

**f56bre** · 12/11/2006, 13h05

Justement j'initialise buffer à NULL dans le constructeur de Bloc mais pour être sûr qu'il passe bien dans la condition j'ai ajouté un fprintf(stderr,"passe ici"); et ... il passe bien dans le if.

**Médinoc** · 12/11/2006, 13h08

tu devrais vérifier si le new ne lance pas une exception std::bad_alloc (oui, je ne sais pas qui a eu cette idée géniale, mais le new par défaut ne renvoie plus NULL si l'allocation échoue...

**f56bre** · 12/11/2006, 13h36

J'ai échangé la ligne d'allocation par ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
try
{
 
     buffer->ptr = new float[ (nbr_mesh+1)*(nbr_mesh+1)*3  ];
}
 
catch(bad_alloc& ex) 
{
      ofstream f("erreur.txt");
      if (f.is_open())
      {
            f << ex.what() << endl;
            f.close();
      }
 
}

Et pas de fichier erreur.txt créé (si je met un simple fprintf(stderr,...) dans le catch rien n'est écrit non plus). Il ne semble pas aller dans le catch.

**f56bre** · 12/11/2006, 14h29

J'ai entouré ce bloc par 2 fprintf(stderr,"ici"); et seul le premier est effectué. L'erreur est donc bien là

**loufoque** · 12/11/2006, 14h46

Bah apparemment, t'as un gestionnaire d'exceptions global merdique qui te les affiche pas.

**f56bre** · 12/11/2006, 15h02

Et il y a une solution pour ça?

**Médinoc** · 12/11/2006, 15h13

Récupérer localement l'exception avec un try/catch() et l'afficher...
Genre, ce qu'est supposé faire ton dernier code...

**f56bre** · 12/11/2006, 15h23

J'avoue que j'ai du mal à saisir la différence, peux-tu me donner un exemple?

**f56bre** · 12/11/2006, 16h04

J'ai essayé cette version là pour l'allocation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
buffer->ptr = new (nothrow) float [(nbr_mesh+1)*(nbr_mesh+1)*3];
if( buffer->ptr == 0 ) fprintf(stderr,"erreur d'allocation");

Mais toujours rien, pourtant le programme s'arrète avec un status 3 (code::blocks avec GCC).

**Médinoc** · 12/11/2006, 16h09

Cela peut également être le résultat d'une corruption du tas entre la dernière allocation et celle-ci.
Vérifie que tu n'as pas fait un dépassement de buffer ou un truc du genre...

**f56bre** · 12/11/2006, 17h09

L'allocation précedant celle-ci est celle de buffer (j'ai d'ailleur ajouté la même gestion d'erreur d'allocation que pour le ptr) et entre les 2 il n'y a rien.

J'ai recompilé avec les options de debug puis fait un "run to cursor" en plaçant ce dernier après la ligne d'allocation de ptr. J'ai alors des valeurs pour bloc et buffer mais pour ptr j'ai "No symbol "ptr" in current context". Si je place le curseur un peu plus loin (là ou je rempli le tableau ptr) j'ai logiquement une segmentation fault.