Início / coding / Perguntas / 79552245
Accepted
GuidoG
Asked: 2025-04-03 15:17:07 +0800 CST

Como definir um inteiro anulável como nulo?

  • 772

Criei um tipo anulável como este, que encontrei em uma resposta do SO, não lembro qual.

unit NullableType;

interface

uses
  System.SysUtils, System.Rtti;

type
  TNullable<T> = record
 private
    FValue: T;
    FHasValue: IInterface;
    function GetHasValue: Boolean;
    function GetValue: T;
    procedure SetValue(const AValue: T);
  public
    constructor Create(AValue: T);
    function ToString: string; // <-- add this for easier use!
    property HasValue: Boolean read GetHasValue;
    property Value: T read GetValue write SetValue;
  end;


implementation


constructor TNullable<T>.Create(AValue: T);
begin
   SetValue(AValue);
end;

function TNullable<T>.GetHasValue: Boolean;
begin
  Result := FHasValue <> nil;
end;

function TNullable<T>.GetValue: T;
begin
  if HasValue then
    Result := FValue
  else
    Result := Default(T);
end;

procedure TNullable<T>.SetValue(const AValue: T);
begin
  FValue := AValue;
  FHasValue := TInterfacedObject.Create;
end;

function TNullable<T>.ToString: string;
begin
  if HasValue then
  begin
    if TypeInfo(T) = TypeInfo(TDateTime) then
      Result := DateTimeToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TDate) then
      Result := DateToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TTime) then
      Result := TimeToStr(PDateTime(@FValue)^)
    else
      Result := TValue.From<T>(FValue).ToString;
  end
  else
    Result := 'null';
end;

end.

Meu problema é que não sei como defini-lo como nulo.
Por exemplo

var
  id : TNullable<integer>;
begin
  if Edit1.Text <> '' then
    id.Value := StrToInt(Edit1.Text)
  else
    id.Value := null;  // runtime error

isso me dá erro de tempo de execução

Não foi possível converter a variante do tipo (Null) em tipo (Integer)

Já faz um tempo que programo em Delphi e não consigo descobrir como definir o valor da idvariável paranull

id.Value := nil;

dá erro de compilador

Tipos incompatíveis: 'integer' e 'pointer'

Somente não definindo o valor de ideu consigo ter seu valor null, mas e se eu quiser defini-lo para qualquer valor, incluindo null? Como fazer isso?

delphi

2 respostas

  1. nullé um const Variantdo tipo VT_NULL, é por isso que você está recebendo um erro de tempo de execução relacionado a uma Variantconversão. Você quer nilem vez disso.

    No entanto, você não pode atribuir a nilpara a Tquando Tnão for um tipo de ponteiro. Então, para fazer o que você quer, você precisa atualizar Nullable<T>para aceitar T^ponteiros como entrada.

    Do Delphi 2006 em diante, um recordpode sobrecarregar operadores , então você não precisa aceitar atribuições por meio de uma Valuepropriedade. Você pode sobrecarregar operadores de conversão que permitirão que você converta Tvalores e T^ponteiros em Nullable<T>(e converta Nullable<T>em Tvalores), então você poderá atribuir nilponteiros para suas Nullablevariáveis, por exemplo:

    unit NullableType;

interface

type
  TNullable<T> = record
  public
    type PointerOfT = ^T; // <-- add this
  private
    FValue: T;
    FHasValue: IInterface;

    function GetHasValue: Boolean;

    procedure SetValue(const AValue: T);
    procedure SetValueByPointer(const AValue: PointerOfT);
    procedure SetToNil;
  public
    constructor Create(const AValue: T); overload;
    constructor Create(const AValue: PointerOfT); overload; // <-- add this

    // add these...
    class operator Implicit(const Src: TNullable<T>): T;
    class operator Implicit(const Src: T): TNullable<T>;
    class operator Implicit(const Src: PointerOfT): TNullable<T>;

    class operator Explicit(const Src: TNullable<T>): T;
    class operator Explicit(const Src: T): TNullable<T>;
    class operator Explicit(const Src: PointerOfT): TNullable<T>;
    //

    property HasValue: Boolean read GetHasValue;
    property Value: T read FValue write SetValue; // <-- optional now!

    function ToString: string;
  end;

implementation

uses
  System.SysUtils, System.Rtti;

constructor TNullable<T>.Create(const AValue: T);
begin
  SetValue(AValue);
end;

constructor TNullable<T>.Create(const AValue: PointerOfT);
begin
  SetValueByPointer(AValue);
end;

class operator TNullable<T>.Implicit(const Src: TNullable<T>): T;
begin
  Result := Src.FValue;
end;

class operator TNullable<T>.Implicit(const Src: T): TNullable<T>;
begin
  Result.SetValue(Src);
end;

class operator TNullable<T>.Implicit(const Src: PointerOfT): TNullable<T>;
begin
  Result.SetValueByPointer(Src);
end;

class operator TNullable<T>.Explicit(const Src: TNullable<T>): T;
begin
  Result := Src.FValue;
end;

class operator TNullable<T>.Explicit(const Src: T): TNullable<T>;
begin
  Result.SetValue(Src);
end;

class operator TNullable<T>.Explicit(const Src: PointerOfT): TNullable<T>;
begin
  Result.SetValueByPointer(Src);
end;

procedure TNullable<T>.SetValue(const AValue: T);
begin
  FValue := AValue;
  FHasValue := TInterfacedObject.Create;
end;

procedure TNullable<T>.SetValueByPointer(const AValue: PointerOfT);
begin
  if AValue <> nil then
    SetValue(AValue^)
  else
    SetToNil;
end;

procedure TNullable<T>.SetToNil;
begin
  FValue := Default(T);
  FHasValue := nil;
end;

function TNullable<T>.ToString: string;
begin
  if HasValue then
  begin
    if TypeInfo(T) = TypeInfo(TDateTime) then
      Result := DateTimeToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TDate) then
      Result := DateToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TTime) then
      Result := TimeToStr(PDateTime(@FValue)^)
    else
      Result := TValue.From<T>(FValue).ToString;
  end
  else
    Result := 'null';
end;

end.

    var
  id : TNullable<integer>;
begin
  if Edit1.Text <> '' then
    id := StrToInt(Edit1.Text)
  else
    id := nil;

    Além disso, a partir do Delphi 10.4, você pode usar um Custom Managed Record para substituir o IInterfacepor um simples Boolean, por exemplo:

    • O uso de IInterfaceé baseado em um antigo artigo de blog escrito por Allen Bauer que antecede a introdução dos CMRs. Ele até afirma no artigo que os CMRs teriam resolvido o problema que ele estava usando IInterfacecomo solução alternativa!
    unit NullableType;

interface

type
  TNullable<T> = record
  public
    type PointerOfT = ^T;
  private
    FValue: T;
    FHasValue: Boolean; // <-- change this

    procedure SetValue(const AValue: T);
    procedure SetValueByPointer(const AValue: PointerOfT);
    procedure SetToNil;
  public
    constructor Create(const AValue: T); overload;
    constructor Create(const AValue: PointerOfT); overload;

    class operator Initialize(out Dest: TNullable<T>); // <-- add this

    class operator Implicit(const Src: TNullable<T>): T;
    class operator Implicit(const Src: T): TNullable<T>;
    class operator Implicit(const Src: PointerOfT): TNullable<T>;
    class operator Explicit(const Src: TNullable<T>): T;
    class operator Explicit(const Src: T): TNullable<T>;
    class operator Explicit(const Src: PointerOfT): TNullable<T>;

    property HasValue: Boolean read FHasValue;
    property Value: T read FValue write SetValue;

    function ToString: string;
  end;

implementation

uses
  System.SysUtils, System.Rtti;

constructor TNullable<T>.Create(const AValue: T);
begin
  SetValue(AValue);
end;

constructor TNullable<T>.Create(const AValue: PointerOfT);
begin
  SetValueByPointer(AValue);
end;

class operator TNullable<T>.Initialize(out Dest: TNullable<T>);
begin
  Dest.SetToNil;
end;

class operator TNullable<T>.Implicit(const Src: TNullable<T>): T;
begin
  Result := Src.FValue;
end;

class operator TNullable<T>.Implicit(const Src: T): TNullable<T>;
begin
  Result.SetValue(Src);
end;

class operator TNullable<T>.Implicit(const Src: PointerOfT): TNullable<T>;
begin
  Result.SetValueByPointer(Src);
end;

class operator TNullable<T>.Explicit(const Src: TNullable<T>): T;
begin
  Result := Src.FValue;
end;

class operator TNullable<T>.Explicit(const Src: T): TNullable<T>;
begin
  Result.SetValue(Src);
end;

class operator TNullable<T>.Explicit(const Src: PointerOfT): TNullable<T>;
begin
  Result.SetValueByPointer(Src);
end;

procedure TNullable<T>.SetValue(const AValue: T);
begin
  FValue := AValue;
  FHasValue := True;
end;

procedure TNullable<T>.SetValueByPointer(const AValue: PointerOfT);
begin
  if AValue <> nil then
    SetValue(AValue^)
  else
    SetToNil;
end;

procedure TNullable<T>.SetToNil;
begin
  FValue := Default(T);
  FHasValue := False;
end;

function TNullable<T>.ToString: string;
begin
  if HasValue then
  begin
    if TypeInfo(T) = TypeInfo(TDateTime) then
      Result := DateTimeToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TDate) then
      Result := DateToStr(PDateTime(@FValue)^)
    else if TypeInfo(T) = TypeInfo(TTime) then
      Result := TimeToStr(PDateTime(@FValue)^)
    else
      Result := TValue.From<T>(FValue).ToString;
  end
  else
    Result := '(null)';
end;

end.

    Se você precisar dar suporte a versões mais antigas do Delphi, basta IFDEFcodificar adequadamente.

    • 3
  2. Best Answer

    Já que você usa uma interface para detectar se tem um valor ou não, eu faria isso:

    PROCEDURE TNullable<T>.SetNull;
  BEGIN
    FHasValue:=NIL
  END;

FUNCTION TNullable<T>.IsNull : BOOLEAN;
  BEGIN
    Result:=NOT Assigned(FHasValue)
  END;

    Você não pode fazer isso por atribuição (ou talvez você possa - declarar um operador de atribuição que aceite um valor de ponteiro, mas permita apenas NILcomo valor, e então chamar SetNull. Se você tentar atribuir um não NILponteiro, gere uma exceção).

    • 1

relate perguntas