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

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

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

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;

Ну, в основном необходимо перейти к грязному с побитовой обработкой.

Да ведь а именно, необходимо ли сохранить ту структуру?

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

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

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

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

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

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

Примечание, что распространенный способ сделать это через SETS Дельфи, которые реализуют внутренне битовые поля использования. Снова, у Вас будет различный код, чем вариант C.