那些遇到过的问题

为什么我不能返回任意数组的字符串？

Jam*_*mes 6 arrays delphi delphi-xe3

编译器允许我执行以下操作:

procedure MyProc(const ADynData: array of string);
Run Code Online (Sandbox Code Playgroud)

要么

procedure MyProc(const ADynData: TStringDynArray);
Run Code Online (Sandbox Code Playgroud)

并传递任意数据,如下所示:

MyProc(['Data1', 'Data2']);
Run Code Online (Sandbox Code Playgroud)

但是,不允许

function MyFunc: TStringDynArray;
....
function MyFunc: TStringDynArray;
begin
    Result := ['Data1', 'Data2'];
end;
Run Code Online (Sandbox Code Playgroud)

要么

function MyFunc: TStringDynArray;
const
    CDynData: array[0..1] of string = ('Data1', 'Data2');
begin
    Result := CDynData;
end;
Run Code Online (Sandbox Code Playgroud)

为什么是这样？这在技术上是不是一回事？

对于这些特定场景,返回任意数组字符串的建议(和最有效)方法是什么？

And*_*and 10

不,这不是一回事.在

procedure MyProc(const ADynData: array of string);
Run Code Online (Sandbox Code Playgroud)

参数是一个开放的数组参数,它与"普通" 动态数组不同.该[..]语法只能用于在函数的开放数组参数中创建开放数组.(否则,[..]用于在代码中指定集合,例如Font.Style := [fsBold, fsItalic].但是集合只能将序数类型作为其"基本类型",因此仍然没有"字符串集"这样的东西.)

换句话说,就像在第二个代码片段中尝试一样,无法在代码中编写动态数组,

function MyFunc: TStringDynArray;
begin
  result := ['Data1', 'Data2']; // Won't work.
end;
Run Code Online (Sandbox Code Playgroud)

但是,在Delphi的新版本中,它几乎是可能的:

type
  TStringDynArray = array of string;

function MyFunc: TStringDynArray;
begin
  result := TStringDynArray.Create('A', 'B');
end;
Run Code Online (Sandbox Code Playgroud)

最后,

function MyFunc: TStringDynArray;
const
  CDynData: array[0..1] of string = ('Data1', 'Data2');
begin
  result := CDynData;
end;
Run Code Online (Sandbox Code Playgroud)

会不会因为工作TStringDynArray是一个动态数组,同时CDynData是一个静态数组,这是两个不同的基本类型.

Dav*_*nan 6

这个结构

['string1', 'string2']
Run Code Online (Sandbox Code Playgroud)

被称为开放数组构造函数.从文档:

Open数组构造函数允许您直接在函数和过程调用中构造数组.

它们只能作为开放数组参数或变量开放数组参数传递.

因此,您不能使用开放数组构造函数来创建函数返回值.

如果数组中有固定数量的元素需要返回,则可以使用动态数组构造函数:

Result := TStringDynArray.Create('string1', 'string2');
Run Code Online (Sandbox Code Playgroud)

但是,这对于可变数量的元素不起作用.现在,我知道你的问题中的例子只有数组中恒定数量的元素.但我相信你会遇到需要比动态数组构造器提供的更多灵活性的情况.

如果您希望创建现有动态数组的副本并返回该数组,请使用Copy.

Result := Copy(SomeOtherDynamicArray);
Run Code Online (Sandbox Code Playgroud)

当你手头有一个打开的数组时会崩溃.您无法将打开的数组传递给Copy.我个人认为这是一个耻辱,因为开放的数组参数非常灵活和有用,我希望看到尽可能多的RTL支持.

因此,您最终必须为这些情况编写辅助函数.你可以为每种阵列类型编写一个专用的帮助器,但这有点令人厌烦.这就是仿制药派上用场的地方.我有一个辅助课程.这是相关的摘录:

type
  TArray = class(Generics.Collections.TArray)
    ....
    class function Copy<T>(const Source: array of T): TArray<T>; overload; static;
    ....
  end;

class function TArray.Copy<T>(const Source: array of T): TArray<T>;
var
  i: Integer;
begin
  SetLength(Result, Length(Source));
  for i := 0 to high(Result) do begin
    Result[i] := Source[i];
  end;
end;
Run Code Online (Sandbox Code Playgroud)

现在,这适用于您的字符串数组,但也适用于任何其他类型.像这样称呼它:

Result := TArray.Copy<string>(SomeStringOpenArray);
Run Code Online (Sandbox Code Playgroud)

一个关键点是我们使用的是动态数组的通用版本,TArray<string>而不是TStringDynArray.如果你想认真使用泛型,那么你必须这样做.那是因为TStringDynArray与赋值不兼容TArray<string>或实际上任何其他类型声明为array of string.它可以带来红利来改变您的代码库以便TArray<T>在整个过程中使用.

如果有人对这个帮助程序类的其余部分感兴趣,这里是:

type
  TArray = class(Generics.Collections.TArray)
  private
    class function Comparison<T>(SortType: TSortType): TComparison<T>; static;
    class function Comparer<T>(const Comparison: TComparison<T>): IComparer<T>; static;
  public
    class procedure Swap<T>(var Left, Right: T); static;
    class procedure Reverse<T>(var Values: array of T); static;
    class function Reversed<T>(const Values: array of T): TArray<T>; static;
    class function Contains<T>(const Values: array of T; const Item: T; out ItemIndex: Integer): Boolean; overload; static;
    class function Contains<T>(const Values: array of T; const Item: T): Boolean; overload; static;
    class function IndexOf<T>(const Values: array of T; const Item: T): Integer; static;
    class function Sorted<T>(var Values: array of T; SortType: TSortType; Index, Count: Integer): Boolean; overload; static;
    class function Sorted<T>(var Values: array of T; SortType: TSortType): Boolean; overload; static;
    class function Sorted<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer): Boolean; overload; static;
    class function Sorted<T>(var Values: array of T; const Comparison: TComparison<T>): Boolean; overload; static;
    class function Sorted<T>(GetValue: TFunc<Integer,T>; const Comparison: TComparison<T>; Index, Count: Integer): Boolean; overload; static;
    class procedure Sort<T>(var Values: array of T; SortType: TSortType; Index, Count: Integer); overload; static;
    class procedure Sort<T>(var Values: array of T; SortType: TSortType); overload; static;
    class procedure Sort<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer); overload; static;
    class procedure Sort<T>(var Values: array of T; const Comparison: TComparison<T>); overload; static;
    class function Copy<T>(const Source: array of T; Index, Count: Integer): TArray<T>; overload; static;
    class function Copy<T>(const Source: array of T): TArray<T>; overload; static;
    class procedure Move<T>(const Source: array of T; var Dest: array of T; Index, Count: Integer); overload; static;
    class procedure Move<T>(const Source: array of T; var Dest: array of T); overload; static;
    class function Concatenated<T>(const Source1, Source2: array of T): TArray<T>; overload; static;
    class function Concatenated<T>(const Source: array of TArray<T>): TArray<T>; overload; static;
    class procedure Initialise<T>(var Values: array of T; const Value: T); static;
    class procedure Zeroise<T>(var Values: array of T); static;
    class function GetHashCode<T>(const Values: array of T): Integer; overload; static;
    class function GetHashCode<T>(Values: Pointer; Count: Integer): Integer; overload; static;
  end;

class function TArray.Comparison<T>(SortType: TSortType): TComparison<T>;
var
  DefaultComparer: IComparer<T>;
begin
  DefaultComparer := TComparer<T>.Default;
  Result :=
    function(const Left, Right: T): Integer
    begin
      case SortType of
      stIncreasing:
        Result := DefaultComparer.Compare(Left, Right);
      stDecreasing:
        Result := -DefaultComparer.Compare(Left, Right);
      else
        RaiseAssertionFailed(Result);
      end;
    end;
end;

class function TArray.Comparer<T>(const Comparison: TComparison<T>): IComparer<T>;
begin
  Result := TComparer<T>.Construct(Comparison);
end;

class procedure TArray.Swap<T>(var Left, Right: T);
var
  temp: T;
begin
  temp := Left;
  Left := Right;
  Right := temp;
end;

class procedure TArray.Reverse<T>(var Values: array of T);
var
  bottom, top: Integer;
begin
  bottom := 0;
  top := high(Values);
  while top>bottom do begin
    Swap<T>(Values[bottom], Values[top]);
    inc(bottom);
    dec(top);
  end;
end;

class function TArray.Reversed<T>(const Values: array of T): TArray<T>;
var
  i, j, Count: Integer;
begin
  Count := Length(Values);
  SetLength(Result, Count);
  j := Count-1;
  for i := 0 to Count-1 do begin
    Result[i] := Values[j];
    dec(j);
  end;
end;

class function TArray.Contains<T>(const Values: array of T; const Item: T; out ItemIndex: Integer): Boolean;
var
  DefaultComparer: IEqualityComparer<T>;
  Index: Integer;
begin
  DefaultComparer := TEqualityComparer<T>.Default;
  for Index := 0 to high(Values) do begin
    if DefaultComparer.Equals(Values[Index], Item) then begin
      ItemIndex := Index;
      Result := True;
      exit;
    end;
  end;
  ItemIndex := -1;
  Result := False;
end;

class function TArray.Contains<T>(const Values: array of T; const Item: T): Boolean;
var
  ItemIndex: Integer;
begin
  Result := Contains<T>(Values, Item, ItemIndex);
end;

class function TArray.IndexOf<T>(const Values: array of T; const Item: T): Integer;
begin
  Contains<T>(Values, Item, Result);
end;

class function TArray.Sorted<T>(var Values: array of T; SortType: TSortType; Index, Count: Integer): Boolean;
begin
  Result := Sorted<T>(Values, Comparison<T>(SortType), Index, Count);
end;

class function TArray.Sorted<T>(var Values: array of T; SortType: TSortType): Boolean;
begin
  Result := Sorted<T>(Values, Comparison<T>(SortType));
end;

class function TArray.Sorted<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer): Boolean;
var
  i: Integer;
begin
  for i := Index+1 to Index+Count-1 do begin
    if Comparison(Values[i-1], Values[i])>0 then begin
      Result := False;
      exit;
    end;
  end;
  Result := True;
end;

class function TArray.Sorted<T>(var Values: array of T; const Comparison: TComparison<T>): Boolean;
begin
  Result := Sorted<T>(Values, Comparison, 0, Length(Values));
end;

class function TArray.Sorted<T>(GetValue: TFunc<Integer, T>; const Comparison: TComparison<T>; Index, Count: Integer): Boolean;
var
  i: Integer;
begin
  for i := Index+1 to Index+Count-1 do begin
    if Comparison(GetValue(i-1), GetValue(i))>0 then begin
      Result := False;
      exit;
    end;
  end;
  Result := True;
end;

class procedure TArray.Sort<T>(var Values: array of T; SortType: TSortType; Index, Count: Integer);
begin
  Sort<T>(Values, Comparison<T>(SortType), Index, Count);
end;

class procedure TArray.Sort<T>(var Values: array of T; SortType: TSortType);
begin
  Sort<T>(Values, SortType, 0, Length(Values));
end;

class procedure TArray.Sort<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer);
begin
  if not Sorted<T>(Values, Comparison, Index, Count) then begin
    Sort<T>(Values, Comparer<T>(Comparison), Index, Count);
  end;
end;

class procedure TArray.Sort<T>(var Values: array of T; const Comparison: TComparison<T>);
begin
  Sort<T>(Values, Comparison, 0, Length(Values));
end;

class function TArray.Copy<T>(const Source: array of T; Index, Count: Integer): TArray<T>;
var
  i: Integer;
begin
  SetLength(Result, Count);
  for i := 0 to high(Result) do begin
    Result[i] := Source[i+Index];
  end;
end;

class function TArray.Copy<T>(const Source: array of T): TArray<T>;
var
  i: Integer;
begin
  SetLength(Result, Length(Source));
  for i := 0 to high(Result) do begin
    Result[i] := Source[i];
  end;
end;

class procedure TArray.Move<T>(const Source: array of T; var Dest: array of T; Index, Count: Integer);
var
  i: Integer;
begin
  for i := 0 to Count-1 do begin
    Dest[i] := Source[i+Index];
  end;
end;

class procedure TArray.Move<T>(const Source: array of T; var Dest: array of T);
var
  i: Integer;
begin
  for i := 0 to high(Source) do begin
    Dest[i] := Source[i];
  end;
end;

class function TArray.Concatenated<T>(const Source1, Source2: array of T): TArray<T>;
var
  i, Index: Integer;
begin
  SetLength(Result, Length(Source1)+Length(Source2));
  Index := 0;
  for i := low(Source1) to high(Source1) do begin
    Result[Index] := Source1[i];
    inc(Index);
  end;
  for i := low(Source2) to high(Source2) do begin
    Result[Index] := Source2[i];
    inc(Index);
  end;
end;

class function TArray.Concatenated<T>(const Source: array of TArray<T>): TArray<T>;
var
  i, j, Index, Count: Integer;
begin
  Count := 0;
  for i := 0 to high(Source) do begin
    inc(Count, Length(Source[i]));
  end;
  SetLength(Result, Count);
  Index := 0;
  for i := 0 to high(Source) do begin
    for j := 0 to high(Source[i]) do begin
      Result[Index] := Source[i][j];
      inc(Index);
    end;
  end;
end;

class procedure TArray.Initialise<T>(var Values: array of T; const Value: T);
var
  i: Integer;
begin
  for i := 0 to high(Values) do begin
    Values[i] := Value;
  end;
end;

class procedure TArray.Zeroise<T>(var Values: array of T);
begin
  Initialise<T>(Values, Default(T));
end;

{$IFOPT Q+}
  {$DEFINE OverflowChecksEnabled}
  {$Q-}
{$ENDIF}
class function TArray.GetHashCode<T>(const Values: array of T): Integer;
// see http://stackoverflow.com/questions/1646807 and http://stackoverflow.com/questions/11294686
var
  Value: T;
  EqualityComparer: IEqualityComparer<T>;
begin
  EqualityComparer := TEqualityComparer<T>.Default;
  Result := 17;
  for Value in Values do begin
    Result := Result*37 + EqualityComparer.GetHashCode(Value);
  end;
end;

class function TArray.GetHashCode<T>(Values: Pointer; Count: Integer): Integer;
// see http://stackoverflow.com/questions/1646807 and http://stackoverflow.com/questions/11294686
var
  Value: ^T;
  EqualityComparer: IEqualityComparer<T>;
begin
  EqualityComparer := TEqualityComparer<T>.Default;
  Result := 17;
  Value := Values;
  while Count>0 do begin
    Result := Result*37 + EqualityComparer.GetHashCode(Value^);
    inc(Value);
    dec(Count);
  end;
end;
{$IFDEF OverflowChecksEnabled}
  {$Q+}
{$ENDIF}
Run Code Online (Sandbox Code Playgroud)

  • 请不要因为迂腐而杀了我,但是第一行IMNSHO确实不应该有冒号. (2认同)

归档时间：

查看次数：

3449 次

最近记录：

10 年，1 月 前
快速简单的哈希码组合 55
为TEqualityComparer.Construct编写hasher函数的规范方法是什么？ 5
更多相关链接
相关归档
在C中声明和初始化数组 52
如何从数组中的所有元素修剪空白？ 36
数组像Javascript中的对象 31
在浮点数组中找到最小值 29
PHP try-catch块:它们能够捕获无效的arg类型吗？ 14
使用stdlib的qsort()对字符串数组进行排序 8
使用Play Framework和Java解析Json数组 8
如何打开/关闭显示器？ 7
如何使用Delphi并行化检查拼写？ 5
构建软件包时同时出现间歇性虚假 Delphi E2200 和 E2213：如何解决？ 5
难疑归档
使用Git将最近的提交移动到新分支 4647
不区分大小写'包含(字符串)' 2785
'using'指令应该在命名空间的内部还是外部？ 1975
如何在Notepad ++中格式化XML？ 1661
var关键字的目的是什么？我何时应该使用它(或省略它)？ 1508
如何在JavaScript中将十进制转换为十六进制？ 1387
UNION和UNION ALL有什么区别？ 1350
除了XHTML自包含标记之外,RegEx匹配开放标记 1323
如何使用sed替换换行符(\n)？ 1295
如何旋转Android模拟器显示？ 1031