JNA：Java等效于C结构，结构包含另一个结构变量

Question

I need help in defining JAVA JNA equivalent of C Structures where each structure contains another structure variable

Code

 typedef struct algorithm_list {

    unsigned char num_of_alg;
    unsigned short *algorithm_guid[];

} algorithm_list_t;

typedef struct key_data {

    unsigned char *key;

    unsigned short key_length;

    algorithm_list_t *algorithms;

} key_data_t;


   typedef struct key_array {

    unsigned char read_byte;

    unsigned char number_of_keys;

    key_data_t *keys[];

} key_array_t;

I am not able to properly define JAVA JNA equivalent of these structure as what I have implemented gives me Invalid Memory access error.

Answer 1

None of these has a struct field. Keeping in mind that [] binds more tightly (higher precedence) than * , you have, respectively, an array of pointer to short, a pointer to struct (or a pointer to a contiguous array of struct , more likely), and an array of pointer to struct .

The easiest mapping for a pointer type is Pointer . Once you get that working, you can refine it to a more specific type.

struct* should use Structure.ByReference as the field type, and an array of those would be Structure.ByReference[] .

As described in the JNA FAQ (omitting getFieldOrder() and constructors for brevity):

public class algorithm_list extends Structure {
    public static class ByReference extends algorithm_list implements Structure.ByReference { }
    public byte num_of_alg;
    public Pointer[] algorithm_guid = new Pointer[1];
    public algorithm_list(Pointer p) {
        super(p);
        int count = (int)readField("num_of_alg") & 0xFF;
        algorithm_guid = new Pointer[count];
        super.read();
}

public class key_data extends Structure {
    public static class ByReference extends key_data implements Structure.ByReference { }
    public Pointer key;
    public short key_length;
    public algorithm_list.ByReference algorithms;
    public key_data(Pointer p) {
        super(p);
        super.read();
        // NOTE: if algorithms points to a contiguous block of struct,
        // you can use "algorithms.toArray(count)" to get that array
    }
}

public class key_array {
    public byte read_byte;
    public byte number_of_keys;
    public key_data.ByReference[] keys = new key_data.ByReference[1];
    public key_array(Pointer p) {
        super(p);
        int count = (int)readField("number_of_keys") & 0xFF;
        keys = new key_data.ByReference[count];
        super.read();
}