System.Generics.Collections.TArray.Copy

[Der schöne Günther]

Ich bin zu dumm dafür. Wie ist das gemeint? Doku ist natürlich keine vorhanden.

Delphi-Quellcode:

var
   firstArray, secondArray: TArray<Integer>;
begin
   firstArray := [5,4,3,2,1];
   SetLength(secondArray, Length(firstArray));
   TArray.Copy(firstArray, secondArray, Length(firstArray));

Ich finde, das ist richtig. Tatsächlich wirft er mir aber eine

Delphi-Quellcode:

EArgumentOutOfRangeException

-Exception um die Ohren denn in
System.Generics.Collections.pas steht:

Delphi-Quellcode:

class procedure TArray.CheckArrays(Source, Destination: Pointer; SourceIndex, SourceLength, DestIndex, DestLength, Count: NativeInt);
begin
  if (SourceIndex < 0) or (DestIndex < 0) or (SourceIndex >= SourceLength) or (DestIndex >= DestLength) or
     (SourceIndex + Count >= SourceLength) or (DestIndex + Count >= DestLength) then
    raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
  if Source = Destination then
    raise EArgumentException.CreateRes(@sSameArrays);
end;

Warum ist es denn ungültig wenn SourceIndex + Count >= SourceLength sind? Das muss doch so sein. Wenn ich ein Array mit fünf Elementen kopieren will- Dann ist doch Index = 0, Count = 5 und Length = 5.

Ich finde, er müsste auf ">" prüfen und nicht ">="



Wo ist mein Denkfehler?

[himitsu]

Copy?
Meinst du nicht eher

Delphi-Quellcode:

TArray.Copy<Integer>

Zitat:

Delphi-Quellcode:

class procedure Copy<T>(const Source, Destination: array of T; SourceIndex, DestIndex, Count: NativeInt); overload; static;
class procedure Copy<T>(const Source, Destination: array of T; Count: NativeInt); overload; static;

Auch wenn ich die OH ein bissl eigenartig finde, denn einer der Array (Dest) sollte doch VAR sein. :gruebel:


Aber ja, > wäre da wohl besser.

Code:

0123456789
   *******

(SourceIndex + Count >= SourceLength)
(3 + 7 >= 10) = True

PS: Dein Beispiel kann man auch mit den alten Funktionen umsetzen.

Delphi-Quellcode:

firstArray := [5,4,3,2,1];
secondArray := Copy(firstArray);

Und gab es nicht auch eine Insert-Funktion im TArray?

[Sir Rufo]

Da sind zwei Fehler den ich schon gemeldet habe ...

https://quality.embarcadero.com/browse/RSP-9620
https://quality.embarcadero.com/browse/RSP-9622

[Der schöne Günther]

Danke! Scheint aber nicht so wichtig zu sein da die Tickets noch nicht einmal jemandem zugewiesen sind. Ich meine, Arrays kopieren. Wer tut das schon.

Ich weiß immer nicht, ob ich mich freuen oder weinen soll wenn man sieht dass der Fehler nicht im eigenen Kopf, sondern im Embarcadero Sourcecode steckt :-D

[himitsu]

Zitat:

Zitat von Der schöne Günther (Beitrag 1280888)

Ich meine, Arrays kopieren. Wer tut das schon.

Dabei wurde es doch als eines DER Features angepriesen, weswegen man das neue Delphi kaufen sollte ... Also dann sollte es auch besser mal funktionieren. :roll:

Zitat:

https://quality.embarcadero.com/browse/RSP-9620

Ohne eingelogt zu sein, kann man das ja nun nichmal mehr lesen. :wall:

[Uwe Raabe]

Zitat:

Zitat von Der schöne Günther (Beitrag 1280879)

Ich finde, das ist richtig. Tatsächlich wirft er mir aber eine

Delphi-Quellcode:

EArgumentOutOfRangeException

-Exception um die Ohren denn in
System.Generics.Collections.pas steht:

Delphi-Quellcode:

class procedure TArray.CheckArrays(Source, Destination: Pointer; SourceIndex, SourceLength, DestIndex, DestLength, Count: NativeInt);
begin
  if (SourceIndex < 0) or (DestIndex < 0) or (SourceIndex >= SourceLength) or (DestIndex >= DestLength) or
     (SourceIndex + Count >= SourceLength) or (DestIndex + Count >= DestLength) then
    raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
  if Source = Destination then
    raise EArgumentException.CreateRes(@sSameArrays);
end;

Das steht in meinem XE7 aber anders da:

Delphi-Quellcode:

class procedure TArray.CheckArrays(Source, Destination: Pointer; SourceIndex, SourceLength, DestIndex, DestLength, Count: NativeInt);
begin
  if (SourceIndex < 0) or (DestIndex < 0) or (SourceIndex >= SourceLength) or (DestIndex >= DestLength) or
     (SourceIndex + Count > SourceLength) or (DestIndex + Count > DestLength) then
    raise EArgumentOutOfRangeException.CreateRes(@SArgumentOutOfRange);
  if Source = Destination then
    raise EArgumentException.CreateRes(@sSameArrays);
end;

[Der schöne Günther]

Jetzt bin ich verwirrt. Ich stehe weiterhin zu meinem Wort, meine XE7 System.Generics.Collections.pas enthält genau das! Enterprise und Architect sollten sich doch hier nicht unterscheiden?
In der Fixlist für XE7.1 finde ich auch nichts passendes.


Größe: 72.436 Bytes
Embarcadero® RAD Studio XE7 Version 21.0.17017.3725
Enterprise

[himitsu]

Zitat:

Delphi-Quellcode:

if Source = Destination then

Man darf die Funktionen nicht verwenden, um Daten innerhalb eines Arrays umukopieren?

Das ist aber blöd.

[Union]

@Uwe, bei Build 21.0.17017.3725 war es aber noch die vom OP genannte Variante. Du hast sicher Update 1 bereits installiert. Allerdings ist diese Änderung nicht in den Release notes.

[Uwe Raabe]

Zitat:

Zitat von Union (Beitrag 1280908)

@Uwe, bei Build 21.0.17017.3725 war es aber noch die vom OP genannte Variante. Du hast sicher Update 1 bereits installiert. Allerdings ist diese Änderung nicht in den Release notes.

Vermutlich ist es so, daß der Fix in Update 1 enthalten ist. Im Moment kann ich das auch nicht kontrollieren.

Man kann sich vielleicht doch nicht immer auf die Vollständigkeit der Bugfix-Liste verlassen.

[Der schöne Günther]

Gewissheit würden wir kriegen wenn wir noch mindestens einen

• mit XE7
• mit XE7.1

das kontrollieren lassen könnten. Freiwillige vor!

[Union]

@DsG: Meine Build-Nummer (7.0) habe ich angegeben, und dort ist es noch so wie bei Dir. Uwe scheint wie gesagt die 7.1 zu haben.

[Uwe Raabe]

Embarcadero® RAD Studio XE7 Version 21.0.17707.5020 (entspricht XE7 Update 1)

[Uwe Raabe]

OMG! :shock:

Wer hat denn den Code von TArray.Copy<T> durch die Qualitätsprüfung gelassen?

Delphi-Quellcode:

class procedure TArray.Copy<T>(const Source, Destination: array of T; SourceIndex, DestIndex, Count: NativeInt);
begin
  CheckArrays(Pointer(@Source[0]), Pointer(@Destination[0]), SourceIndex, Length(Source), DestIndex, Length(Destination), Count);
  if IsManagedType(T) then
    System.CopyArray(Pointer(@Destination[SourceIndex]), Pointer(@Source[SourceIndex]), TypeInfo(T), Count)
  else
    System.Move(Pointer(@Destination[SourceIndex])^, Pointer(@Source[SourceIndex])^, Count * SizeOf(T));
end;

Die Deklaration von System.CopyArray ist zwar

Delphi-Quellcode:

procedure CopyArray(Dest, Source...

aber die von System.Move immer noch

Delphi-Quellcode:

procedure Move(const Source; var Dest;...

[Sir Rufo]

Als Ergänzung hier mal meine TestCases, die ich an den jeweiligen BugReport gehängt habe

RSP-9620

Delphi-Quellcode:

unit Test.System;

interface

uses
  TestFramework;

type
  Test_System_Routines = class( TTestCase )
  strict private
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure Test_CopyArray_Integer;
    procedure Test_CopyArray_Int64;
    procedure Test_CopyArray_String;
    procedure Test_CopyArray_Variant;
  end;

implementation

procedure Test_System_Routines.SetUp;
begin
  inherited;
end;

procedure Test_System_Routines.TearDown;
begin
  inherited;
end;

procedure Test_System_Routines.Test_CopyArray_Integer;
var
  LSource : TArray<Integer>;
  LDest: TArray<Integer>;
  LLength : Integer;
begin
  LLength := 5;
  SetLength( LSource, LLength );
  SetLength( LDest, LLength );
  CopyArray( @LDest[0], @LSource[0], TypeInfo( Integer ), LLength );
end;

procedure Test_System_Routines.Test_CopyArray_Int64;
var
  LSource : TArray<Int64>;
  LDest: TArray<Int64>;
  LLength : Integer;
begin
  LLength := 5;
  SetLength( LSource, LLength );
  SetLength( LDest, LLength );
  CopyArray( @LDest[0], @LSource[0], TypeInfo( Int64 ), LLength );
end;

procedure Test_System_Routines.Test_CopyArray_String;
var
  LSource : TArray<string>;
  LDest: TArray<string>;
  LLength : Integer;
begin
  LLength := 5;
  SetLength( LSource, LLength );
  SetLength( LDest, LLength );
  CopyArray( @LDest[0], @LSource[0], TypeInfo( string ), LLength );
end;

procedure Test_System_Routines.Test_CopyArray_Variant;
var
  LSource : TArray<Variant>;
  LDest: TArray<Variant>;
  LLength : Integer;
begin
  LLength := 5;
  SetLength( LSource, LLength );
  SetLength( LDest, LLength );
  CopyArray( @LDest[0], @LSource[0], TypeInfo( Variant ), LLength );
end;

initialization

RegisterTest( Test_System_Routines.Suite );

end.

RSP-9622

Delphi-Quellcode:

unit Test.System.Generics.Collections;

interface

uses
  TestFramework,
  System.Generics.Collections;

type
  Test_System_Generics_Collections_TArray = class( TTestCase )
  strict private
    FSource: TArray<Integer>;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure Test_Copy_1;
    procedure Test_Copy_2;
    procedure Test_Copy_3;
    procedure Test_Copy_4;
  end;

implementation

procedure Test_System_Generics_Collections_TArray.SetUp;
begin
  inherited;
  SetLength( FSource, 10 );
end;

procedure Test_System_Generics_Collections_TArray.TearDown;
begin
  inherited;

end;

procedure Test_System_Generics_Collections_TArray.Test_Copy_1;
var
  LDest: TArray<Integer>;
begin
  SetLength( LDest, 5 );
  TArray.Copy<Integer>( FSource, LDest, Length( LDest ) );
end;

procedure Test_System_Generics_Collections_TArray.Test_Copy_2;
var
  LDest: TArray<Integer>;
begin
  SetLength( LDest, 5 );
  TArray.Copy<Integer>( FSource, LDest, Length( LDest ) - 1 );
end;

procedure Test_System_Generics_Collections_TArray.Test_Copy_3;
var
  LDest: TArray<Integer>;
begin
  SetLength( LDest, 5 );
  TArray.Copy<Integer>( FSource, LDest, 0, 0, Length( LDest ) );
end;

procedure Test_System_Generics_Collections_TArray.Test_Copy_4;
var
  LDest: TArray<Integer>;
begin
  SetLength( LDest, 5 );
  TArray.Copy<Integer>( FSource, LDest, 0, 0, Length( LDest ) - 1 );
end;

initialization

RegisterTest( Test_System_Generics_Collections_TArray.Suite );

end.

[Uwe Raabe]

https://quality.embarcadero.com/browse/RSP-9763

Ich plädiere für ein XE7 Update 2...