Comment traduire le code C++ en Delphi

Question

J'essaie de traduire du code C++ en Delphi.

Le code traite C++ avec quelques tableaux de ce seul:

const float* const inp 
const float* const prWeight 

Je définis les types suivants pour les traiter:

type 
    TSingleArray = array of Single; 
    PSingleArray = ^TSingleArray; 

lorsque le code C ajoute à la varible comme si :

inp += 5 

Je suppose que la variable est mise à jour avec le décalage de la 5'th produite CE et i peut définir un indice de 5 et de la valeur d'accès de la 5 occurence comme ceci:

i := 5; 
PSingleArray(inp)^[i] := 0.5; 

et le code C:

for (int j = 5; j; --j) { 
    *inp++ += *prWeight++*ari; 

peut être traduit à

x := 0; 
for j := 5 downto 0 do 
    begin 
     Inc(i); 
     PSingleArray(inp)^[i] := PSingleArray(inp)^[i] + 
     PSingleArray(prWeight)^[x] * ari; 
    end; 

est-ce correct?

aussi je me demande. Si:

inp[k++] = nc == 1; 
inp[k++] = nc == 2; 
inp[k++] = nc >= 3; 

soit:

Inc(k); 
PSingleArray(inp)^[k] := Ord(nc = 1); 
Inc(k); 
PSingleArray(inp)^[k] := Ord(nc = 2); 
Inc(k); 
PSingleArray(inp)^[k] := Ord(nc = 3); 

ou:

Inc(k); 
PSingleArray(inp)^[k] := Ord(nc = 1); 
PSingleArray(inp)^[k] := Ord(nc = 2); 
PSingleArray(inp)^[k] := Ord(nc = 3); 

Je ne suis pas sûr que ce soit correct. Est-ce que quelqu'un a une idée?

Answer 1

Vous ne devriez pas essayer de faire une traduction directe, en particulier avec l'arithmétique pointeur/tableau entremêlé.

Quelques notes:

Goutte PSingleArray. Delphi n'a pas la conversion implicite entre les pointeurs et les tableaux que C a. Toute l'arithmétique sur les pointeurs doit devenir arithmétique sur un index de tableau. Les copies de pointeurs sont des copies d'indices de tableau. L'indexation de tableau sur un pointeur incrémenté devient une somme de plusieurs parties d'index.

Certains de ce code est unidiomatic C, vous ne devez pas faire encore plus unidiomatic Delphi

for (int j = 5; j; --j) { 
    *inp++ += *prWeight++*ari; 
} 

// previous incrementing of inp went into i 
for j := 0 to 4 do 
begin 
    inp[i + j] := inp[i + j] + prWeight[j] * ari; 
end; 
i = i + 5; 

Notez que dans C varie sont à moitié ouvertes, l'indice final ne soit pas utilisé.

inp[k++] = ... utilise un opérateur de post-incrémentation. L'indice utilisé est la valeur non modifiée de k, qui devient inp[k] := ...; Inc(k);. Notez également l'utilisation de >=. Je ne recommanderais pas simplement de lancer Boolean => Single pour les conversions à 1.0 et 0.0, mais je manque de contexte pour suggérer un meilleur design.