types Définition d'autres unités Delphi

Question

Var
     A : Array [1..4] of Integer;
     B : Array [1..4] of Integer;

Begin
    A := B;

ne fonctionne pas comme dit Loren-pechtel ici le problème est A et B pour moi sont dans des unités différentes. Alors, est-il un moyen de définir une définition de type d'un existant dans une autre classe?

Answer 1

Définir le type dans le bloc d'interface d'une certaine unité et inclure cette unité via la clause de uses dans d'autres unités où vous avez besoin de ce type.

unit A;
interface
type
  TMyArray = array [1..4] of Integer;

...

Lorsque vous devez utiliser TMyArray dans une autre unité:

unit B;
interface
uses A;

...
var x : TMyArray;

Answer 2

En variante, définir le type de la section d'interface de l'unité C et en utilisant cet appareil à la fois A et B.

Answer 3

types de tableaux dans Delphi sont un peu bizarre. Il regarde comme A et B sont exactement du même type, mais Delphi ne considère pas que ce sont les mêmes. "Array [1..4] of Integer" apparaît deux fois, alors Delphi pense qu'il existe deux types différents. C'est juste une bizarrerie de Delphes. La plupart des autres langues, je pense, ne se soucieraient pas. Ce n'est pas un problème dans la pratique; il est juste un peu étrange. Peut-être il y a une bonne raison pour cela. Qui sait. La solution, comme les autres l'ont dit, est de définir votre propre type, que vous pouvez mettre dans une unité qui peut être utilisé par d'autres unités. Je mentionne simplement cette question des types de tableaux, car il peut être vous confondre.

Answer 4

Une autre approche, un peu vieille école, mais fonctionne toujours, est d'utiliser le mot-clé ABSOLU pour forcer la mémoire d'un à superposer une autre, et rendre l'autre type compatible. Par exemple, dans l'unité une laisse dire que vous avez les éléments suivants:

TYPE
  TArrayA = Array[1..4] of integer;

puis dans l'unité b, vous disposez des éléments suivants:

TYPE
  TArrayB = Array[1..4] of integer;  

Pour la compatibilité, vous pouvez faire ce qui suit:

VAR
  InstanceA : TArrayA;
  InstanceB : TArrayB;
  InstanceBasA : TArrayA ABSOLUTE InstanceB;

Qu'est-ce que cela fait est de créer une variable « InstanceBasA » de type Arraya qui recouvre le même espace mémoire que la variable « InstanceB ». Cela vous permet de faire la commande suivante:

InstanceA := InstanceBasA;

Answer 5

Une autre méthode pour déplacer des données à partir de variableA variableB est d'utiliser la commande MOVE. Par exemple, pour passer de Arraya vous pouvez ArrayB faire ce qui suit:

var
  ArrayA : array[1..4] of Integer;
  ArrayB : Array[1..4] of Integer;
begin
  FillChar(ArrayB[1],SizeOf(ArrayB),#0);
  ArrayA[1] := 1234;
  ArrayA[2] := 3456;
  ArrayA[3] := 7890;
  ArrayA[4] := 9876;

  // This is where the move from ArrayA to ArrayB happens.
  Move( ArrayA[1], ArrayB[1], SizeOf(ArrayA) );

  Assert( ArrayA[4] = ArrayB[4], 'ArrayA[4] <> ArrayB[4]');
end;

Cela fonctionne par le fait que le tableau est aménagé de façon linéaire, de sorte que votre copie les octets à partir de la première position du tableau, pour la longueur du tableau.

Answer 6

Vous pouvez forcer le compilateur à supposer qu'ils sont du même type en les typecasting:

type
  TIntArray = array[1..4] of integer;

begin
  Assert(SizeOf(ArrayA) = SizeOf(TIntArray));
  Assert(SizeOf(ArrayB) = SizeOf(TIntArray));
  TIntArray(ArrayA) := TIntArray(ArrayB);

Mais vous devez vous assurer que les deux sont en fait array [1..4] de vous remplaceriez de la mémoire. Voilà pourquoi j'ai ajouté les deux affirmations.

Answer 7

Il suffit d'utiliser dans l'unité après UnitS Interface et avant la balise mise en œuvre ... !!!!

Answer 8

Jamais, jamais, ne jamais utiliser le code comme ceci:

// This is where the move from ArrayA to ArrayB happens.
Move( ArrayA[1], ArrayB[1], SizeOf(ArrayA) );

Où est la faille? Vous utilisez la taille de source pour obtenir le nombre d'octets à se déplacer, pas la taille DESTINATION !!! Si SizeOf (A)> SizeOf (B) vous avez un dépassement de mémoire tampon et vous écrasez la mémoire. Si vous êtes chance vous obtenez un AV, si vous n'êtes pas vous avez une vulnérabilité exploitable. Il est beaucoup mieux d'utiliser toujours la taille de destination, bien que cette façon vous pouvez finir par la mémoire de lecture vous ne devriez pas si la taille (B)> Taille (A), peut-être exposer les données indésirables. Quoi qu'il en soit, vérifiez toujours les limites de la structure lors du déplacement des données - certaines entreprises opérations interdites comme celui-ci (à savoir memcpy ()) à partir de leur code

.