java - 通过使用正确的数据类型在 Java 中转换 C++ 方法逻辑

Question

我在 C++ 中定义了几个字段，使用这些字段我们正在创建一个新值。我需要按照 C++ 方法在 Java 中做类似的事情。

• “文本”定义为 uint8_t
• “client_id”定义为 uint16_t
• “proc_id”定义为 uint8_t
• “pod_count”定义为 uint32_t

以下是 C++ 方法:

typedef uint64_t    ClientData;

// convert all four fields into one variable "client_data"
void pack(uint8_t text, 
          uint16_t client_id, 
          uint8_t proc_id, 
          uint32_t pod_count,
          ClientData& client_data)
{
    client_data = (uint64_t(text) << 56)
                   + (uint64_t(client_id) << 40)
                   + (uint64_t(proc_id) << 32)
                   + pod_count;
}

// now retrieve individual fields value from converted "client_data" variable
void unpack(ClientData client_data,
            uint8_t& text, 
            uint16_t& client_id, 
            uint8_t& proc_id, 
            uint32_t& pod_count)
{
    pod_count = client_data & 0xffffffff;
    client_data = client_data >> 32;
    proc_id = client_data & 0xff;
    client_data = client_data >> 8;
    client_id = client_data & 0xffff;
    client_data = client_data >> 16;
    text = client_data & 0xff;
}

现在这就是我在 Java 中所做的:

public final class ClientData {
  private final byte text;
  private final short clientId;
  private final byte procId;
  private final int podCount;

  // this is my pack method corresponding to c++ method above
  public long pack() {
    return (((long) text) << 56) | (((long) clientId) << 40) | (((long) procId) << 32)
        | ((long) podCount);
  }  

  // this is my unpack in Java.
  public unpack(long packedValue) {
    this.text = (byte) ((packedValue >>> 56) & ((1 << 8) - 1));
    this.clientId = (short) ((packedValue >>> 40) & ((1 << 16) - 1));
    this.procId = (byte) ((packedValue >>> 32) & ((1 << 8) - 1));
    this.podCount = (int) ((packedValue) & ((1L << 32) - 1));
  }
}

现在我的问题是 - 我在 Java 中的 pack 和 unpack 方法中的逻辑是否按照上面的 C++ 代码是正确的？ C++ 中的 pod_count 定义为 uint32_t 但在我上面的 Java 代码中我将其定义为 int。

Answer 1

默认情况下，Java 有带符号的数字，但您可以将它们用作无符号数字。 Java Primitive data types .

• uint8_t:byte是一个 8 位有符号整数。如果要添加符号位，则必须使用 short。
• uint16_t:short是一个 16 位有符号整数。如果要添加符号位，则必须使用 int .
• uint32_t:int是一个 32 位有符号整数。但是，您可以将其用作无符号整数。为此，您可能想查看 unsigned comparison methods etc.
• uint64_t:long是一个 64 位有符号整数。但是，您可以将其用作无符号整数。

我认为使用带符号或无符号的数据类型与按位运算符一起使用并不重要。您遇到的唯一问题是在打印这些数字或将它们转换为字符串时。为此，您可以使用 toUnsignedInteger Byte的方法|和 Short或 toUnsignedLong的 Integer .

对于逻辑部分: 您可以像在 C++ 中一样实现按位逻辑，但使用类型转换。请引用documentation获取更多信息。

public class ClientData
{
    private int pod_count;
    private byte proc_id;
    private short client_id;
    private byte text;

    public static void main (String[] args)
    {
        new ClientData().unpack(Long.decode("0x32112321321fdffa"));
    }
    void unpack(long client_data)
    {
        this.pod_count = (int)(client_data & 0xffffffff);
        client_data = client_data >> 32;
        this.proc_id = (byte) (client_data & 0xff);
        client_data = client_data >> 8;
        this.client_id = (short) (client_data & 0xffff);
        client_data = client_data >> 16;
        this.text = (byte) (client_data & 0xff);
    }
}