Pemetaan jenis JNA Java, perhatian kepada butiran dan penggunaan

String

Yang pertama ialah pemetaan String dalam JAVA sebenarnya sepadan dengan dua jenis asli: const char* dan const wchar_t*. Secara lalai String akan ditukar kepada char*.

char ialah jenis data ANSI dan wchar_t ialah jenis data aksara Unikod, juga dipanggil aksara lebar.

Jika aksara unikod JAVA hendak ditukar kepada tatasusunan aksara, beberapa operasi pengekodan perlu dilakukan Jika jna.encoding ditetapkan, kaedah pengekodan yang ditetapkan akan digunakan untuk pengekodan. Secara lalai, kaedah pengekodan ialah "UTF8".

Jika ia WString, maka nilai Unicode ​​boleh disalin terus ke WString tanpa sebarang pengekodan.

Mari kita lihat contoh mudah dahulu:

char* returnStringArgument(char *arg) {
  return arg;
}

wchar_t* returnWStringArgument(wchar_t *arg) {
  return arg;
}

Kod asli di atas boleh dipetakan kepada:

String returnStringArgument(String s);
WString returnWStringArgument(WString s);

Mari lihat contoh yang berbeza kaedah asli Takrifannya adalah seperti ini:

int getString(char* buffer, int bufsize);

int getUnicodeString(wchar_t* buffer, int bufsize);

Kami mentakrifkan dua kaedah, parameter kaedah tersebut ialah char* dan wchar_t* masing-masing.

Mari kita lihat cara mentakrifkan pemetaan kaedah dalam JAVA:

// Mapping A:
int getString(byte[] buf, int bufsize);
// Mapping B:
int getUnicodeString(char[] buf, int bufsize);

Berikut ialah penggunaan khusus:

byte[] buf = new byte[256];
int len = getString(buf, buf.length);
String normalCString = Native.toString(buf);
String embeddedNULs = new String(buf, 0, len);

Sesetengah pelajar mungkin bertanya, Sejak Rentetan dalam JAVA boleh ditukar kepada char*, mengapa kita perlu menggunakan tatasusunan bait di sini?

Ini kerana kaedah getString perlu mengubah suai kandungan tatasusunan aksara masuk, tetapi kerana String tidak boleh diubah, String tidak boleh digunakan secara langsung di sini.

Kemudian kami menggunakan Native.toString(byte[]) untuk menukar tatasusunan bait kepada rentetan JAVA.

Lihat nilai pulangan lain:

// Example A: Returns a C string directly
const char* getString();
// Example B: Returns a wide character C string directly
const wchar_t* getString();

Secara amnya, jika kaedah asli mengembalikan rentetan secara langsung, kita boleh menggunakan Rentetan untuk pemetaan:

// Mapping A
String getString();
// Mapping B
WString getString();

Jika asli kod memperuntukkan ruang memori untuk String, maka lebih baik kita menggunakan Penunjuk dalam JNA sebagai nilai pulangan, supaya kita boleh melepaskan ruang yang diduduki pada satu ketika pada masa hadapan, seperti ditunjukkan di bawah:

Pointer getString();

Penimbal , Memori, Tatasusunan dan Penunjuk

Bilakah anda perlu menggunakan Penampan dan Memori?

Secara amnya, jika tatasusunan data asas dihantar sebagai parameter kepada fungsi, anda boleh Dalam JAVA, tatasusunan kelas asas digunakan secara langsung sebaliknya. Tetapi jika kaedah asli masih perlu mengakses tatasusunan selepas kaedah kembali (simpan penuding ke tatasusunan), dalam kes ini adalah tidak sesuai untuk menggunakan tatasusunan kelas asas Dalam kes ini, kita perlu menggunakan ByteBuffers atau ingatan .

Kami tahu bahawa tatasusunan dalam JAVA mempunyai panjang, tetapi untuk kaedah asli, tatasusunan yang dikembalikan sebenarnya adalah penunjuk kepada tatasusunan, dan kami tidak tahu panjang tatasusunan yang dikembalikan, jadi jika kaedah asli Jika penunjuk tatasusunan dikembalikan, adalah tidak sesuai untuk menggunakan tatasusunan untuk pemetaan dalam kod JAVA. Dalam kes ini, anda perlu menggunakan Penunjuk.

Penunjuk mewakili penunjuk. Mari kita lihat contoh Penunjuk terlebih dahulu Pemetaan JAVA. >Lihat tatasusunan rentetan sekali lagi:

void* returnPointerArgument(void *arg) {
  return arg;
}

void* returnPointerArrayElement(void* args[], int which) {
  return args[which];
}

Pemetaan JAVA yang sepadan adalah seperti berikut:

Pointer returnPointerArgument(Pointer p);
Pointer returnPointerArrayElement(Pointer[] args, int which);

Sepadan dengan Penampan, JAVA NIO menyediakan banyak jenis penimbal, seperti ByteBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer dan DoubleBuffer, dsb. Di sini kami mengambil ByteBuffer sebagai contoh untuk melihat penggunaan khusus

public static class TestPointerType extends PointerType {
            public TestPointerType() { }
            public TestPointerType(Pointer p) { super(p); }
        }
TestPointerType returnPointerArrayElement(TestPointerType[] args, int which);

Pertama, lihat kod asli:

char* returnStringArrayElement(char* args[], int which) {
  return args[which];
}
wchar_t* returnWideStringArrayElement(wchar_t* args[], int which) {
  return args[which];
}

Penimbal diisi dengan jelas, penimbal ini perlu digunakan kemudian. Jadi tidak sesuai untuk menggunakan tatasusunan di sini Kita boleh memilih untuk menggunakan ByteBuffer:

String returnStringArrayElement(String[] args, int which);

WString returnWideStringArrayElement(WString[] args, int which);

dan kemudian lihat cara menggunakannya secara khusus:

Parameter pembolehubah<.>

Untuk kedua-dua parameter pembolehubah asli dan JAVA Mari kita ambil contoh Dalam kaedah asli:

int32_t fillInt8Buffer(int8_t *buf, int len, char value) {
  int i;

  for (i=0;i < len;i++) {
    buf[i] = value;
  }
  return len;
}

, kaedah JAVA yang sepadan dipetakan seperti berikut:

int fillInt8Buffer(ByteBuffer buf, int len, byte value);

<.> Kod panggilan yang sepadan adalah seperti berikut:

TestLibrary lib = Native.load("testlib", TestLibrary.class);

        ByteBuffer buf  = ByteBuffer.allocate(1024).order(ByteOrder.nativeOrder());
        final byte MAGIC = (byte)0xED;
        lib.fillInt8Buffer(buf, 1024, MAGIC);
        for (int i=0;i < buf.capacity();i++) {
            assertEquals("Bad value at index " + i, MAGIC, buf.get(i));
        }

Atas ialah kandungan terperinci Pemetaan jenis JNA Java, perhatian kepada butiran dan penggunaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!