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

Delphi Corner Руди это лучший ресурс, который я знаю о совместимости Delphi и C/C++. Его ловушки преобразования в значительной степени необходимо читать при использовании API C/C++ в Delphi. Глава, которая вас больше всего заинтересует, это записи и выравнивание - > Bitfields, но я призываю вас прочитать все это сверху донизу,два раза. Другие статьи, безусловно, стоит время инвестиций, тоже.

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

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 F;
  end;

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

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

  procedure TBits.SetDbl(const ADpl: Byte);
  begin
    FTypeDblPres := (FTypeDblPres and $F9) + ((ADpl and ) 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 F;
  end;

  procedure TBits.SetLimitHi(const AValue: Byte);
  begin
    FLimitHiSysEa := (FLimitHiSysEa and F) + ((AValue and F) 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;

Ну, вам в основном нужно спуститься к грязному с Бит-манипуляцией.

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

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

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

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

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

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

упакованная запись, предложенная другим здесь, не делает этого и никогда не должна была. Он удалит только заполнение выравнивания, чтобы поместить целые числа на 32-битные границы и аналогичные, но не будет упаковать несколько полей в один байт.

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