Fehler beim Testen meiner DLL

  • C/C++

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Fehler beim Testen meiner DLL

    Guten Tach, Leute!

    Folgendes Problem:
    Wenn ich meine DLL kompiliere, sie dann in eine GEX packen will, test weise in ein GM-Projekt einbinden will und das Spiel dann starte um die Funktionen zu testen, kriege ich den Fehler hier:



    [hide=Problemsignatur:]Problemereignisname: APPCRASH
    Anwendungsname: test.exe
    Anwendungsversion: 1.0.0.0
    Anwendungszeitstempel: 2a425e19
    Fehlermodulname: libstdc++-6.dll
    Fehlermodulversion: 0.0.0.0
    Fehlermodulzeitstempel: 4e71847f
    Ausnahmecode: 40000015
    Ausnahmeoffset: 0001bb30
    Betriebsystemversion: 6.1.7601.2.1.0.768.3
    Gebietsschema-ID: 2055
    Zusatzinformation 1: 4176
    Zusatzinformation 2: 4176e39b12a5f22424b14e313154e263
    Zusatzinformation 3: b723
    Zusatzinformation 4: b723479c9bc771a4a7d2fda0ab8bd1bd[/hide]

    Der Fehler ist gestern zum ersten mal aufgetreten. Vorher hab ich die DLL auch getestet und da hat alles ohne Probleme funktioniert.
    Woran kann das liegen?
    Hier mal die Funktionen, die extern aufrufbar sind und die Extension selber (+Test.gmk).

    [hide=Aufrufbare Funktionen der DLL]

    C-Quellcode

    1. #include <cstdlib>
    2. #include <map>
    3. #include "Animation.h"
    4. #include "Bone.h"
    5. #include "Skeleton.h"
    6. #define gm extern "C" __declspec (dllexport)
    7. using namespace std;
    8. map<unsigned int, Animation*> animations;
    9. map<unsigned int, Bone*> bones;
    10. map<unsigned int, Skeleton*> skels;
    11. int anim_i = 0, bone_i = 0, skel_i = 0;
    12. /*
    13. * Helper methods
    14. */
    15. Animation *animation_get_ref(double index){
    16. unsigned int i = (unsigned int) index;
    17. if(i >= 0 && i < animations.size()) return animations.at(i);
    18. else return NULL;
    19. }
    20. double animation_get_index(Animation *animation){
    21. bool found = false;
    22. map<unsigned int, Animation*>::iterator it = animations.begin();
    23. for(; it != animations.end() && !found; ++it) found = it->second == animation;
    24. return (--it)->first;
    25. }
    26. Bone *bone_get_ref(double index){
    27. unsigned int i = (unsigned int) index;
    28. if(i >= 0 && i < bones.size()) return bones.at(i);
    29. else return NULL;
    30. }
    31. double bone_get_index(Bone *bone){
    32. bool found = false;
    33. map<unsigned int, Bone*>::iterator it = bones.begin();
    34. for(; it != bones.end() && !found; ++it) found = it->second == bone;
    35. return (--it)->first;
    36. }
    37. Skeleton *skeleton_get_ref(double index){
    38. unsigned int i = (unsigned int) index;
    39. if(i >= 0 && i < skels.size()) return skels.at(i);
    40. else return NULL;
    41. }
    42. /*
    43. * Animation export
    44. */
    45. gm double animation_create(double bones, double frames){
    46. anim_i++;
    47. animations.insert(pair<unsigned int, Animation*>(anim_i,new Animation(bones,frames)));
    48. return anim_i;
    49. }
    50. gm double animation_delete(double animation_index){
    51. Animation *anim = animation_get_ref(animation_index);
    52. animations.erase((unsigned int)animation_index);
    53. delete anim;
    54. anim = NULL;
    55. return 0;
    56. }
    57. gm double animation_get_frames(double animation_index){
    58. try{
    59. return animation_get_ref(animation_index)->get_frames();
    60. }
    61. catch(...){
    62. return -1;
    63. }
    64. }
    65. gm double animation_get_bones(double animation_index){
    66. try{
    67. return animation_get_ref(animation_index)->get_frames();
    68. }
    69. catch(...){
    70. return -1;
    71. }
    72. }
    73. gm double animation_set_frame(double animation_index, double frame, double bone_index,double x, double y, double angle, double scale, double parent_angle, double parent_length,
    74. double sprite_xscale, double sprite_yscale, double sprite_index, double joint_xscale, double joint_yscale, double joint_index){
    75. Animation *anim = animation_get_ref(animation_index);
    76. anim->set_frame(frame, (unsigned int) bone_index,x,y,angle,scale,parent_angle,parent_length,sprite_xscale,sprite_yscale,sprite_index,joint_xscale,joint_yscale,joint_index);
    77. return 0;
    78. }
    79. gm double animation_set_keyframe(double animation_index, double frame, double key){
    80. Animation *anim = animation_get_ref(animation_index);
    81. anim->set_keyframe((unsigned int) frame, (bool) key);
    82. return 0;
    83. }
    84. gm double animation_concat(double animation_index1, double animation_index2){
    85. Animation *anim = animation_get_ref(animation_index1);
    86. anim->concat(animation_get_ref(animation_index2));
    87. return 0;
    88. }
    89. gm double animation_create_between(double animation_index1, double animation_index2, double frames){
    90. Animation *anim = animations.at((unsigned int) animation_index1);
    91. animations.insert(pair<unsigned int, Animation*>(animations.size(),anim->create_between(animations.at((unsigned int) animation_index2),(unsigned int) frames)));
    92. return animations.size()-1;
    93. }
    94. /*
    95. * Bone export
    96. */
    97. gm double bone_create(double parent, double x, double y, double angle, double scale,double index){
    98. bone_i++;
    99. bones.insert(pair<unsigned int, Bone*>( bone_i, new Bone(NULL,bone_get_ref(parent),x,y,angle,scale,(unsigned int)index)));
    100. return bone_i;
    101. }
    102. gm double bone_set_name(double bone_index, char *name){
    103. try{
    104. bone_get_ref(bone_index)->name = name;
    105. return 1;
    106. }
    107. catch(...){
    108. return -1;
    109. }
    110. }
    111. gm double bone_set_sprite(double bone_index, double sprite_index, double x, double y, double depth, double joint){
    112. try{
    113. bone_get_ref(bone_index)->set_sprite(sprite_index,x,y,depth,(bool) joint);
    114. return 1;
    115. }
    116. catch(...){
    117. return -1;
    118. }
    119. }
    120. gm double bone_set_animation(double bone_index, double animation_index){
    121. bone_get_ref(bone_index)->animation = animation_get_ref(animation_index);
    122. }
    123. gm double bone_set_added_angle(double bone_index, double angle){
    124. try{
    125. bone_get_ref(bone_index)->added_angle = angle;
    126. return 1;
    127. }
    128. catch(...){
    129. return -1;
    130. }
    131. }
    132. gm double bone_parent_exists(double bone_index){
    133. try{
    134. return (double)(bone_get_ref(bone_index)->parent != 0L);
    135. }
    136. catch(...){
    137. return -1;
    138. }
    139. }
    140. gm double bone_get_animation(double bone_index){
    141. return animation_get_index(bone_get_ref(bone_index)->animation) ;
    142. }
    143. gm double bone_get_sprite(double bone_index){
    144. try{
    145. return bone_get_ref(bone_index)->sprite;
    146. }
    147. catch(...){
    148. return -1;
    149. }
    150. }
    151. gm double bone_get_joint(double bone_index){
    152. try{
    153. return bone_get_ref(bone_index)->joint;
    154. }
    155. catch(...){
    156. return -1;
    157. }
    158. }
    159. gm double bone_get_added_angle(double bone_index){
    160. try{
    161. return bone_get_ref(bone_index)->added_angle;
    162. }
    163. catch(...){
    164. return -1;
    165. }
    166. }
    167. gm char *bone_get_name(double bone_index){
    168. try{
    169. return bone_get_ref(bone_index)->name;
    170. }
    171. catch(...){
    172. return 0L;
    173. }
    174. }
    175. /*
    176. * Skeleton export
    177. */
    178. gm double skeleton_create(){
    179. skel_i++;
    180. skels.insert(pair<unsigned int, Skeleton*>(skel_i, new Skeleton()));
    181. return skel_i;
    182. }
    183. gm double skeleton_add_bone(double skeleton_index, double bone_index){
    184. skeleton_get_ref(skeleton_index)->add_bone(bone_get_ref(bone_index));
    185. return 1;
    186. }
    187. gm double skeleton_set_frame_speed(double skeleton_index, double frame_speed){
    188. try{
    189. skeleton_get_ref(skeleton_index)->frame_speed = frame_speed;
    190. return 1;
    191. }
    192. catch(...){
    193. return -1;
    194. }
    195. }
    196. gm double skeleton_set_frame(double skeleton_index, double frame){
    197. try{
    198. skeleton_get_ref(skeleton_index)->count= frame;
    199. return 1;
    200. }
    201. catch(...){
    202. return -1;
    203. }
    204. }
    205. gm double skeleton_set_offset(double skeleton_index, double x, double y){
    206. try{
    207. skeleton_get_ref(skeleton_index)->set_offset(x,y);
    208. return 1;
    209. }
    210. catch(...){
    211. return -1;
    212. }
    213. }
    214. gm double skeleton_set_animation(double skeleton_index, double animation_index){
    215. try{
    216. skeleton_get_ref(skeleton_index)->set_animation(animation_get_ref(animation_index));
    217. return 1;
    218. }
    219. catch(...){
    220. return -1;
    221. }
    222. }
    223. gm double skeleton_update(double skeleton_index, double x, double y){
    224. try{
    225. skeleton_get_ref(skeleton_index)->update(x,y);
    226. return 1;
    227. }
    228. catch(...){
    229. return -1;
    230. }
    231. }
    232. gm double skeleton_flip_hor(double skeleton_index){
    233. try{
    234. skeleton_get_ref(skeleton_index)->flip_hor();
    235. return 1;
    236. }
    237. catch(...){
    238. return -1;
    239. }
    240. }
    241. gm double skeleton_flip_ver(double skeleton_index){
    242. try{
    243. skeleton_get_ref(skeleton_index)->flip_ver();
    244. return 1;
    245. }
    246. catch(...){
    247. return -1;
    248. }
    249. }
    250. gm double skeleton_get_bone_by_name(double skeleton_index, char *name){
    251. try{
    252. return bone_get_index(skeleton_get_ref(skeleton_index)->get_bone_by_name(name));
    253. }
    254. catch(...){
    255. return -1;
    256. }
    257. }
    258. gm double skeleton_get_animation(double skeleton_index){
    259. try{
    260. return animation_get_index(skeleton_get_ref(skeleton_index)->animation);
    261. }
    262. catch(...){
    263. return -1;
    264. }
    265. }
    266. gm double skeleton_get_frame(double skeleton_index){
    267. try{
    268. return skeleton_get_ref(skeleton_index)->frame;
    269. }
    270. catch(...){
    271. return -1;
    272. }
    273. }
    274. gm double skeleton_get_frame_speed(double skeleton_index){
    275. try{
    276. return skeleton_get_ref(skeleton_index)->frame_speed;
    277. }
    278. catch(...){
    279. return -1;
    280. }
    281. }
    Alles anzeigen
    [/hide]
    Ich hab auch mal Windows nach Fehlern (mittels sfc/scannow) durchsuchen lassen und da wird auch nix gefunden.
    Danke schon mal für die Hilfe!

    MfG Trixt0r

    Albert Einstein schrieb:

    Probleme kann man niemals mit derselben Denkweise lösen, durch die sie entstanden sind.
  • Ok, aber ich denke nicht, dass da was falsch ist, da ich mit dem selben Quellcode auch schon vorher getestet habe und dort alles glatt ging.

    Source.

    Edit: Headerfiles vergessen. -.-

    Albert Einstein schrieb:

    Probleme kann man niemals mit derselben Denkweise lösen, durch die sie entstanden sind.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Trixt0r ()

  • In Animation.cpp, Zeile 44

    Quellcode

    1. for(int j = 0; i < frames; j++){

    soll wohl eher heißen

    Quellcode

    1. for(int j = 0; j < frames; j++){

    Aber ungeachtet dessen verstehe ich nicht ganz, was du mit dieser Schleife vor hast. Zunächst mal rufst du dort für jede map die Methode at auf, die es aber offiziell nicht gibt, siehe cplusplus.com/reference/stl/map/. Du suchst wahrscheinlich find. Aber abgesehen davon versuchst du dort jeweils mehrere Nullen einzufügen, obwohl du zuvor nur jeweils ein Paar in die maps eingefügt hast.
  • @Bl@ckSp@rk: Du bist echt der Retter in der Not ^^.
    Die komplette innere for-Schleife hat keinen Sinn gemacht.
    Aber warum zeigt mir der Compiler keine Fehler an, wenn ich mit at(i) kompiliere?
    Ist es sicherer sowas zu schreiben:

    Quellcode

    1. this->x->find(i)->second->push_back(0);

    anstatt sowas:

    Quellcode

    1. this->x->at(i)->push_back(0);

    ?

    Albert Einstein schrieb:

    Probleme kann man niemals mit derselben Denkweise lösen, durch die sie entstanden sind.
  • Manche Compiler bieten die Methode at einfach noch zusätzlich an, wie auch der Visual C++ Compiler. Vermutlich damit man damit intuitiver arbeiten kann, da es diese Methode ja auch bei einigen anderen Containern (z.B. vector) gibt. Im C++ Standard ist sie jedoch nicht vorgesehen, sodass man sie auch lieber nicht verwenden sollte, wenn man Plattformunabhängigkeit erreichen will.