泛型类创建多对象遇问题：构造函数未调用指定T类实现求助

你的核心问题在于泛型类中调用T.Create()时，没有匹配具体类的构造函数签名，且未正确初始化二维数组。结合IBlock接口的通用特性，以下是具体修复方案：

关键问题点 #

1. 构造函数签名不匹配：你调用无参的T.Create()，但如果目标类（如TFinestra）的构造函数需要参数（比如Owner），则实际调用的可能是父类的无参构造，而非目标类的自定义构造。
2. 二维数组未初始化：直接对blocks数组赋值会导致内存访问越界，必须先通过SetLength指定数组维度。
3. 未利用接口做通用操作：所有T类都实现了IBlock，可直接通过接口调用通用方法，无需依赖具体类。

修复后的完整代码示例 #

1. 定义IBlock接口（通用操作契约） #

type
  IBlock = interface
    ['{YOUR-GUID-HERE}']
    procedure Initialize; // 示例通用初始化方法
    // 添加其他通用操作方法
  end;

2. 实现具体类（如TFinestra） #

确保构造函数签名与泛型约束一致：

type
  TFinestra = class(TInterfacedObject, IBlock)
  private
    FOwner: someClass;
  public
    constructor Create(const Owner: someClass);
    procedure Initialize;
  end;

constructor TFinestra.Create(const Owner: someClass);
begin
  inherited Create;
  FOwner := Owner;
  // 自定义初始化逻辑
end;

procedure TFinestra.Initialize;
begin
  // 通用初始化逻辑
end;

3. 修正泛型类TMultiBlock #

明确泛型约束的构造函数签名，正确初始化数组并调用目标类构造：

type
  // 约束：T为类、实现IBlock、拥有带Owner参数的构造函数
  TMultiBlock<T: class, IBlock, constructor(const Owner: someClass)> = class(TObject)
  private
    FBlocks: array of array of T;
    function GetBlock(ARow, ACol: Integer): T;
  public
    constructor Create(const Owner: someClass; const n: Integer);
    destructor Destroy; override;
    procedure InitializeAllBlocks; // 通用批量操作
    property Blocks[ARow, ACol: Integer]: T read GetBlock; default;
  end;

constructor TMultiBlock<T>.Create(const Owner: someClass; const n: Integer);
var
  i, j: Integer;
begin
  inherited Create;
  // 初始化n×n的二维数组
  SetLength(FBlocks, n, n);
  for i := 0 to High(FBlocks) do
    for j := 0 to High(FBlocks[i]) do
    begin
      // 调用T类的带参构造函数
      FBlocks[i][j] := T.Create(Owner);
      // 通过IBlock接口执行通用操作
      (FBlocks[i][j] as IBlock).Initialize;
    end;
end;

destructor TMultiBlock<T>.Destroy;
var
  i, j: Integer;
begin
  // 释放所有创建的对象，避免内存泄漏
  for i := 0 to High(FBlocks) do
    for j := 0 to High(FBlocks[i]) do
      FBlocks[i][j].Free;
  inherited;
end;

function TMultiBlock<T>.GetBlock(ARow, ACol: Integer): T;
begin
  Result := FBlocks[ARow][ACol];
end;

procedure TMultiBlock<T>.InitializeAllBlocks;
var
  i, j: Integer;
begin
  for i := 0 to High(FBlocks) do
    for j := 0 to High(FBlocks[i]) do
      (FBlocks[i][j] as IBlock).Initialize;
end;

使用示例 #

var
  TM: TMultiBlock<TFinestra>;
begin
  TM := TMultiBlock<TFinestra>.Create(YourOwnerInstance, 5); // 创建5×5的对象数组
  try
    TM.InitializeAllBlocks; // 执行通用批量操作
    // 访问单个对象：TM[2,3]
  finally
    TM.Free;
  end;
end;

核心说明 #

• 泛型约束精准化：通过constructor(const Owner: someClass)明确要求所有T类必须拥有匹配的构造函数，编译时即可检查兼容性。
• 接口驱动通用操作：所有T类实现IBlock，泛类内部无需关心具体类细节，直接通过接口调用通用方法。
• 内存安全：添加析构函数统一释放对象，避免内存泄漏。

内容的提问来源于stack exchange，提问作者matteofolli