What is the best way to convert Bytes to Cardinal and vice versa

Question

I have The following code for now.

type
  TByte4 = array[0..3] of Byte; // 32-bit

function CardinalToBytes(const Data: Cardinal): TByte4;
begin
  Result[0] := (Data shr 24) and 255;
  Result[1] := (Data shr 16) and 255;
  Result[2] := (Data shr 8) and 255;
  Result[3] := Data and 255;
end;

function BytesToCardinal(const Data: TByte4): Cardinal;
begin
  Result := (Data[0] * 16777216) +
            (Data[1] * 65536) +
            (Data[2] * 256) +
             Data[3];
end;

I am wondering if this is the fastest and most efficient way (I am sure it is not :) ). The catch is this has to work in compact framework under Delphi 2006 (don't even ask). I am using it in a TEA encryption algorithm that works with Ansi and Unicode versions of Delphi and also with .NET and .NET compact framework in Delphi 2006.

So no "Move" and similar functions that work with pointers are allowed (no i do not want unsafe code).

Edit:

I still haven't found a better way to do this. Some great suggestion were given, but they all fail in .NET. I am afraid I will not spend any more time on a dead road. VCL .NET is dead, so is CF in delphi I am afraid. So this will have to do for maintaining this project. I will stil wait for while if somebody proves me wrong and gets the code to compile in .NET

Edit2:

The solution was simple as it is in most cases. Somebody just had to look for the obvious solution. I just didn't know anymore that there is a BitConverter class in .NET

Answer 1

resp.

result:=TByte4(Data);

and result:=cardinal(data)

This is not the same endianwise though (you are more or less implementing a host to little endian function and back above).

Alternately, there is the union trick:

  type 
   TSomeRecord = packed record
                case boolean of 
                    true : (data4:TByte4);
                    false :(dateabyte:cardinal);
                 end;

But I assume .NET will barf on that too.

Answer 2

You didn't say no mnemonic, so...

type
  TByte4 = packed array[0..3] of Byte; // 32-bit

function CardinalToBytes(const Data: Cardinal): TByte4;
asm
  bswap  eax
end;

function BytesToCardinal(const Data: TByte4): Cardinal;
asm
  bswap  eax
end;

Answer 3

OK this is little bit faster...

And don't forget to switch off range checking!

function CardinalToBytes(const Data: Cardinal): TByte4;
begin
  Result[0] := Data shr 24;
  Result[1] := Data shr 16;
  Result[2] := Data shr 8;
  Result[3] := Data;
end;

Answer 4

One way would be to use a case record:

type
  TTestRecord = record
    case Cardinal of
      0: (Card: Cardinal);
      1: (Arr: array[0..3] of Byte);
  end;

var
  TR: TTestRecord;
begin

  TR.Arr[0] := 0;
  TR.Arr[1] := 1;
  TR.Arr[2] := 2;
  TR.Arr[3] := 3;
  TR.Card := 0;

Answer 5

In Delphi.NET, use the BitConverter class from the .NET framework to do the conversion. See BitConverter Class (System).

For an example:

function CardinalToBytes(const Data: Cardinal): TBytes;
begin
  Result := BitConverter.ToBytes(Data);
end;

function BytesToCardinal(const Data: TBytes): Cardinal;
begin
  Result := BitConverter.ToUInt32(Data, 0);
end;