Mon code marche en mode debugging, mais pas en exécution !

Version imprimable

Bonjour,

Ayant pris peur devant le code immonde que j'avais pondu pour un projet datant de presque un an (résultant d'ajouts successifs), j'ai décidé de le refaire proprement (et d'en profiter pour faire des optimisations [de mémoire en partie, avec l'allocation dynamique] et quelques ajouts).

Cependant, alors même que je finis le composant audio, lors d'un test (puisque j'y introduis de nouveaux concepts, comme l'OO) en console je me rends compte que l'exécution engendre la fermeture du programme, retournant un nombre du type -1073741819, alors qu'en mode debugging, tout marche parfaitement !

Comment cela se fait-il ?

Je ne vois pas du tout d'où cela peut provenir, donc je vous fournis le code en entier...

Main.c :

Code:

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
#include "Music.h"
 
#include <stdio.h>
 
/* getch() */
#include <conio.h>
 
static void openPlaylist(Playlist *, const char *);
 
int main(void)
{
    Music music = CreateMusic(InitFmod());
    Playlist playlist = CreatePlaylist();
 
    openPlaylist(&playlist, "playlist.m3u");
 
    music.load(&music, playlist.list[2]);
 
    music.play(&music);
 
    /* getchar(), et même (getchar)() ne bloquent pas le thread... */
    getch();
 
    CloseFmod(music.sys);
    music.free(&music);
    playlist.free(&playlist);
 
    return 0;
}
 
static void openPlaylist(Playlist *playlist, const char *playlistFilePath)
{
    FILE *playlistFile = fopen(playlistFilePath, "r");
 
    if(playlistFile != NULL)
    {
        char path[MAX_PATH] = "";
        while(fgets(path, MAX_PATH, playlistFile) != NULL)
        {
            path[strlen(path)-1] = '\0'; /*Removes '\n'*/
            playlist->add(playlist, path);
        }
 
        fclose(playlistFile);
    }
}

Music.h :

Code:

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
#ifndef MUSIC_H_INCLUDED
#define MUSIC_H_INCLUDED
 
#ifndef __bool_true_and_false_are_defined
    #define bool int
    #define true 1
    #define false 0
#endif
 
/* DLL */
#include <windows.h>
#include <fmod/fmod.h>
 
FMOD_SYSTEM *InitFmod(void);
void CloseFmod(FMOD_SYSTEM *);
 
typedef enum Status
{
    PLAYING,
    STOPPED,
    PAUSED
}Status;
 
typedef struct Music
{
    FMOD_SOUND *stream;
    FMOD_CHANNEL *channel;
    FMOD_SYSTEM *sys;
 
    unsigned int (*getElapsedTime)(struct Music*);
    unsigned int (*getTotalTime)(struct Music*);
    void (*seek)(struct Music*, unsigned int);
    void (*load)(struct Music*, const char *);
    Status (*getStatus)(struct Music*);
    void (*play)(struct Music*);
    void (*stop)(struct Music *);
    void (*pause)(struct Music *, bool);
    void (*free)(struct Music*);
    unsigned int (*getVol)(struct Music*);
    void (*setVol)(struct Music*, unsigned int);
}Music;
 
Music CreateMusic(FMOD_SYSTEM*);
Music *NewMusic(FMOD_SYSTEM*);
 
typedef enum Mode
{
    SHUFFLE = 1 << 0,
    LOOP = 1 << 1
}Mode;
 
typedef struct Playlist
{
    void (*add)(struct Playlist*, const char*);
    void (*suppr)(struct Playlist*, unsigned int);
    void (*free)(struct Playlist*);
 
    char **list;
    unsigned int count;
 
    Mode mode;
}Playlist;
 
Playlist CreatePlaylist(void);
Playlist *NewPlaylist(void);
 
unsigned int GetMusicElapsedTime(Music*);
void SeekMusic(Music*, unsigned int);
unsigned int GetMusicTotalTime(Music*);
void LoadMusic(Music*, const char *);
Status GetMusicStatus(Music*);
void PlayMusic(Music*);
void StopMusic(Music *);
void PauseMusic(Music *, bool);
void FreeMusic(Music*);
void DeleteMusic(Music*);
void SetMusicVolume(Music*, float);
float GetMusicVolume(Music*);
 
void AddToPlaylist(Playlist*, const char*);
void SupprFromPlaylist(Playlist*, unsigned int);
void FreePlaylist(Playlist*);
void DeletePlaylist(Playlist*);
 
#endif

Music.c :

Code:

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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
#include "Music.h"
 
#include <string.h>
#include <stdlib.h>
 
FMOD_SYSTEM *InitFmod(void)
{
    FMOD_SYSTEM *sys;
 
    FMOD_System_Create(&sys);
    FMOD_System_Init(sys, 1, FMOD_INIT_NORMAL, NULL);
 
    return sys;
}
 
void CloseFmod(FMOD_SYSTEM *sys)
{
    FMOD_System_Close(sys);
    FMOD_System_Release(sys);
}
 
static void InitMusic(Music *music, FMOD_SYSTEM *sys)
{
    music->stream = NULL;
    music->channel = NULL;
    music->sys = sys;
 
    music->getElapsedTime = GetMusicElapsedTime;
    music->getTotalTime = GetMusicTotalTime;
    music->seek = SeekMusic;
    music->load = LoadMusic;
    music->getStatus = GetMusicStatus;
    music->play = PlayMusic;
    music->stop = StopMusic;
    music->pause = PauseMusic;
}
 
Music CreateMusic(FMOD_SYSTEM *sys)
{
    Music instance;
    InitMusic(&instance, sys);
    instance.free = FreeMusic;
 
    return instance;
}
 
Music *NewMusic(FMOD_SYSTEM *sys)
{
    Music *instance = NULL;
    instance = malloc(sizeof (Music));
 
    InitMusic(instance, sys);
    instance->free = DeleteMusic;
 
    return instance;
}
 
void FreeMusic(Music *music)
{
    FMOD_Sound_Release(music->stream);
}
 
void DeleteMusic(Music *music)
{
    FreeMusic(music);
    free(music);
}
 
static void InitPlaylist(Playlist *playlist)
{
    playlist->list = NULL;
    playlist->count = 0;
    playlist->mode = 0;
 
    playlist->add = AddToPlaylist;
    playlist->suppr = SupprFromPlaylist;
}
 
Playlist CreatePlaylist(void)
{
    Playlist instance;
    InitPlaylist(&instance);
    instance.free = FreePlaylist;
 
    return instance;
}
 
Playlist *NewPlaylist(void)
{
    Playlist *instance = NULL;
    instance = malloc(sizeof (Playlist));
 
    InitPlaylist(instance);
    instance->free = DeletePlaylist;
 
    return instance;
}
 
void FreePlaylist(Playlist *This)
{
    size_t i;
    for(i = 0 ; i < This->count ; i++)
        free(This->list[i]);
 
    free(This->list);
}
 
void DeletePlaylist(Playlist *This)
{
    FreePlaylist(This);
    free(This);
}
 
void AddToPlaylist(Playlist *This, const char *path)
{
    This->count++;
 
    This->list = realloc(This->list, This->count * sizeof(char*));
    This->list[This->count-1] = malloc(strlen(path) * sizeof (char));
 
    strcpy(This->list[This->count-1], path);
}
 
void SupprFromPlaylist(Playlist *This, size_t index)
{
    free(This->list[index]);
 
    {
        size_t i;
        for(i = index ; i < This->count-1 ; i++)
            This->list[i] = This->list[i+1];
    }
 
    This->count--;
 
    This->list = realloc(This->list, This->count * sizeof(char*));
}
 
size_t GetMusicElapsedTime(Music *music)
{
    size_t ret = 0;
 
    FMOD_Channel_GetPosition(
                                music->channel,
                                &ret,
                                FMOD_TIMEUNIT_MS
                            );
    return ret /= 1000;
}
 
size_t GetMusicTotalTime(Music *music)
{
    size_t ret = 0;
 
    FMOD_Sound_GetLength(music->stream, &ret, FMOD_TIMEUNIT_MS);
 
    return ret /= 1000;
}
 
void SeekMusic(Music *music, size_t pos)
{
    FMOD_Channel_SetPosition(music->channel, pos*1000, FMOD_TIMEUNIT_MS);
}
 
void LoadMusic(Music *music, const char *path)
{
    FMOD_System_CreateStream(
                                music->sys,
                                path,
                                FMOD_DEFAULT,
                                0,
                                &music->stream
                            );
}
 
Status GetMusicStatus(Music *music)
{
    FMOD_BOOL res = false;
    Status ret;
 
    if(music->channel == NULL)
        ret = STOPPED;
    else
    {
        FMOD_Channel_IsPlaying(music->channel, &res);
        if(res == false)
            ret = STOPPED;
        else
        {
            ret = PLAYING;
 
            FMOD_Channel_GetPaused(music->channel, &res);
            if(res == true)
                ret = PAUSED;
        }
    }
    return ret;
}
 
void PlayMusic(Music *music)
{
    FMOD_System_PlaySound(
                            music->sys,
                            FMOD_CHANNEL_FREE,
                            music->stream,
                            0,
                            &music->channel
                         );
}
 
void StopMusic(Music *music)
{
    FMOD_Channel_Stop(music->channel);
}
 
void PauseMusic(Music *music, bool flag)
{
    FMOD_Channel_SetPaused(music->channel, flag);
}
 
void SetMusicVolume(Music *music, float vol)
{
    FMOD_Channel_SetVolume(music->channel, vol);
}
 
float GetMusicVolume(Music *music)
{
    float vol = 0.0;
    FMOD_Channel_GetVolume(music->channel, &vol);
 
    return vol;
}

Merci d'avance.

P.S: Je compile en ANSI. N'hésitez pas à me faire des remarques, même si elles n'ont pas de rapport particulier avec le sujet : j'y suis toujours ouvert ;)

23/06/2007, 14h10
Médinoc

Commence par donner le code de retour exact, puis convertis-le en hexa (la calculatrice Windows peut faire ça).
Et ensuite, cherche ce nombre en hexa sur MSDN et dans les headers, ça te donnera déjà un aperçu de l'erreur...
23/06/2007, 14h18
|PaRa-BoL

Il se peut qu'un code marche en mode debugging mais pas en normal.

http://fr.wikipedia.org/wiki/Heisenbug
23/06/2007, 14h33
kidpaddle2

Très intéressante la comparaison avec le principe d'incertitude... par ailleurs, d'après ce que je vois, le mode debugger allouerait plus de mémoire qu'il n'en est nécessaire (je suis sous Code::Blocks) ?

Sinon, j'ai été voir dans les sources des différentes biblio, le code correspondant, puisque la sortie me semble fixe à :

Citation:

Process returned -1073741819 (0xC0000005) execution time : 0.187 s
Press any key to continue.

Et je trouve, dans ntstatus.h, le define correspondant :

Code:

#define STATUS_ACCESS_VIOLATION ((NTSTATUS)0xC0000005L)

Rremarquez-vous dans mon code une erreur, en ce qui concerne la gestion de la mémoire (d'après le lien de |PaRa-Bol, confirmé par cette macro, ça pourrait en être la cause) ?

Je tiens à préciser que durant mes nombreux essais, getch() et même scanf() pouvaient engendrer le return...
23/06/2007, 14h43
|PaRa-BoL

Meme si code::Block n'allou pas plus de mémoire en mode debug (Je n'en sait rien), de toute façon la structure du programme n'est plus la même. Donc vérifi si tu n'a pas un petit overflow quelque part ou une variable non initialisée. Met ton compilateur en mode paranöid et vérifi tout :)
23/06/2007, 14h45
Médinoc

Pour commencer, à ta place j'éviterais de retourner une structure par valeur, surtout en C...
23/06/2007, 14h53
kidpaddle2

|PaRa-Bol -> Justement, je ne trouve pas... ça fait un petit moment que j'y suis déjà.

Médinoc -> Oui, je suis au courant. Cependant, ça vient du tuto (sur ce site même) concernant la programmation orientée objet en C, et même si j'utilise ma fonction NewMusic() et NewPlaylist() (retournant des pointeurs), j'ai le même problème.

D'ailleurs, les membres sont copiés un à un, et l'objet d'origine est détruit ensuite... quel problème pourrait-on rencontrer ? Pour un opérateur d'assignation, d'accord, puisque l'on n'est pas sûr de la perrenité de l'objet d'origine, mais là...
23/06/2007, 14h56
Médinoc

Je pense que tu as quelque part une variable mal initialisée, ou un truc du genre.
Tu es sous MinGW pour l'instant, non ?
Il faudrait l'essayer sous le debugger de Visual, mais je n'ai pas SDL Music et j'ai la flemme de chercher à faire marcher cette lib...
23/06/2007, 15h02
kidpaddle2

Pour moi, Visual c'est la jungle. Bardé de courage, j'ai essayé de le faire marcher à trois reprises, et rien n'y a fait. Lui et moi, c'est incompatible pour le moment ^^

Sinon, je n'utilise pas SDL_Music mais Fmod, même si ça revient au même pour toi... je doute par contre que le problème vienne de son fonctionnement, ou à la limite un dû aux variables que j'utilise dans la structure Music.

Au fait, j'ai réglé mon compilo (oui, MinGW) à la manière 'parano' (selon le site de Emmanuel Delahaye), et seul le header stdio.h est commenté, à part concernant mes fonctions CreateXXXX, qui engendrent (normal) un warning du type "returns aggregate".

Citation:

Envoyé par kidpaddle2

Comportement indéfini ? Il manque pas mal de contrôles. Je propose ceci. Pose des questions si tu ne comprends pas :

Code:

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
 
/* main.c */
 
#include "playlist.h"
#include "music.h"
 
#include <stdio.h>
#include <conio.h>/* getch() */
 
int main (void)
{
   Music *music = music_create ();
 
   if (music != NULL)
   {
      Playlist *playlist = playlist_create ();
 
      if (playlist != NULL)
      {
         int err = playlist_open (playlist, "playlist.m3u");
         if (!err)
         {
            if (playlist_count(playlist) > 1)
            {
               music_load (music, playlist->list[2]);
               music_play (music);
               getch ();
            }
            playlist_delete (playlist);
         }
      }
      music_delete (music);
   }
   return 0;
}

Code:

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
 
#ifndef H_ED_MUSIC_20070623224109
#define H_ED_MUSIC_20070623224109
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* music.h */
 
#include <stddef.h>
 
   typedef enum
   { false, true }
   bool;
 
   typedef enum Status
   { PLAYING, STOPPED, PAUSED }
   Status;
 
/* type abstrait */
   typedef struct music Music;
 
   Music *music_create (void);
   void music_delete (Music * music);
 
   size_t music_getElapsedTime (Music * music);
   size_t music_getTotalTime (Music * music);
   void music_seek (Music * music, size_t pos);
   void music_load (Music * music, const char *path);
   Status music_getStatus (Music * music);
   void music_play (Music * music);
   void music_stop (Music * music);
   void music_pause (Music * music, bool flag);
   void music_set_volume (Music * music, float vol);
   float music_get_volume (Music * music);
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

Code:

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
 
/* music.c */
 
#include "music.h"
 
#include <string.h>
#include <stdlib.h>
 
#include <fmod/fmod.h>
 
struct music
{
   FMOD_SOUND *stream;
   FMOD_CHANNEL *channel;
   FMOD_SYSTEM *sys;
};
 
static FMOD_SYSTEM *InitFmod (void)
{
   FMOD_SYSTEM *sys;
   FMOD_System_Create (&sys);
   FMOD_System_Init (sys, 1, FMOD_INIT_NORMAL, NULL);
   return sys;
}
 
static void CloseFmod (FMOD_SYSTEM * sys)
{
   FMOD_System_Close (sys);
   FMOD_System_Release (sys);
}
 
/* points d'entree */
Music *music_create (void)
{
   Music *instance = malloc (sizeof (Music));
   if (instance != NULL)
   {
      instance->stream = NULL;
      instance->channel = NULL;
      instance->sys = InitFmod ();
   }
   return instance;
}
 
void music_delete (Music * music)
{
   FMOD_Sound_Release (music->stream);
   CloseFmod (music->sys);
   free (music);
}
 
size_t music_getElapsedTime (Music * music)
{
   size_t ret = 0;
   FMOD_Channel_GetPosition (music->channel, &ret, FMOD_TIMEUNIT_MS);
   return ret /= 1000;
}
 
size_t music_getTotalTime (Music * music)
{
   size_t ret = 0;
   FMOD_Sound_GetLength (music->stream, &ret, FMOD_TIMEUNIT_MS);
   return ret / 1000;
}
 
void music_seek (Music * music, size_t pos)
{
   FMOD_Channel_SetPosition (music->channel, pos * 1000, FMOD_TIMEUNIT_MS);
}
 
void music_load (Music * music, const char *path)
{
   FMOD_System_CreateStream (music->sys, path, FMOD_DEFAULT, 0,
                             &music->stream);
}
 
Status music_getStatus (Music * music)
{
   FMOD_BOOL res = false;
   Status ret;
   if (music->channel == NULL)
      ret = STOPPED;
   else
   {
      FMOD_Channel_IsPlaying (music->channel, &res);
      if (res == false)
         ret = STOPPED;
      else
      {
         ret = PLAYING;
         FMOD_Channel_GetPaused (music->channel, &res);
         if (res == true)
            ret = PAUSED;
      }
   }
   return ret;
}
 
void music_play (Music * music)
{
   FMOD_System_PlaySound (music->sys, FMOD_CHANNEL_FREE, music->stream, 0,
                          &music->channel);
}
 
void music_stop (Music * music)
{
   FMOD_Channel_Stop (music->channel);
}
 
void music_pause (Music * music, bool flag)
{
   FMOD_Channel_SetPaused (music->channel, flag);
}
void music_set_volume (Music * music, float vol)
{
   FMOD_Channel_SetVolume (music->channel, vol);
}
 
float music_get_volume (Music * music)
{
   float vol = 0.0;
   FMOD_Channel_GetVolume (music->channel, &vol);
   return vol;
}

Code:

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
 
#ifndef H_ED_PLAYLIST_20070623165015
#define H_ED_PLAYLIST_20070623165015
 
/* playlist.h */
 
#ifdef __cplusplus
extern "C"
{
#endif
 
   typedef enum Mode
   { SHUFFLE = 1 << 0, LOOP = 1 << 1 }
   Mode;
 
   typedef struct
   {
      char **list;
      unsigned int count;
      Mode mode;
   }
   Playlist;
 
   Playlist *playlist_create (void);
   void playlist_delete (Playlist * This);
 
   int playlist_open (Playlist * This, const char *playlistFilePath);
   void playlist_add (Playlist * This, const char *);
   void playlist_suppr (Playlist * This, unsigned int);
   int playlist_count (Playlist * This);
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

Code:

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
 
/* playlist.c */
 
#include "playlist.h"
 
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
Playlist *playlist_create (void)
{
   Playlist *This = malloc (sizeof (Playlist));
   if (This != NULL)
   {
      This->list = NULL;
      This->count = 0;
      This->mode = 0;
   }
   return This;
}
 
void playlist_delete (Playlist * This)
{
   size_t i;
   for (i = 0; i < This->count; i++)
      free (This->list[i]);
   free (This->list);
   free (This);
}
 
int playlist_open (Playlist * This, const char *playlistFilePath)
{
   int err = 0;
   FILE *playlistFile = fopen (playlistFilePath, "r");
   if (playlistFile != NULL)
   {
      char path[MAX_PATH] = "";
      while (fgets (path, MAX_PATH, playlistFile) != NULL)
      {
         path[strlen (path) - 1] = '\0'; /*Removes '\n' */
         playlist_add (This, path);
      }
      fclose (playlistFile);
   }
   else
   {
      perror (playlistFilePath);
      err = 1;
   }
 
   return err;
}
 
void playlist_add (Playlist * This, const char *path)
{
   This->count++;
   This->list = realloc (This->list, This->count * sizeof (char *));
   This->list[This->count - 1] = malloc (strlen (path) * sizeof (char));
   strcpy (This->list[This->count - 1], path);
}
 
void playlist_suppr (Playlist * This, size_t index)
{
   free (This->list[index]);
   {
      size_t i;
      for (i = index; i < This->count - 1; i++)
         This->list[i] = This->list[i + 1];
   }
   This->count--;
   This->list = realloc (This->list, This->count * sizeof (char *));
}
 
int playlist_count (Playlist * This)
{
   return This->count;
}

24/06/2007, 12h49
kidpaddle2

En ce qui concerne les contrôles, je voulais les implémenter après avoir résolu le problème, mais j'aurais dû effectivement le faire au fur et à mesure.

Bref, je ne vois pas ce qui a changé dans ton code (à part la suppression de l'OO), sauf en ce qui concerne les tests ? Ainsi, à l'exécution, j'ai exactement le même problème...

Ca fait un bout de temps que je cherche, et je n'ai toujours pas la moindre idée d'où cela peut provenir...
24/06/2007, 13h23
Emmanuel Delahaye

Citation:

Envoyé par kidpaddle2

En ce qui concerne les contrôles, je voulais les implémenter après avoir résolu le problème, mais j'aurais dû effectivement le faire au fur et à mesure.

Bref, je ne vois pas ce qui a changé dans ton code (à part la suppression de l'OO), sauf en ce qui concerne les tests ? Ainsi, à l'exécution, j'ai exactement le même problème...

Ca fait un bout de temps que je cherche, et je n'ai toujours pas la moindre idée d'où cela peut provenir...

Pour pouvoir tester dans les mêmes conditions, il faudrait que j'ai les mêmes fichiers de donnée que toi. Tu peux les déposer sur un site perso ?

Je n'ai pas "supprimmé l'OO". Au contraire, je l'ai même renforcée en la rendant opaque, donc plus sécuritaire. Par contre, l'usage des pointeurs de fonctions ne se justifie pas, à moins que tu cherches à faire de l'héritage multiple...

Si tu tiens aux pointeurs de fonction, ça doit rester une manip 'interne', et vu de l'extérieur, il faut continuer à fournir une interface classique (appel de fonction).

L'utilisateur n'a pas à connaitre les détails de la structure interne.

Salut,

Juste une petite remarque concernant ce seul petit bout de code:
Code:

1 2 3 4 5 6 #ifndef __bool_true_and_false_are_defined #define bool int #define true 1 #define false 0 #endif
Ne manquerait-il pas un define __bool_true_and_false_are_defined dans le lot:question:
Code:

1 2 3 4 5 6 #ifndef __bool_true_and_false_are_defined #define __bool_true_and_false_are_defined #define bool int #define true 1 #define false 0 #endif
Sinon, il me semble que __bool_true_and_false_are_defined ne sera jamais définis ;)

24/06/2007, 23h20
Emmanuel Delahaye

Citation:

Envoyé par koala01

Sinon, il me semble que __bool_true_and_false_are_defined ne sera jamais définis ;)

C'est peut être une définition personnelle... Mais je me demande si ce n'est pas dans le <bool.h> de C99...
25/06/2007, 00h38
koala01

Ca l'est peut etre, mais, ici, c'est dans son propre code source...

Et un ifndef n'est utile, que s'il contient la définition de l'élément testé, sinon, il ne sert à rien, me semble-t-il du moins ;)
25/06/2007, 02h16
Emmanuel Delahaye

Citation:

Envoyé par koala01

Ca l'est peut etre, mais, ici, c'est dans son propre code source...

Bah non, c'est probablement une définition sur la ligne de commande avec -D... ou alors dans un include (bool.h ?)

Citation:

Et un ifndef n'est utile, que s'il contient la définition de l'élément testé, sinon, il ne sert à rien, me semble-t-il du moins ;)

Bah non, le rôle de #ifdef ou #ifndef est précisément de savoir si la macro a été définie ou non...
25/06/2007, 12h33
kidpaddle2

Suis-je tête-en-l'air ^^ Effectivement, il manque un #define...

-ed-, pour les "fichiers de données", je suppose que tu parles des bibliothèques utilisées... j'ai déposé le code source ainsi que les headers, la bibliothèque et la DLL de fmod dans une archive située sur mon espace FTP.

En ce qui concerne playlist.m3u, il s'agit d'un fichier m3u simplifié (pas de commentaires ['#']), à savoir contenant les chemins des musiques disposés à la suite (conséquemment séparés par '\n').

En espérant que tu trouves ce qui cloche (je n'en doute pourtant pas), merci d'avance.

Edit: Ca aurait pu être contenu dans un paramètre -D, effectivement, mais je voulais tout simplement définir un type bool, sans pour autant en redéfinir un dans le cas d'une compilation C99.
25/06/2007, 14h15
Emmanuel Delahaye

Citation:

Envoyé par kidpaddle2

-ed-, pour les "fichiers de données", je suppose que tu parles des bibliothèques utilisées...

Non. Je parle de "playlist.m3u" et des .mp3 qui vont avec...

Citation:

En ce qui concerne playlist.m3u, il s'agit d'un fichier m3u simplifié (pas de commentaires ['#']), à savoir contenant les chemins des musiques disposés à la suite (conséquemment séparés par '\n').

... voilà. Mais ce n'est que ça, OK, je vais me débrouiller avec.

En fait, c'est plus compliqué que je ne le pensais. Avec FMOD, il y a 2 branches : 3.x historique, C) et EX (Classes C++).

Curieusement, la branche EX supporte aussi une interface C, mais elle n'est pas documentée. (enfin, j'ai pas trouvé). Faut-il prendre la doc 3.x ?
25/06/2007, 15h17
kidpaddle2

Non, en fait, la version _Ex comporte un header d'interface C (obligatoire pour les compilos autre que Visual, à cause des DLL) dont les fonctions observent la nomenclature suivante :

Au lieu de méthode Classe::Méthode(params), FMOD_Classe_Méthode(Classe*, params)

Tu pourras donc utiliser la doc de Fmodex et traduire en C... mais normalement, concernant les fonctions utilisées, il n'y a pas de problèmes. J'avais fait une autre bibliothèque audio (celle-ci pour mon prochain projet Windows API, en C++) comportant les mêmes fonctions, et celle-ci marchait à merveille.
27/06/2007, 11h19
kidpaddle2

Hem... up ?
25/07/2007, 18h48
kidpaddle2

Même si j'avance mon nouveau projet en parallèle, je reste coincé quant à celui-ci : personne ne peut m'aider, svp ?
26/07/2007, 00h41
souviron34

d'autre part, à ce sujet, j'avais déjà signalé, mais je me demande bien pourquoi on met

Code:

#define bool int

et non pas

Code:

#define bool char

ce qui fait quand même économiser 3 octets par valeur.... (en moyenne ;) )
26/07/2007, 00h46
souviron34

Citation:

Envoyé par kidpaddle2

Très intéressante la comparaison avec le principe d'incertitude... par ailleurs, d'après ce que je vois, le mode debugger allouerait plus de mémoire qu'il n'en est nécessaire (je suis sous Code::Blocks) ?

je dirais même plus : systématiquement l'usage d'un debugger ou d'un outil incluant un debugger modifie le comportement vis-à-vis de la mémoire... car en général il "surveille" grâce à ses propres mallocs/frees, et est lui-même en général chargé ;) ce qui modifie signaficativement les segments utilisés...

Et enfin c'est un comportement symptomatique bien connu d'un problème de fuite de mémoire..
26/07/2007, 00h53
souviron34
et en passant rapidement sur le code original, je m'aperçois que :
- Pas de test si les allocations/réallocations se sont correctement effectuées.
- Donc des copies et des frees potentiellement erronés
- Une erreur de longueur d'allocation (débordement) :
  Code:
  
  1 2 This->list[This->count-1] = malloc( (strlen(path)+1) * sizeof (char));
En passant en 3 minutes...
26/07/2007, 10h19
DaZumba

Citation:

Envoyé par souviron34

Code:

#define bool char

ce qui fait quand même économiser 3 octets par valeur...

...mais peut augmenter la taille du code (et le temps d'execution) s'il y a beaucoup de conversion a faire vers int. Si on est limite en memoire, char est bon choix. Sinon, il y a peu de raisons de ne pas utiliser int.
26/07/2007, 10h30
souviron34

Citation:

Envoyé par DaZumba

...mais peut augmenter la taille du code (et le temps d'execution) s'il y a beaucoup de conversion a faire vers int.

bah à ce compte-là pourquoi utiliser un booléen ??

c'est bien 0 ou 1, si mes souvenirs sont bons :aie:

Donc pourquoi stocker dans une variable qui peut aller jusqu'à INT_MAX ??

256 valeurs c'est déjà largement suffisant pour en représenter 2....

Et si il y a beaucoup de conversion vers int c'est qu'on a mal choisi sa variable....
26/07/2007, 11h09
Médinoc

Je rappelle que les paramètres de fonction sont facilement promus en Int, et que les procs les plus rapides ne savent pas faire des opérations (même des comparaisons à zéro) sur plus petit...
26/07/2007, 11h14
DaZumba

Citation:

Envoyé par Médinoc

Je rappelle que les paramètres de fonction sont facilement promus en Int, et que les procs les plus rapides ne savent pas faire des opérations (même des comparaisons à zéro) sur plus petit...

... et je complete que la norme precise que le resultat des operateurs relationnels (< > <= >=) et des operateurs d'egalite (== !=) est de type int (6.5.8, 6.5.9). int est donc un type naturel pour quelque-chose qui se retrouve dans un if()...

Citation:

Envoyé par souviron34

bah à ce compte-là pourquoi utiliser un booléen ??

Exactement. Perso, je n'en ai jamais eu besoin...
26/07/2007, 11h44
souviron34

Citation:

Envoyé par DaZumba

..Exactement. Perso, je n'en ai jamais eu besoin...

Moi une seule fois, pour compléter des types de données (réels, entier, chaines, char, et booléen (donc char ;) ) ).
26/07/2007, 15h24
kidpaddle2

Le débat portant sur la justification d'un type booléen fait rage, à ce que je vois, mais je rappelle que ce n'est pas le sujet de ce topic. En revanche, suite à une des réponses de souviron34 -que je remercie donc, en plus de ceux qui ont daigné répondre ^^ -, que voilà :

Citation:

Une erreur de longueur d'allocation (débordement) :

Code:

This->list[This->count-1] = malloc( (strlen(path)+1) * sizeof (char));

Avec cette modification, le programme s'exécute sans problème, que ce soit en mode release ou debug. Après avoir réfléchis un peu par la suite, j'ai émis l'hypothèse que cette distinction debug/release soit due à une potentielle initialisation du segment de mémoire utilisé par le programme (par le debugger) à 0. Ainsi, l'absence du caractère NULL final serait comblée par sa présence au sein du reste de la mémoire...

Enfin bref, tout ça pour dire que l'aiguille a finalement été trouvée dans cette botte de foin, et que le sujet est conséquemment résolu ;)

Merci à vous tous.