A definição de tipos de outras unidades em Delphi

Question

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

Begin
    A := B;

Não funciona como loren-pechtel disse: aqui o problema é A e B, para mim, estão em unidades diferentes.Assim, há uma maneira para definir um tipo de definição a partir de uma já existente em outra classe?

Answer 1

Defina o tipo no bloco de interface de alguma unidade e inclua essa unidade via uses Cláusula em outras unidades onde você precisa desse tipo.

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

...

Quando você precisa usar TMyArray em outra unidade:

unit B;
interface
uses A;

...
var x : TMyArray;

Answer 2

Como alternativa, defina seu tipo na seção de interface da Unidade C e use esta unidade em A e B.

Answer 3

Os tipos de matriz em Delphi são um pouco estranhos. Isto parece Como A e B são exatamente do mesmo tipo, mas Delphi não considera que eles são iguais. "Array [1..4] de Integer" aparece duas vezes, então Delphi acha que existem dois tipos diferentes. Isso é apenas uma estranheza de Delphi. A maioria dos outros idiomas, eu acho, não se importaria. Não é um problema na prática; É um pouco estranho. Talvez haja uma boa razão para isso. Quem sabe. A solução, como os outros disseram, é definir seu próprio tipo, que você pode colocar em uma unidade que pode ser usada por outras unidades. Acabei de mencionar esta questão dos tipos de matriz porque pode estar confundindo você.

Answer 4

Outra abordagem, um pouco antiga, mas ainda funciona, é usar a palavra -chave absoluta para forçar a memória de um a sobrepor outra e tornar o outro tipo compatível. Por exemplo, na unidade A, digamos que você tenha o seguinte:

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

Então, na unidade B, você tem o seguinte:

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

Para compatibilidade, você pode fazer o seguinte:

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

O que isso faz é criar uma variável "instantaBasa" do tipo Arraya, que se sobrepõe ao mesmo espaço de memória que a variável "instanceB". Isso permite que você faça o seguinte comando:

InstanceA := InstanceBasA;

Answer 5

Mais um método de transferência de dados de variablea para variávelb é usar o comando MOVE.Por exemplo, para mover a partir de ArrayA para ArrayB você pode fazer o seguinte:

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;

Isso funciona pelo fato de que a matriz é disposto numa forma linear, de modo que a sua cópia bytes começando a primeira posição de matriz, para o comprimento da matriz.

Answer 6

Você pode forçar o compilador a assumir que eles são do mesmo tipo, digitando -os:

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

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

Mas você deve garantir que ambos sejam matriz [1..4] de, caso contrário, você substituirá alguma memória. É por isso que adicionei as duas afirmações.

Answer 7

Basta usar o UnitA no Unitb depois Inteface e antes do implementação ...!!!!

Answer 8

Nunca, nunca, nunca use código como este:

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

Onde está a falha? Você está usando o tamanho da fonte para obter o número de bytes para se mover, não o tamanho do destino !!! Se sizeof (a)> sizeof (b), você tem um excesso de buffer e substitui a memória. Se você tiver sorte, você recebe um AV, se não estiver, você tem uma vulnerabilidade explorável. É muito melhor sempre usar o tamanho do destino, embora dessa maneira você possa acabar lendo a memória Você não deve se o tamanho (b)> tamanho (a), talvez expondo dados indesejados. De qualquer forma, sempre verifique os limites da estrutura ao mover dados - algumas empresas proibiram operações como essa (ou seja, memcpy ()) de seu código.