Conversion C en Delphi

Version imprimable

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:

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:

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

Je vois deux choix :

Code:

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:

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;

26/02/2023, 18h12
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

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

Citation:

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:

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.

Citation:

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

03/03/2023, 10h49
ch16089

Merci wheel pour votre aide.