Comment resoudre des erreurs sous c++ builder

Version imprimable

27/05/2009, 17h17
steph496

Comment resoudre des erreurs sous c++ builder

Bonjour, je travaille sur une application faite sous c++ builder. En faite je travaille sur l´application en ouvrant project.bpr.
J´ai ajoute un program supplementaire dans project.bpr.
Quand je compile mon projet, j´obtiens un exe et quand je lance cet exe j´obtiens l´erreur suivante.

Citation:

Project Pressopt.exe raised exception class EAccess violation with message 'Access violation at adress 7AD61DF7 in module 'libmx.dll'. Read of adress 00000018. Process stopped. Use Step or Run to continue

.

En faite j´utilise une dll creer avec matlab. Libmx.dll contient des fonctions qui permettent de faire l´interface entre c/c++ code et matlab code afin par exemple de creer des entrees/sorties pour les fonctions de la dll creer avec matlab.

Je ne sais pas tres bien me servir me c++builder. Comment voir d´ou provient l´erreur? On peut afficher CPU window mais je ne sais pas trop comment m´en servir.
27/05/2009, 19h12
Grosbenji

Bonjour,

Quelques pistes:

* Commencer par vérifier que ton code Matlab fonctionne correctement dans Matlab (mais ça, j'imagine que tu l'as déjà fait).

* Vérifier que le fichier header ".h" (ou ".hpp") que tu utilises correspond bien à celui de la version de la dll. Il en est de même de la lib (tu peux la recréer à partir de la dll avec un implib).

* Déposer un break point en début de programme, lancer l'exécution dans l'EDI, et faire défiler les lignes pas à pas pour savoir là où sa plante. N'hésite pas à poster ton code ici, avec la ligne de plantage.

Cordialement,

Benjamin

En faite, mon programme plante apres la 8eme iteration. Mais avant le plantage tout marche bien.
Je ne vais pas mettre tout mon code parce que c´est assez long mais je peux mettre la structure des fonctions de libmx que j´utilise:

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
long david_algorithm(FILE *out, int Why, long *Answer, tParams Parameters[], int *CollisionFlag)
{
   
    static mxArray *in1=NULL, *in2=NULL, *in3=NULL, *in4=NULL, *in5=NULL, *in6=NULL, *in7=NULL, *in8=NULL, *in9=NULL, *in10=NULL, *in12=NULL;
    static mxArray *out1 = NULL;
    static mxArray *out2 = NULL;
    static mxArray *out3 = NULL;
    static mxArray *out4 = NULL;
    static mxArray *out5 = NULL;
    static mxArray *out6 = NULL;
    static mxArray *out7 = NULL;
    static mxArray *out8 = NULL;
    static mxArray *out9 = NULL;
    static mxArray *out10 = NULL;

     if(Why==0)
    {
            if( !mclInitializeApplication(NULL,0) )
            {
                MainForm->MemoInfo->Lines->Add("David algorithm couldn´t initialise the application");


    	return -1;
             }

              if (!libfinalInitialize())
             {
                 MainForm->MemoInfo->Lines->Add("David algorithm couldn´t initialise the library");
        return -2;
             }

    in1=(mxArray*)mxMalloc(N1*pdim * 64 ); 
    in2=(mxArray*)mxMalloc(N1 * 64);


    in2 = mxCreateDoubleMatrix(1,N1,mxREAL);
    in3 = mxCreateDoubleMatrix(1,pdim,mxREAL);
    in4 = mxCreateDoubleMatrix(1,pdim,mxREAL);
    in5 = mxCreateDoubleMatrix(1,1,mxREAL);
    in6 = mxCreateDoubleMatrix(1,1,mxREAL);

    in7 = mxCreateDoubleMatrix(1,pdim,mxREAL);
    in8 = mxCreateDoubleMatrix(1,pdim,mxREAL);
    in9 = mxCreateDoubleMatrix(1,1,mxREAL);
    in10 = mxCreateDoubleMatrix(1,1,mxREAL);

    memcpy(mxGetPr(in3), data1111, pdim*sizeof(double));
    memcpy(mxGetPr(in4), data2222, pdim*sizeof(double));
    memcpy(mxGetPr(in5), data5, 1*sizeof(double));  
    memcpy(mxGetPr(in6), data6, 1*sizeof(double));



    memcpy(mxGetPr(in7), data1111, pdim*sizeof(double));
    memcpy(mxGetPr(in8), data2222, pdim*sizeof(double));
    memcpy(mxGetPr(in9), data9, 1*sizeof(double));
    memcpy(mxGetPr(in10), data10, 1*sizeof(double));




       mlfInitdoe(1, &out10, in9, in10, in7, in8);
       display(out10,tab2,tab22);
       mxDestroyArray(out10), out10=0;

       memcpy(mxGetPr(in2), data2, N1*sizeof(double));
       
        in1 = mxCreateDoubleMatrix(N1,pdim,mxREAL);
        memcpy(mxGetPr(in1), tab23, N1*pdim*sizeof(double));           

       mlfNewpoint(9, &out1, &out2, &out3, &out4, &out5, &out6, &out7, &out8, &out9, in1, in2, in3, in4, in5, in6);
         display(out1,tab1,tab11);

          mxDestroyArray(out1); out1=0;
      }// end de why=0

      if(Why==1)
      {
        in12 = mxCreateDoubleMatrix(1,1,mxREAL);
        memcpy(mxGetPr(in12), data6, 1*sizeof(double));//data6 contient l´indice d´iteration

         in1=(mxArray*)mxRealloc(in1,((N1+i13+1)*pdim)*sizeof(double));
         in2=(mxArray*)mxRealloc(in2,(i13+1+N1)*sizeof(double));

         in1 = mxCreateDoubleMatrix((N1+i13+1),pdim,mxREAL);
         in2 = mxCreateDoubleMatrix(1,N1+i13+1,mxREAL);

         memcpy(mxGetPr(in1), tab23, (N1+i13+1) * pdim * sizeof(double));
         memcpy(mxGetPr(in2), data2, (N1+i13+1) * sizeof(double));


         mlfNewpoint(9, &out1, &out2, &out3, &out4, &out5, &out6, &out7, &out8, &out9, in1, in2, in3, in4, in5, in12);
         display(out1,tab1,tab11);



        mxDestroyArray(out1); out1=0;
        mxDestroyArray(out2); out2=0;
        mxDestroyArray(out3); out3=0;
        mxDestroyArray(out4); out4=0;
        mxDestroyArray(out5); out5=0;
        mxDestroyArray(out6); out6=0;
        mxDestroyArray(out7); out7=0;
        mxDestroyArray(out8); out8=0;
        mxDestroyArray(out9), out9=0;

       if(i13>max iteration)
     {
        mxDestroyArray(in1); in1 = 0;
        mxDestroyArray(in2); in2 = 0;
        mxDestroyArray(in3); in3 = 0;
        mxDestroyArray(in4); in4 = 0;
        mxDestroyArray(in5); in5 = 0;
        mxDestroyArray(in6); in6 = 0;
        mxDestroyArray(in7); in7 = 0;
        mxDestroyArray(in8); in8 = 0;
        mxDestroyArray(in9); in9 = 0;
        mxDestroyArray(in10); in10 = 0;
        mxDestroyArray(in12); in12 = 0;

        libfinalTerminate();

         mclTerminateApplication();

        return -1;  // Stop signal
     }
    else
     {

        return 1;  // go in an other loop why=1
     }



    }//End of why = 1
}//enf of long

void display(const mxArray* in, int* tab, double* tabdoub)
{
      int i=0, j=0; /* loop index variables */
      int r=0, c=0; /* variables to store the row and column length of the matrix */
      int k=0;
      double *data; /* variable to point to the double data stored within the mxArray */

      r = mxGetM(in); //number of rows
      c = mxGetN(in); //number of columns

      data = mxGetPr(in); //Get real data elements in mxArray

      for( i = 0; i < r; i++ )
      {

           for( j = 0; j < c; j++)
              {
              //printf("     %04.2f\t",data[i*c+j]);
              k=10*i+j;
              tab[k] = (data[i*c+j]+0.5);         // good conversion between integer and double
              tabdoub[k] =  data[i*c+j];
              //tabdoub[k] =  (double)(tab[k]);
              }
      }

}

Le probleme survient dans la fonction display a la fin du code. Lorsque j´utilise :

Citation:

tabdoub[k] = data[i*c+j];

aucun probleme tout marche bien(mais moi je travaille avec des entiers et j´ai besoin de double pour utiliser mes fonctions de ma librairie).
Quand je fais ca:

Citation:

tabdoub[k] = (double)(tab[k]);

Mon programme s´execute correctement mais plante apres 8 iteration, c´est a dire apres avoir parcouru 8 fois la boucle why=1.
Je ne comprend pas trop la difference entre ces deux expressions, pour moi y a autant d´element dans l´un que dans l´autre et ce sont bien des doubles.

Bonjour,

Bon, je ne connais pas l'utilisation des fonctions matlab.
Mais, dès le début, un truc me semble étrange.
Code:

1 2 3 4 5 6 7 8 9 10 static mxArray *in1=NULL, *in2=NULL, *in3=NULL, *in4=NULL, *in5=NULL, *in6=NULL, *in7=NULL, *in8=NULL, *in9=NULL, *in10=NULL, *in12=NULL; //.... in1=(mxArray*)mxMalloc(N1*pdim * 64 ); in2=(mxArray*)mxMalloc(N1 * 64); in2 = mxCreateDoubleMatrix(1,N1,mxREAL); in3 = mxCreateDoubleMatrix(1,pdim,mxREAL);
J'imagine que la fonction 'mxCreateDoubleMatrix' fait une allocation mémoire, non? Sinon la ligne suivante n'a aucun sens:
Code:

1 2 in3 = mxCreateDoubleMatrix(1,pdim,mxREAL);
Et si c'est le cas, pourquoi faire dans un premier temps une allocation avec mxMalloc pour in2, puis faire:

Code:

in2 = mxCreateDoubleMatrix(1,N1,mxREAL);

29/05/2009, 08h25
steph496

oui en effet, je n´ai pas besoin de mxMalloc ni de mxRealloc. mxCreateDoubleMatrix alloue deja de la memoire. Je pense que je dois avoir un probleme dans l´utilisation des fonctions mx. Ce qui est frustrant c´est que ca marche jusqu´a la huitieme iteration et aprse seulement ca plante.
29/05/2009, 11h16
totoche76

Hello,

Dans ton exemple, comment sont alloués les tableaux tab1, tab2 ??
29/05/2009, 17h47
steph496

dans la boucle why=0

Citation:

tab1=(int*)malloc(pdim * sizeof(int));
tab2=(int*)malloc(n1 * sizeof(int));
tab11=(int*)malloc(pdim * sizeof(double));
tab22=(double*)malloc(n1 * sizeof(double));
data2=(double*)malloc(N1 * sizeof(double));

dans la boucle why=1

Citation:

tab22=(double*)realloc(tab22,(N1+i13+1)*pdim * sizeof(double));
data2=(double*)realloc(data2, (N1+i13+1) * sizeof(double));

tab22 et tab 23 sont la en faite la meme chose.
En faite j´utilise malloc et realloc pour allouer de la memoire.
02/06/2009, 11h52
totoche76

Question à 2 balles: dans ta fonction display, est-ce que tu es sûr que

Code:

k=10*i+j;

ne sort pas des limites des tableaux qui sont derrière tab et tabdoub ?