Как имитировать битовые поля в записях Delphi?

Ответ 1

Спасибо всем!

Основываясь на этой информации, я уменьшил ее до:

RBits = record
public
  BaseMid: BYTE;
private
  Flags: WORD;
  function GetBits(const aIndex: Integer): Integer;
  procedure SetBits(const aIndex: Integer; const aValue: Integer);
public
  BaseHi: BYTE;
  property _Type: Integer index $0005 read GetBits write SetBits; // 5 bits at offset 0
  property Dpl: Integer index $0502 read GetBits write SetBits; // 2 bits at offset 5
  property Pres: Integer index $0701 read GetBits write SetBits; // 1 bit at offset 7
  property LimitHi: Integer index $0804 read GetBits write SetBits; // 4 bits at offset 8
  property Sys: Integer index $0C01 read GetBits write SetBits; // 1 bit at offset 12
  property Reserved_0: Integer index $0D01 read GetBits write SetBits; // 1 bit at offset 13
  property Default_Big: Integer index $0E01 read GetBits write SetBits; // 1 bit at offset 14
  property Granularity: Integer index $0F01 read GetBits write SetBits; // 1 bit at offset 15
end;

Индекс кодируется следующим образом: (BitOffset shl 8) + NrBits. Где 1 <= NrBits <= 32 и 0 <= битОффсет <= 31

Теперь я могу получить и установить эти биты следующим образом:

{$OPTIMIZATION ON}
{$OVERFLOWCHECKS OFF}
function RBits.GetBits(const aIndex: Integer): Integer;
var
  Offset: Integer;
  NrBits: Integer;
  Mask: Integer;
begin
  NrBits := aIndex and $FF;
  Offset := aIndex shr 8;

  Mask := ((1 shl NrBits) - 1);

  Result := (Flags shr Offset) and Mask;
end;

procedure RBits.SetBits(const aIndex: Integer; const aValue: Integer);
var
  Offset: Integer;
  NrBits: Integer;
  Mask: Integer;
begin
  NrBits := aIndex and $FF;
  Offset := aIndex shr 8;

  Mask := ((1 shl NrBits) - 1);
  Assert(aValue <= Mask);

  Flags := (Flags and (not (Mask shl Offset))) or (aValue shl Offset);
end;

Довольно изящный, ты не думаешь?!?!

PS: Руди Велтиус теперь включил пересмотренную версию этого в своем превосходном "Ловушки конвертирования" -архикла.

Ответ 2

Rudy Delphi Corner - лучший ресурс, который я знаю о взаимодействии Delphi и C/С++. Его Ловушки конверсии в значительной степени должны быть прочитаны при использовании API C/С++ в Delphi. Раздел, который вам больше всего интересен, - Записи и выравнивание → Битфилды, но я призываю вас прочитать всю вещь сверху вниз, дважды. Другие статьи, безусловно, тоже стоят времени на инвестиции.

Ответ 3

Хорошо, мои манипуляции с битами немного ржавые, поэтому я мог бы изменить байты. Но приведенный ниже код дает общую идею:

type
  TBits = record
  private
    FBaseMid     : Byte;
    FTypeDplPres :  Byte;
    FLimitHiSysEa: Byte;
    FBaseHi      : Byte;

    function GetType: Byte;
    procedure SetType(const AType: Byte);
    function GetDpl: Byte;
    procedure SetDbl(const ADpl: Byte);
    function GetBit1(const AIndex: Integer): Boolean;
    procedure SetBit1(const AIndex: Integer; const AValue: Boolean);
    function GetLimitHi: Byte;
    procedure SetLimitHi(const AValue: Byte);
    function GetBit2(const AIndex: Integer): Boolean;
    procedure SetBit2(const AIndex: Integer; const AValue: Boolean);

  public
    property BaseMid: Byte read FBaseMid write FBaseMid;
    property &Type: Byte read GetType write SetType; // 0..31
    property Dpl: Byte read GetDpl write SetDbl; // 0..3
    property Pres: Boolean index 128 read GetBit1 write SetBit1; 
    property LimitHi: Byte read GetLimitHi write SetLimitHi; // 0..15

    property Sys: Boolean index 16 read GetBit2 write SetBit2; 
    property Reserved0: Boolean index 32 read GetBit2 write SetBit2; 
    property DefaultBig: Boolean index 64 read GetBit2 write SetBit2; 
    property Granularity: Boolean index 128 read GetBit2 write SetBit2; 
    property BaseHi: Byte read FBaseHi write FBaseHi;
  end;

  function TBits.GetType: Byte;
  begin
    Result := (FTypeDplPres shr 3) and $1F;
  end;

  procedure TBits.SetType(const AType: Byte);
  begin
    FTypeDplPres := (FTypeDplPres and $07) + ((AType and $1F) shr 3);
  end;

  function TBits.GetDpl: Byte;
  begin
    Result := (FTypeDplPres and $06) shr 1;
  end;

  procedure TBits.SetDbl(const ADpl: Byte);
  begin
    FTypeDblPres := (FTypeDblPres and $F9) + ((ADpl and $3) shl 1);
  end;

  function TBits.GetBit1(const AIndex: Integer): Boolean;
  begin
    Result := FTypeDplPres and AIndex = AIndex;
  end;

  procedure TBits.SetBit1(const AIndex: Integer; const AValue: Boolean);
  begin
    if AValue then
      FTypeDblPres := FTypeDblPres or AIndex
    else
      FTypeDblPres := FTypeDblPres and not AIndex;
  end;

  function TBits.GetLimitHi: Byte;
  begin
    Result := (FLimitHiSysEa shr 4) and $0F;
  end;

  procedure TBits.SetLimitHi(const AValue: Byte);
  begin
    FLimitHiSysEa := (FLimitHiSysEa and $0F) + ((AValue and $0F) shr 4);
  end;

  function TBits.GetBit2(const AIndex: Integer): Boolean;
  begin
    Result := FLimitHiSysEa and AIndex = AIndex;
  end;

  procedure TBits.SetBit2(const AIndex: Integer; const AValue: Boolean);
  begin
    if AValue then
      FLimitHiSysEa := FLimitHiSysEa or AIndex
    else
      FLimitHiSysEa := FLimitHiSysEa and not AIndex;
  end;

Ответ 4

Ну, вам в основном нужно спуститься к грязным с манипуляциями с битами.

Почему, в частности, вам нужно сохранить эту структуру?

Если вам нужно только поговорить с унаследованной программой, которая либо говорит на этом диалекте (TCP/IP, либо аналогично), либо хранит данные таким образом (файлы и т.д.), тогда я бы сопоставил нормальную структуру Delphi с бит-версия. Другими словами, я бы использовал обычно структурированную структуру Delphi в памяти и написал код для записи и чтения этой структуры в совместимом виде.

Если вам нужно сохранить память, я бы сделал геттеры и сеттеры, которые управляют битами внутренних целых чисел или схожими. Это будет иметь влияние на производительность, но не намного больше, чем у исходной программы на C, единственное различие заключается в том, что бит-манипуляция будет добавлена ​​магией компилятора в версии C, тогда как вам придется писать ее самостоятельно.

Если у вас не так много записей в памяти, и вам не нужно разговаривать с другой программой, я бы использовал естественную структуру Delphi. Компромисс для более высокой производительности будет использовать больше памяти.

Но все зависит от ваших критериев.

В любом случае вы не сможете поговорить с компилятором Delphi для выполнения того же задания для вас, что и компилятор C.

УПАКОВАННЫЙ ЗАПИСЬ, предложенный другим здесь, не делает этого и никогда не предназначался. Он удалит только выравнивание, чтобы поместить целые числа на 32-битные границы и аналогичные, но не будет упаковывать несколько полей в один байт.

Обратите внимание, что общий способ сделать это через Delphi SETS, которые реализуют внутреннее использование битовых полей. Опять же, у вас будет другой код, чем вариант C.