static int sizeofints( const int num_of_ints, unsigned int sizes[]) {
    int i, num;
    unsigned int num_of_bytes, num_of_bits, bytes[32], bytecnt, tmp;
    num_of_bytes = 1;
    bytes[0] = 1;
    num_of_bits = 0;
    for (i=0; i < num_of_ints; i++) {    
    tmp = 0;
    for (bytecnt = 0; bytecnt < num_of_bytes; bytecnt++) {
        tmp = bytes[bytecnt] * sizes[i] + tmp;
        bytes[bytecnt] = tmp & 0xff;
        tmp >>= 8;
    }
    while (tmp != 0) {
        bytes[bytecnt++] = tmp & 0xff;
        tmp >>= 8;
    }
    num_of_bytes = bytecnt;
    }
    num = 1;
    num_of_bytes--;
    while (bytes[num_of_bytes] >= num) {
    num_of_bits++;
    num *= 2;
    }
    return num_of_bits + num_of_bytes * 8;

}

    for (bytecnt = 0; bytecnt < num_of_bytes; bytecnt++) {

    for (int bytecnt = 0; bytecnt < num_of_bytes; bytecnt++) {

    for (int bytecnt = 0; bytecnt < num_of_bytes; ++bytecnt) {

    int i, num;
    unsigned int num_of_bytes, num_of_bits, bytes[32], bytecnt, tmp;

function cbsizeofints(num_of_ints: Integer; sizes: array of int64): Integer;
var
  i, num: Integer;
  num_of_bytes, num_of_bits, bytecnt, tmp: int64;
  bytes: array[0..31] of int64;
begin
  num_of_bytes := 1;
  bytes[0] := 1;
  num_of_bits := 0;

  for i := 0 to num_of_ints - 1 do
  begin
    tmp := 0;
    bytecnt:=0;
    while bytecnt<num_of_bytes - 1 do
    begin
      tmp := bytes[bytecnt] * sizes[i] + tmp;
      bytes[bytecnt] := tmp and $ff;
      tmp := tmp shr 8;
      inc(bytecnt);
    end;

    while tmp <> 0 do
    begin
      bytes[bytecnt] := tmp and $ff;
      tmp := tmp shr 8;
      Inc(bytecnt);
    end;

    num_of_bytes := bytecnt;
  end;

  num := 1;
  Dec(num_of_bytes);

  while bytes[num_of_bytes] >= num do
  begin
    Inc(num_of_bits);
    num := num * 2;
  end;

  Result := num_of_bits + num_of_bytes * 8;
end;

    int num_of_bytes = 2, bytecnt = 0;
    while (bytecnt < num_of_bytes)
    {
        // код в цикле
        bytecnt++;
    }

    int num_of_bytes = 2;
    for (int bytecnt = 0; bytecnt < num_of_bytes; bytecnt++)
    {
        // код в цикле
    }

for (инициализация; предусловие; петля)

    int num_of_bytes = 2, bytecnt = 0;
    while(bytecnt < num_of_bytes)
    {
        // код в цикле
        bytecnt++;
    }

    int num_of_bytes = 2, bytecnt = 0;
    for (;bytecnt < num_of_bytes;)
    {
        // код в цикле
        bytecnt++;
    }

function sizeofints(sizes:array of cardinal):integer;
  var j,zn:integer;
  var z:array[32] of byte;
  procedure z_mul(x:cardinal);
  var i:integer; carry:cardinal;
  begin
    i:=0; carry:=0;
    while i<zn or carry<>0 do
      inc(carry,z[i]*x);
      z[i]:=carry; carry:=carry shr 8;
      inc(i);
    end
    zn:=i;
  end
  function bits(x:byte);begin
    result:=0; while x<>0 do begin inc(result); x:=x shr 1; end
  end
begin
    zn:=1; z[0]:=1;
    for j:=0 to length(sizes)-1 do z_mul(sizes[j]);
    result:=(zn-1)*8+bits(z[zn-1]);
end

    for (bytecnt = 0; bytecnt < num_of_bytes; bytecnt++) {
        tmp = bytes[bytecnt] * sizes[i] + tmp;
        bytes[bytecnt] = tmp & 0xff;
        tmp >>= 8;
    }

bytecnt = 0;
while (bytecnt < num_of_bytes) {
  tmp = bytes[bytecnt] * sizes[i] + tmp;
  bytes[bytecnt] = tmp & 0xff;
  tmp >>= 8;

  bytecnt++;
}

Here is the translated code from C++ to Delphi:

```delphi
function sizeofints(const num_of_ints: Integer; sizes: array of Cardinal): Integer;
var
  i, num: Integer;
  num_of_bytes, num_of_bits, bytecnt, tmp: Cardinal;
  bytes: array[0..31] of Byte;
begin
  num_of_bytes := 1;
  bytes[0] := 1;
  num_of_bits := 0;
  for i := 0 to num_of_ints - 1 do
  begin
    tmp := 0;
    for bytecnt := 0 to num_of_bytes - 1 do
    begin
      tmp := bytes[bytecnt] * sizes[i] + tmp;
      bytes[bytecnt] := tmp and $FF;
      tmp := tmp shr 8;
    end;
    while tmp <> 0 do
    begin
      bytes[bytecnt] := tmp and $FF;
      Inc(bytecnt);
      tmp := tmp shr 8;
    end;
    num_of_bytes := bytecnt;
  end;
  num := 1;
  Dec(num_of_bytes);
  while bytes[num_of_bytes] >= num do
  begin
    Inc(num_of_bits);
    num := num * 2;
  end;
  Result := num_of_bits + num_of_bytes * 8;
end;
```

Explanation:
- I changed the `int` and `unsigned int` types to their Delphi equivalents: `Integer` and `Cardinal`.
- I adjusted the array parameter to be a dynamic array in Delphi.
- C++ arrays are 0-indexed as are Delphi arrays, so we didn't need to change the indexing in the translation.
- The `for` loops and `while` loops were adapted to Delphi's syntax.
- Bitwise operations remain the same, but the shift right operator is `shr` in Delphi instead of `>>`.
- The `return` statement has been changed to assigning the `Result` variable, which is how you return values from functions in Delphi.