Perché alcuni array possono essere pubblicati ma non altri?

Question

type 
    TStaticArray = array[1..10] of integer; 
    TDynamicArray = array of integer; 

    TMyClass = class(TObject) 
    private 
     FStaticArray: TStaticArray; 
     FDynamicArray: TDynamicArray; 
    published 
     property staticArray: TStaticArray read FStaticArray write FStaticArray; //compiler chokes on this 
     property dynamicArray: TDynamicArray read FDynamicArray write FDynamicArray; //compiler accepts this one just fine 
    end; 

Cosa sta succedendo qui? Una matrice statica fornisce l'errore, "staticArray" di proprietà pubblicata non può essere di tipo ARRAY "ma gli array dinamici vanno bene? Non ho capito bene. Qualcuno conosce il ragionamento alla base di questo e come posso aggirarlo? (E no, non voglio ridichiarare tutti i miei array statici come dinamici. Sono le dimensioni che sono per una ragione.)

Answer 1

dichiarazione pubblicata dice al compilatore di memorizzare le informazioni nella tabella metodo virtuale. Solo alcuni tipi di informazioni possono essere memorizzati.
Il tipo di una proprietà pubblicata non può essere un puntatore, un record o una matrice. Se è un tipo impostato, deve essere abbastanza piccolo da essere memorizzato in un numero intero.
(O'REILLY, DELPHİ IN NUTSHELL)

Answer 2

Le proprietà dell'array non possono essere pubblicate. Quindi il seguente codice non funziona. Il lavoro attorno probabilmente è quello di renderlo public.

TMyClass = class(TObject) 
    private 
    FStaticArray: TStaticArray; 

    function GetFoo(Index: Integer): Integer; 
    procedure SetFoo(Index: Integer; Value: Integer); 
    public 
    property Foo[Index: Integer] : Integer read GetFoo write SetFoo; 
    end; 

Answer 3

Il motivo per cui è possibile pubblicare una proprietà di matrice dinamica, è che gli array dinamici è implementato come riferimenti, o 'implicitamente puntatore'. Funzionano più come stringhe, davvero.

Il motivo per cui non è possibile pubblicare un array statico, non lo so. E 'solo il modo in cui è fatto, immagino ..

Per maggiori dettagli su come array dinamici lavorare, dare un'occhiata a DrBobs site

Answer 4

Devi avere getter e setter. Sotto D2009 (non ha controllato altre versioni), i parametri per i getter/setter non possono, per qualche ragione, essere const. ?

Questo funziona bene sotto D2009:

type 
    TMyArray = array[0..20] of string; 

type 
    TMyClass=class(TObject) 
    private 
    FMyArray: TMyArray; 
    function GetItem(Index: Integer): String; 
    procedure SetItem(Index: Integer; Value: string); 
    public 
    property Items[Index: Integer]: string read GetItem write SetItem; 
    end; 

implementation 

function TMyClass.GetItem(Index: Integer): string; 
begin 
    Result := ''; 
    if (Index > -1) and (Index < Length(FMyArray)) then 
    Result := FMyArray[Index]; 
end; 

procedure TMyClass.SetItem(Index: Integer; Value: string); 
begin 
    if (Index > -1) and (Index < Length(FMyArray)) then 
    FMyArray[Index] := Value; 
end; 

NOTA: Non vorrei in genere semplicemente ignorare valori dell'Indice fuori portata, ovviamente. Questo era un rapido esempio di come rendere statiche proprietà di array in una definizione di classe; IOW, è solo un esempio compilabile.

Answer 5

TMyClass = class(TObject) 
    private 
    FStaticArray: TStaticArray; 
    FIdx: Integer; 
    function GetFoo(Index: Integer): Integer; 
    procedure SetFoo(Index: Integer; Value: Integer); 
    public 
    property Foo[Index: Integer] : Integer read GetFoo write SetFoo; 
    published 
    property Idx: Integer read fidx write fidx; 
    property AFoo: Integer read GetAFoo writte SetAFoo; 
    end; 
implementation 
function TMyClass.GetAFoo: Integer; 
begin 
    result := FStaticArray[FIdx]; 
end; 
procedure TMyClass.SetAFoo(Value: Integer); 
begin 
    FStaticArray[FIdx] := Value; 
end;