Bonjour,

J'ai écrit un programme (calculant des indices de sensibilité pour mon stage de 2A) qui nécessite d'initialiser tout plein de zones mémoire (pour aller plus vite):

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
 
 
int i,ip,ipp;
long j,k,l,aux,tmpl;
long *casesY,*p,*estimationsX,*estimationsY;
long **casesX,**estimationsXX,**estimationsXY=0;
long ***estimationsXXY;
 
double sum,H0=0,pasX,tmp;
double *infX,*infY,*supX,*supY,*pasY,*mS1=0,*minS1=0,*maxS1=0,*sigS1=0;
double **mS2=0,**minS2=0,**maxS2=0,**sigS2=0,**X,**Y,**HK=0;
double ***HK2=0;
 
/* initialisation des tableaux contenant les indices */
if (Si) {
    HK=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) {
        HK[i]=(double*)malloc(R*sizeof(double));
        for (ip=R-1; ip>=0; ip--) HK[i][ip]=0;
    }
    mS1=(double*)malloc(dim_x*sizeof(double));
    minS1=(double*)malloc(dim_x*sizeof(double));
    maxS1=(double*)malloc(dim_x*sizeof(double));
    sigS1=(double*)malloc(dim_x*sizeof(double));
} 
if (Sij) {
    HK2=(double***)malloc(dim_x*sizeof(double**));
    for (i=dim_x-1; i>=0; i--) {
        HK2[i]=(double**)malloc(dim_x*sizeof(double*));
        for (ip=dim_x-1; ip>=0; ip--) {
            HK2[i][ip]=(double*)malloc(R*sizeof(double));
            for (ipp=R-1; ipp>=0; ipp--) HK2[i][ip][ipp]=0;
        }
    }
    mS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) mS2[i]=(double*)malloc(dim_x*sizeof(double));
    minS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) minS2[i]=(double*)malloc(dim_x*sizeof(double));
    maxS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) maxS2[i]=(double*)malloc(dim_x*sizeof(double));
    sigS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) sigS2[i]=(double*)malloc(dim_x*sizeof(double));
} 
 
/* autres initialisations */
aux=puiss(n+1,dim_y); 
p=(long*)malloc(dim_y*sizeof(long));
for (i=dim_y; i>=0; i--) p[i]=puiss(n+1,i);
estimationsY=(long*)malloc((aux+1)*sizeof(long)); 
X=(double**)malloc(dim_x*sizeof(double*));
for (i=dim_x-1; i>=0; i--) X[i]=(double*)malloc(S*sizeof(double)); 
infX=(double*)malloc(dim_x*sizeof(double));
supX=(double*)malloc(dim_x*sizeof(double));
infY=(double*)malloc(dim_y*sizeof(double));
supY=(double*)malloc(dim_y*sizeof(double));
pasY=(double*)malloc(dim_y*sizeof(double));
casesY=(long*)malloc(S*sizeof(long));
casesX=(long**)malloc(dim_x*sizeof(long*));
for (i=dim_x-1; i>=0; i--) casesX[i]=(long*)malloc(S*sizeof(long));
estimationsX=(long*)malloc((n+1)*sizeof(long));
if (Si) {
   estimationsXY=(long**)malloc((n+1)*sizeof(long*));
   for (j=n; j>=0; j--)
       estimationsXY[j]=(long*)malloc((aux+1)*sizeof(long));
}
estimationsXX=(long**)malloc((n+1)*sizeof(long*));
estimationsXXY=(long***)malloc((n+1)*sizeof(long**));
for (j=n; j>=0; j--) {
    estimationsXX[j]=(long*)malloc((n+1)*sizeof(long));
    estimationsXXY[j]=(long**)malloc((n+1)*sizeof(long*));
    for (k=n; k>=0; k--) 
        estimationsXXY[j][k]=(long*)malloc((aux+1)*sizeof(long));
}
Contrairement aux apparences c'est bien du C++ ^^
En revanche:

- Ca marche avec dev-cpp sous windows
- Ca plante systématiquement avant la fin des allocations avec g++ sous Unix; message d'erreur:

(gdb) run e Parametres/paramE_hs.dat hs 1000 100
Starting program: /home/iooss/benjamin/main e Parametres/paramE_hs.dat hs 1000 100

Program received signal SIGSEGV, Segmentation fault.
0x42074675 in _int_malloc () from /lib/tls/libc.so.6
(gdb) bt
#0 0x42074675 in _int_malloc () from /lib/tls/libc.so.6
#1 0x4207378d in malloc () from /lib/tls/libc.so.6
#2 0x0804ebcb in entrop ()
#3 0x0804adff in main ()
#4 0x42015704 in __libc_start_main () from /lib/tls/libc.so.6

Faut-il que je transforme tous mes "malloc" en "new" ?
Ce qui m'embête c'est que le code suivant fonctionne sous Unix avec g++:

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
 
 
int i,ip,ipp,j;
long k;
double V0=0,my=0;
double *Y,*Yp,*mS1=0,*mSt=0,*minS1=0,*minSt=0,*maxS1=0,*maxSt=0,*sigS1=0,*sigSt=0;
double **mS2=0,**minS2=0,**maxS2=0,**sigS2=0,**X1,**X2,**sav,**S1=0,**St=0;
double ***S2=0;
 
/* initialisation des tableaux contenant les indices */
if (Si) {
    S1=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) {
        S1[i]=(double*)malloc(R*sizeof(double)); 
        for (ip=R-1; ip>=0; ip--) S1[i][ip]=0;
    }
    mS1=(double*)malloc(dim_x*sizeof(double));
    minS1=(double*)malloc(dim_x*sizeof(double));
    maxS1=(double*)malloc(dim_x*sizeof(double));
    sigS1=(double*)malloc(dim_x*sizeof(double));
}
if (Sij) {
    S2=(double***)malloc(dim_x*sizeof(double**));
    for (i=dim_x-1; i>=0; i--) {
        S2[i]=(double**)malloc(dim_x*sizeof(double*));
        for (ip=dim_x-1; ip>=0; ip--) {
            S2[i][ip]=(double*)malloc(R*sizeof(double));
            for (ipp=R-1; ipp>=0; ipp--) S2[i][ip][ipp]=0;
        }
    }
    mS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) mS2[i]=(double*)malloc(dim_x*sizeof(double));
    minS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) minS2[i]=(double*)malloc(dim_x*sizeof(double));
    maxS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) maxS2[i]=(double*)malloc(dim_x*sizeof(double));
    sigS2=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) sigS2[i]=(double*)malloc(dim_x*sizeof(double));
} 
if (Sti) {
    St=(double**)malloc(dim_x*sizeof(double*));
    for (i=dim_x-1; i>=0; i--) {
        St[i]=(double*)malloc(R*sizeof(double));
        for (ip=R-1; ip>=0; ip--) St[i][ip]=0;
    }
    mSt=(double*)malloc(dim_x*sizeof(double));
    minSt=(double*)malloc(dim_x*sizeof(double));
    maxSt=(double*)malloc(dim_x*sizeof(double));
    sigSt=(double*)malloc(dim_x*sizeof(double));
}
 
/* autres initialisations */
X1=(double**)malloc(dim_x*sizeof(double*));
for (i=dim_x-1; i>=0; i--) X1[i]=(double*)malloc(S*sizeof(double));
X2=(double**)malloc(dim_x*sizeof(double*));
for (i=dim_x-1; i>=0; i--) X2[i]=(double*)malloc(S*sizeof(double));
sav=(double**)malloc(dim_x*sizeof(double*));
for (i=dim_x-1; i>=0; i--) sav[i]=(double*)malloc(S*sizeof(double));
alors que les allocations nécessaires sont plus grandes que dans le cas précédent (n de l'ordre de 100, S peut atteindre 500000, 1000000..etc).

Je n'y comprend rien (comme d'habitude :-/)

Merci d'avance,
Benjamin.