IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Problème avec segmentation fault


Sujet :

C

  1. #1
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut Problème avec segmentation fault
    Bonjour,

    J'ai écrit un code source en c et en Opengl afin de générer un terrain. Le programme se compile, mais lors de l'exécution, il m'affiche segmentation fault. J'ai lancer le debugger et voici le résultat du debugger: erreur au niveau de cette ligne

    glVertex3f(posi,m.heightmap[i][j]*alt,posj);

    et que la fonction dessine_sol (x=-1 et y=-2)

    Aidez-moi

  2. #2
    Rédacteur

    Avatar de ram-0000
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    Mai 2007
    Messages
    11 517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 62
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Mai 2007
    Messages : 11 517
    Par défaut
    J'ai l'impression que tu "jardines" hors de ton jardin et que tu as explosé les valeurs de tes indices.

    • quelle est la taille du tableau m.heightmap ?
    • Quelle sont les valeurs de i et de j lorsque ton programme se plante ?
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

  3. #3
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut Program received signal SIGSEGV, Segmentation fault.
    Quand je lance le debugger par le menu Debug-> Start, voici ce qui m'affiche:

    Building to ensure sources are up-to-date
    Build succeeded
    Selecting target:
    Debug
    Adding source dir: I:\Informatique\Technique de rendu\paysage\
    Adding source dir: I:\Informatique\Technique de rendu\paysage\
    Adding file: bin\Debug\paysage.exe
    Starting debugger:
    done
    Registered new type: wxString
    Registered new type: STL String
    Registered new type: STL Vector
    Setting breakpoints
    Debugger name and version: GNU gdb 6.7.50.20071127
    Child process PID: 632
    Program received signal SIGSEGV, Segmentation fault.
    At I:/Informatique/Technique de rendu/paysage/terrain.c:233

    En plus, une autre fenetre qui s'appelle Call Stack où il y a le nom des fonctions indiquant la présence des erreurs grace aux numéros de lignes.

    -dessine_sol(x=-1, y=-2)
    -choisir_texture()
    -display()
    -glutMainLoop()
    -glutMainLoop()
    -main(argc=1, argv=0x3e2638)

    choisir_texture() et displaya() appellent dessine_sol.
    glutMainLoop est appelée dans main.

    Quand je lance par le menu Debuf->Debugging windows->Watches, une fenetre qui affiche ceci :

    Local variables
    m
    name=0x47fa0000 <Adress 0x47fa0000 out of bounds>
    name_texture=0x0
    heightmap=0x0
    texchrg=0x0

    i=0
    j=0
    posi=-5121
    posj=-10240

    Function Arguments
    x=-1
    y=-2

    Je n'ai pas affiché le code source car il est assez long, cependant si vous voulez que je l'affiche pour mieux éclaircir et m'aider à trouver les erreurs, je l'afficherai dans le prochain message.

    Merci d'avance de votre aide et pour ceux qui s'intéressent à résoudre mon problème.

  4. #4
    Invité
    Invité(e)
    Par défaut
    Bonjour, tu as une double erreur: la principale est que la structure m n'a pas été malloquée, donc quand tu essayes d'accéder à un élément le programme segfault immediatement. Ensuite, les variables i et j sont négatives, or les index d'un tableau doivent etre positifs, d'où une erreur que tu auras dès que tu auras corrigé la première!

  5. #5
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut
    m est déclarée dans cette fonction, n'est-ce pas:

    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
    /*Charger une heightmap, remplit la matrice d'altitude, puis cree la matrice de couleurs et genere la texture correspondante */
    multitexture creer_texture(multitexture m){
     
        int i,j;
        int k,l;
        Image *image = (Image *) malloc(sizeof(Image));
        ImageLoad(m.name, image);
        //remplisage de la matrice d'altitude 'mt.heightmap[][]':
        m.heightmap=(float**)malloc(SIZE*sizeof(float*));
        for (i=SIZE-1,k=0;i>0;i--,k++){
            m.heightmap[k]=(float*)malloc (SIZE*sizeof(float));
            for(j=0,l=0;j<SIZE*3;j+=3,l++){
                m.heightmap[k][l]=image->data[i*image->sizeX*3+j];
                pourcentage[k][l]=Terrain_RemplitPart(m.heightmap[k][l]);//calcul de la matrice de couleur
            }
        }
       generer_texture(m);//generation de la nouvelle texture
       free(image);
       return m;
    }

  6. #6
    Invité
    Invité(e)
    Par défaut
    En voyant ton code, je viens de comprendre que name est une variable de ta structure m. Selon gdb, name n'a pas été initialisé puisqu'il te dit que l'adresse est outofbounds, d'où certainement des erreurs ensuite. Teste la valeur de m et de ses champs à la fin de la fonction de remplissage. Et teste le retour de malloc!

  7. #7
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut
    J'ai dépose 3 fichiers: Loader.c, Loader.h et Terrain.c

    C'est le fichier Loader.c

    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    /*Charger une texture*/
    GLuint Charger_Texture(char *filename, GLuint * texchrg,int n){
        Image *image;
        image = (Image *) malloc(sizeof(Image));
        ImageLoad(filename, image);
        texchrg=(GLuint*)malloc (sizeof(GLuint));
        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, texchrg);
        glBindTexture(GL_TEXTURE_2D, *texchrg);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE, image->data);
        free(image->data);
        free(image);
        return *texchrg;
    }
     
     
    /*Chargement des textures de base des heightmaps*/
    void init_texture(){
        neige = (Image *) malloc(sizeof(Image));
        roche = (Image *) malloc(sizeof(Image));
        prairie = (Image *) malloc(sizeof(Image));
        eau = (Image *) malloc(sizeof(Image));
     
        ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/neige.bmp", neige);
        ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/roche.bmp", roche);
        ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/grass.bmp", prairie);
        ImageLoad("I:/Informatique/Technique de rendu/paysage/Images/eau.bmp", eau);
    }
     
     
    /*Calcul des couleurs pour chaque pixel des heightmaps selon la hauteur*/
    participation Terrain_RemplitPart(float haut){
        participation part;
        //p:prairie, r:roche, n:neige, e:eau,
        int add;
        add = haut + (rand()%25)-15; //un petit peu de hasard
            if(add<0) add = 0;
            if(add>255) add = 255;
            haut = add;
     
        if(haut<5.0){//les faible altitudes correspondent a la texture d'eau
                part.p=0.0;
                part.r=0.0;
                part.n=0.0;
                part.e=1.0;
     
            }
     
            else if(haut<20.0){// melange d'eau et de prairie
                part.p = (haut-5.0)/10.0;
                part.r = 0.0;
                part.n = 0.0;
                part.e = 1.0 - (haut-5.0)/10.0;
     
            }
            else if(haut<60.0){// en moyenne altitude on a de la pairie
                part.p = 1.0;
                part.r = 0.0;
                part.n = 0.0;
                part.e = 0.0;
     
            }
            else if(haut<130.0){// melange de prairie et de roche
                part.p = 1.0 - (haut-60.0)/70.0;
                part.r = (haut-60.0)/70.0;/*Charger une texture*/
                part.n = 0.0;
                part.e = 0.0;
     
            }
            else if(haut<180.0){// en haute altitude on a de la roche
                part.p = 0.0;
                part.r = 1.0;
                part.n = 0.0;
                part.e = 0.0;
     
            }
            else if(haut<220.0){// melange de roche et de neige
                part.p = 0.0;
                part.r = 1.0 - (haut-180.0)/40.0;
                part.n = (haut-180.0)/40.0;
                part.e = 0.0;
     
            }
     
            else{// et en tres haute altitude on a de la neige
                part.p = 0.0;
                part.r = 0.0;
                part.n = 1.0;
                part.e = 0.0;
     
            }
     
        return part;
    }
     
     
    /*Charger une heightmap, remplit la matrice d'altitude, puis cree la matrice de couleurs et genere la texture correspondante */
    multitexture creer_texture(multitexture m){
     
        int i,j;
        int k,l;
        Image *image = (Image *) malloc(sizeof(Image));
        ImageLoad(m.name, image);
        //remplisage de la matrice d'altitude 'mt.heightmap[][]':
        m.heightmap=(float**)malloc(SIZE*sizeof(float*));
        for (i=SIZE-1,k=0;i>0;i--,k++){
            m.heightmap[k]=(float*)malloc (SIZE*sizeof(float));
            for(j=0,l=0;j<SIZE*3;j+=3,l++){
                m.heightmap[k][l]=image->data[i*image->sizeX*3+j];
                pourcentage[k][l]=Terrain_RemplitPart(m.heightmap[k][l]);//calcul de la matrice de couleur
            }
        }
       generer_texture(m);//generation de la nouvelle texture
       free(image);
       return m;
    }
     
     
    /*Genere une texture en fonction de la matrice de couleurs*/
    void generer_texture(multitexture m){
        int i, j, k, l, z, I;
        Image  *image = (Image *) malloc(sizeof(Image));
        ImageLoad(m.name, image);
        for (i=SIZE-1,k=0;i>0;i--,k++){
            for(j=0,l=0;j<SIZE*3;j+=3,l++){
                z=(j%prairie->sizeY);
                I=(i%prairie->sizeX)*prairie->sizeX*3+z-z%3;
                //calcul des couleurs de chaque pixel de la heightmap grace a la matrice de couleurs precalculee
                rouge[k][l] = pourcentage[k][l].p *prairie->data[I]
                            + pourcentage[k][l].r *roche->data[I]
                            + pourcentage[k][l].n *neige->data[I]
                            + pourcentage[k][l].e *eau->data[I]
     
                            ;
                vert[k][l]  = pourcentage[k][l].p *prairie->data[I+1]
                            + pourcentage[k][l].r *roche->data[I+1]
                            + pourcentage[k][l].n *neige->data[I+1]
                            + pourcentage[k][l].e *eau->data[I+1]
     
                            ;
                bleu[k][l]  = pourcentage[k][l].p *prairie->data[I+2]
                            + pourcentage[k][l].r *roche->data[I+2]
                            + pourcentage[k][l].n *neige->data[I+2]
                            + pourcentage[k][l].e *eau->data[I+2]
     
                            ;
                //on memorise ces nouvelles couleurs dans l'image
                image->data[(SIZE-i)*image->sizeX*3+j]=(rouge[k][l]);
                image->data[(SIZE-i)*image->sizeX*3+j+1]=(vert[k][l]);
                image->data[(SIZE-i)*image->sizeX*3+j+2]=(bleu[k][l]);
            }
        }
        //enfin on enregistre la texture
        ImageSave(m.name_texture,image);
        free(image);
    }
    Le fichier Loader.h

    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    #define SIZE 512 //taille des images de multitexture
    #define N 50    //taille de la heihtmap: 50*50*SIZE
     
    //FONCTIONS PERMETTANT:
    //-le chargemet des images et textures bmp
    //-la sauvegarde d'images bmp
    //-le chargement de heightmaps bmp
    //-la creation de nouvelles textures en fonction des heightmaps
     
     
    //Structure stockant les données d'une image bmp
    typedef struct {
        unsigned long sizeX;
        unsigned long sizeY;
        GLubyte *data;
    } Image;
     
    //Structure correspondant aux participations des textures de base pour un pixel d'une heightmap
    struct participation {
         float p;//pourcentage de la texture 'prairie'
         float r;//pourcentage de la texture 'roche'
         float n;//pourcentage de la texture 'neige'
         float e;//pourcentage de la texture 'eau'
     
    };
    typedef struct participation participation;
     
    /*Structure permettant de stocker les informations necessaires a l'exploitaton d'une heightmap*/
    typedef struct multitexture{
        char *name;               //son nom pour le chargement de la heightmap
        char *name_texture;       //nom de la texture generee
        float **heightmap;        //la matrice contenant les altitudes correspondant aux niveaux de gris
        GLuint *texchrg;          //la texture "name_texture" chargee
    } multitexture;
     
     
    /*LES FONCTIONS*/
        //Les images et textures bmp
    static unsigned int getint(FILE *);
    static unsigned int getshort(FILE *);
    int ImageLoad(char *, Image *);
    int ImageSave(char *filename, Image *image);
    GLuint Charger_Texture(char *, GLuint * ,int );
     
        //Exploitation des multitextures pour les heightmaps
    void init_texture();
    multitexture creer_texture(multitexture);
    void generer_texture(multitexture);
     
        /*LES VARAIBLES*/
    int HEIGHTMAP[N][N];     //La heightmap
    static GLuint *CIEL;     //structure ciel
     
    Image *neige,*roche,*prairie, *eau;//textures de base pour les heightmaps
    multitexture mt[5];//tableau de multitexture pour les heightmaps
    int nbtexture;//nombre de textures pour les heightmaps
    participation pourcentage[SIZE][SIZE];
    float rouge[SIZE][SIZE];//tableau contenant les valeurs de la couleur rouge pour chaque pixel de la texture generee
    float vert[SIZE][SIZE];//tableau contenant les valeurs de la couleur vert pour chaque pixel de la texture generee
    float bleu[SIZE][SIZE];//tableau contenant les valeurs de la couleur bleue pour chaque pixel de la texture generee
    Le fichier Terrain.c

    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
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    //dessine une multitexture correctement, en respectant les altitudes
     void dessine_sol(int x, int y){
        multitexture m;
        int i,j;
        float posi,posj;
     
        //on calcule la multitexture correpondante a HEIGHTMAP[x][y]
        m=mt[HEIGHTMAP[x][y]];
     
        glBindTexture(GL_TEXTURE_2D, m.texchrg);//on utilise la texture qui lui est associee
        glPushMatrix();
            glEnable(GL_TEXTURE_2D);
     
            //pour chaque pixel (i,j) de la multitexture:
            for(i=0 ,posi=taille*x;i<SIZE-2;i++,posi+=pas){
                for(j=0, posj=taille*y;j<SIZE-1;j++,posj+=pas){
     
                    //on dessine les deux triangles formés par le carre: (i,j),(i,j+1),(i+1,j),(i+1,j+1)
                    glBegin(GL_TRIANGLE_STRIP);
                        glTexCoord2f( ((float) j)/SIZE, ((float) i)/SIZE);
     
                            //l'erreur se situe sur cette ligne (glVertex3f)
                            glVertex3f(posi,m.heightmap[i][j]*alt,posj);
     
                        glTexCoord2f( ((float) j+1)/SIZE, ((float) i)/SIZE);
                            glVertex3f(posi,m.heightmap[i][j+1]*alt,posj+pas);
                        glTexCoord2f( ((float) j+1)/SIZE, ((float) i+1)/SIZE);
                            glVertex3f(posi+pas,m.heightmap[i+1][j+1]*alt,posj+pas);
     
                        glTexCoord2f( ((float) j)/SIZE, ((float) i)/SIZE);
                            glVertex3f(posi,m.heightmap[i][j]*alt,posj);
                        glTexCoord2f( ((float) j+1)/SIZE, ((float) i+1)/SIZE);
                            glVertex3f(posi+pas,m.heightmap[i+1][j+1]*alt,posj+pas);
                        glTexCoord2f( ((float) j)/SIZE, ((float) i+1)/SIZE);
                            glVertex3f(posi+pas,m.heightmap[i+1][j]*alt,posj);
                    glEnd();
                }
            }
    	glDisable(GL_TEXTURE_2D);
        glPopMatrix();
    }
     
    //Trouve une multitexture dans les environs, la selectionne pour la dessiner
    void choisir_texture(){
        int i,j,x,y;
        x=(int)(xcam/taille);
        y=(int)(ycam/taille);
        for(i=x-5;i<=x+5;i++)
            for(j=y-5;j<=y+5;j++)
                if (HEIGHTMAP[i][j] != 0){
                    x=i;
                    y=j;
     
                     //La deuxième erreur se trouve sur dessine_sol
                    dessine_sol(x,y);
                    return;
                }
        dessine_sol(x,y);
        return;
    }
     
     
    /*fonction d'affichage*/
    //dessine tous les elements du programme, repositionne la camera
    void display(){
        int i,j;
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
    /* Rotation du sol autour d'un axe vertical*/
            glRotatef(angleZ,0.0,0.0,1.0);
            /* Position de la camera */
              gluLookAt(xcam, ycam, zcam, xtarget, ytarget, ztarget, 0.0, 0.0, 1.0);
     
    //dessin des sols plats
            for (i=-50;i<N+50;i++)
                for (j=-50;j<N+50;j++)
                    if(i<0 || j<0 || i>= N || j>=N)
                    dessineSolPlat(i,j,mt[HEIGHTMAP[0][0]]);
                    else
                       dessineSolPlat(i,j,mt[HEIGHTMAP[i][j]]);
           //La troisème erreur se situe sur choisir_texture         
            choisir_texture();//selection d'une multitexture et dessine celle-ci en fonction de ses altitudes
            glTranslatef(xtarget,ytarget,ztarget);
            glPushMatrix();
                dessineCiel();
     
    glPopMatrix();
        glPopMatrix();
        glFlush();
        FPS();
        glutSwapBuffers();
    }
     
     
    //Fonction Main
    //l'erreur est sur le main
    int main(int argc, char *argv[]){
     
        /*creation de la fenetre*/
        glutInit(&argc, argv);
        glutInitWindowSize(500,500);
        glutInitWindowPosition(100,100);
        glutCreateWindow("PAYSAGE NATUREL");
     
        /*Fonctions d'initialisation*/
        init_texture();
        initialiser();
     
        /*Fonctions de rappel*/
        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
        glutDisplayFunc(display);
        glutMotionFunc(mouseMotion);
        glutKeyboardFunc(keyboard_1);
        glutSpecialFunc(keyboard_2);
        glutReshapeFunc(reshape);
     
        /*lancement de la boucle d'attente*/
    // L'erreur est sur glutMainLoop
        glutMainLoop();
        return 0;
    }
    Dans le fichier Terrain.c, j'ai affiché que quelques fonctions concernées par les erreurs, et non pas tout le code source (le positionnement de la caméra, ses angles de rotation, la fonction initailiser, etc...)

  8. #8
    Invité
    Invité(e)
    Par défaut
    Il faut que tu essayes ce que je t'ai conseillé dans mon précédent post, que tu testes tous les malloc, et aussi essaye d'envoyer m en tant que pointeur dans les fonctions où tu fais des malloc sur des champs de cette structure, ca vient peut-etre de là.

  9. #9
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut
    Comment tester tous les malloc?

    aussi essaye d'envoyer m en tant que pointeur dans les fonctions où tu as fais des malloc sur des champs de cette structure
    J'ai 3 structures avec leurs champs:

    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
    //Structure stockant les données d'une image bmp
    typedef struct {
        unsigned long sizeX;
        unsigned long sizeY;
        GLubyte *data;
    } Image;
     
    //Structure correspondant aux participations des textures de base pour un pixel d'une heightmap
    struct participation {
         float p;//pourcentage de la texture 'prairie'
         float r;//pourcentage de la texture 'roche'
         float n;//pourcentage de la texture 'neige'
         float e;//pourcentage de la texture 'eau'
     
    };
    typedef struct participation participation;
     
    /*Structure permettant de stocker les informations necessaires a l'exploitaton d'une heightmap*/
    typedef struct multitexture{
        char *name;               //son nom pour le chargement de la heightmap
        char *name_texture;       //nom de la texture generee
        float **heightmap;        //la matrice contenant les altitudes correspondant aux niveaux de gris
        GLuint *texchrg;          //la texture "name_texture" chargee
    } multitexture;
    J'ajoute que *m comme paramètre dans les fonctions où j'ai fais malloc? tu fais allusion à ça je pense?

  10. #10
    Invité
    Invité(e)
    Par défaut
    Oui, envoie m en tant que pointeurs aux fonctions où tu l'utilises pour que les changements soient répercutés. Par exemple pour créer-texture envoie multitexture *m. Pour vérifier un malloc, il suffit de faire pour voir si l'adresse donnée est égale à NULL. De facon générale, tous les appels systèmes doivent etre vérifiés.

  11. #11
    Membre confirmé Avatar de Gobelins
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Décembre 2007
    Messages
    171
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur

    Informations forums :
    Inscription : Décembre 2007
    Messages : 171
    Par défaut
    C'était un problème qui est du aux paramètres de la caméra. J'ai changé les valeurs du positionnement de la caméra. Le programme s'éxécute, et génère un terrain qui s'affiche mais avec des pixels plus au moins visibles. Je pense que je dois encore règler les paramètres de gluLookAt.

Discussions similaires

  1. Problème de segmentation fault
    Par skysee dans le forum C++
    Réponses: 4
    Dernier message: 25/01/2009, 10h06
  2. problème de "segmentation fault"
    Par reivilouadivad dans le forum C++
    Réponses: 2
    Dernier message: 05/03/2008, 08h54
  3. problème de segmentation fault
    Par cheff dans le forum Débuter
    Réponses: 4
    Dernier message: 21/02/2008, 11h26
  4. Réponses: 6
    Dernier message: 01/11/2007, 18h44
  5. [Socket SSL] problème de "Segmentation fault"
    Par jesus144 dans le forum Programmation et administration système
    Réponses: 1
    Dernier message: 09/03/2007, 19h50

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo