Discussion :

[ch16089]

Bonjour,
Je suis en train de convertir un programme C en Delphi.
Mes connaissances en C sont limitées, notamment concernant l'utilisation de pointeurs en C et des conventions d'écriture associées en C.
Je bloque sur la conversion de la fonction suivante :

Code c :

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
MAGtype_LegendreFunction *MAG_AllocateLegendreFunctionMemory(int NumTerms)
 
/* Allocate memory for Associated Legendre Function data types.
   Should be called before computing Associated Legendre Functions.
 
 INPUT: NumTerms : int : Total number of spherical harmonic coefficients in the model
 
 
 OUTPUT:    Pointer to data structure MAGtype_LegendreFunction with the following elements
                        double *Pcup;  (  pointer to store Legendre Function  )
                        double *dPcup; ( pointer to store  Derivative of Legendre function )
 
                        FALSE: Failed to allocate memory
 
CALLS : none
 
 */
{
    MAGtype_LegendreFunction *LegendreFunction;
 
    LegendreFunction = (MAGtype_LegendreFunction *) calloc(1, sizeof (MAGtype_LegendreFunction));
 
    if(!LegendreFunction)
    {
        MAG_Error(1);
        return NULL;
    }
    LegendreFunction->Pcup = (double *) malloc((NumTerms + 1) * sizeof ( double));
    if(LegendreFunction->Pcup == 0)
    {
        MAG_Error(1);
        return NULL;
    }
    LegendreFunction->dPcup = (double *) malloc((NumTerms + 1) * sizeof ( double));
    if(LegendreFunction->dPcup == 0)
    {
        MAG_Error(1);
        return NULL;
    }
    return LegendreFunction;
} /*MAGtype_LegendreFunction*/

Le type MAGtype_LegendreFunction est défini par :

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct {
    double *Pcup; /* Legendre Function */
    double *dPcup; /* Derivative of Legendre fcn */
} MAGtype_LegendreFunction;

Pouvez-vous m'aider à convertir en Delphi le type MAGtype_LegendreFunction et la fonction MAG_AllocateLegendreFunctionMemory ?

Merci pour votre aide.

Thierry RICHET

[wheel]

Je vois deux choix :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type
  PDoubleArray = array[0..$ffffff];
  PMAGtype_LegendreFunction = ^MAGtype_LegendreFunction;
  MAGtype_LegendreFunction = record  
	Pcup :PDoubleArray;
	dPcup:PDoubleArray;
  end;
 
function MAG_AllocateLegendreFunctionMemory(NumTerms:integer):PMAGtype_LegendreFunction; 
begin
    New(Result); 
    GetMem(Result.Pcup,(NumTerms + 1) * sizeof( double));
    GetMem(Result.dPcup,(NumTerms + 1) * sizeof( double));   
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
type
  PMAGtype_LegendreFunction = ^MAGtype_LegendreFunction;
  MAGtype_LegendreFunction = record 
	Pcup :array of double;
	dPcup:array of double;
  end;
 
function MAG_AllocateLegendreFunctionMemory(NumTerms:integer):PMAGtype_LegendreFunction; 
begin
    New(Result); 
    SetLength(Result.Pcup, NumTerms + 1);
    SetLength(Result.dPcup,NumTerms + 1);   
end;

[ch16089]

Bonjour,

Merci à wheel pour sa réponse.

Le 2ème code proposé fonctionne tel quel. Il fonctionne également sans utiliser de pointeur sur le type "MAGtype_LegendreFunction".
Avec ce code, la taille en mémoire d'une variable de type "MAGtype_LegendreFunction" est de "2 * 8 * NumTerms" octets.

Le 1er code conduit à une erreur de compilation en ligne 2. Cette erreur disparait en remplaçant cette ligne par "PDoubleArray = array[0..$ffffff] of double;".
Avec ce code, la taille en mémoire d'une variable de type "MAGtype_LegendreFunction" est de "2 * 8 * $ffffff" octets quelque soit la valeur passée à "NumTerms".

Comment optimiser le 1er code pour optimiser la taille en mémoire d'une variable de type "MAGtype_LegendreFunction" ?

Nota : je vais tester au cours de la semaine prochaine la solution du 2ème code dans le programme C en cours de conversion, si le résultat est satisfaisant, je clôturerais la discussion.

En attente de réponse.

Thierry RICHET

[wheel]

c’était une erreur de ma part je n'avais pas vérifier bien le code

Avec ce code, la taille en mémoire d'une variable de type "MAGtype_LegendreFunction" est de "2 * 8 * $ffffff" octets quelque soit la valeur passée à "NumTerms".

Les champs Pcup et dPcup devraient être un pointeur vers un tableau de type Double créé dynamiquement par GetMem, la définition du bord supérieur n'est que pour échapper à la vérification de l'indice au cas ou elle est activée dans le programme, en théorie même array[0..0] of double fonctionne.

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
type
  TDoubleArray =  array[0..$FFFFF] of Double;
  PDoubleArray =  ^TDoubleArray;
  PMAGtype_LegendreFunction = ^MAGtype_LegendreFunction;
  MAGtype_LegendreFunction = record
  Pcup :PDoubleArray;
	dPcup:PDoubleArray;
  end;
 
function MAG_AllocateLegendreFunctionMemory(NumTerms:integer):PMAGtype_LegendreFunction;
begin
    New(Result);
    GetMem(Result.Pcup,(NumTerms + 1) * sizeof( double));
    GetMem(Result.dPcup,(NumTerms + 1) * sizeof( double));
end;
 
procedure FreeMAGtype(pMG:PMAGtype_LegendreFunction);
begin
    FreeMem(pMG.Pcup);
    FreeMem(pMG.dPcup);
    Dispose(pMG);
end;

pour libérer la mémoire utiliser FreeMAGtype.

Le 2ème code proposé fonctionne tel quel. Il fonctionne également sans utiliser de pointeur sur le type "MAGtype_LegendreFunction".
Avec ce code, la taille en mémoire d'une variable de type "MAGtype_LegendreFunction" est de "2 * 8 * NumTerms" octets.

n’oublier pas de libérer la mémoire après l'utilisation, pour ce code Dispose suffit

[ch16089]

Merci wheel pour votre aide.