动态数组（结构数组）

Question

我有一个名为person的结构，如下所示：

struct person {
    int height, weight;
};

我还创建了一个person数组，如下所示：

^{pr2}$

我对person的数组执行以下操作：

struct Array_2d_ofperson{
    int len;   //indicates the length of this array(its supposed to be dynamic)
    Arrayofperson *subarray; //this is supposed to be the dynamic 2d array of person.
};   

这是我的代码：

#include <iostream>
#include "test.h"
using namespace std;

#define DLLEXPORT extern "C" __declspec(dllexport)

DLLEXPORT Arrayofperson create_arr_person(int len) {
    Arrayofperson arr_p;
    arr_p.len = len;
    arr_p.p = new person[len];
    //populate the array here:
    for (int a = 0; a < len; a++) {
        arr_p.p[a].height = a; //yes they're the same, but it doesn't matter for now.
        arr_p.p[a].weight = a; 
    };
    return arr_p;
}

DLLEXPORT void print_arr_person(Arrayofperson pp) {
    printf("length: %d\n", pp.len);
    for (int b = 0; b < pp.len; b++) {
        printf("height, weight %d, %d\n", pp.p[b].height, pp.p[b].weight);
    }; 
}

DLLEXPORT Array_2d_ofperson create_2darr_person(int len, int sublen) {
    Array_2d_ofperson arr_2d_person;
    arr_2d_person.len = len;
    arr_2d_person.subarray = new Arrayofperson[len];

    for (int a = 0; a < len; a++) {
        arr_2d_person.subarray[a].len = sublen;
        arr_2d_person.subarray[a].p = new person[sublen];
        for (int b = 0; b < sublen; b++) {          
            arr_2d_person.subarray[a].p[b].height = b;
            arr_2d_person.subarray[a].p[b].weight = b;
        }
    };

    for (int a = 0; a < len; a++) {
        for (int b = 0; b < sublen; b++) {  
            printf("(a, b): %d, %d", arr_2d_person.subarray[a].p[b].height, arr_2d_person.subarray[a].p[b].weight);
            printf("\n");
        }
    };
    return arr_2d_person;
    cin.get();
}

DLLEXPORT void print_2darr_person(Array_2d_ofperson pp) {
    int len = pp.len;
    int sublen = pp.subarray[0].len; //yes I haven't forgotten that it can change between different subarrays.

    for (int a = 0; a < len; a++) {
        for (int b = 0; b < sublen; b++) {  
            printf("(a, b): %d, %d", pp.subarray[a].p[b].height, pp.subarray[a].p[b].weight);
            printf("\n");
        }
    }; 
}

我打算从上面的代码中创建一个dll（这里的原因不重要）（后面会有更多的代码），并在python中使用它。我的问题是：

1）当我在python端执行此操作时：

from ctypes import *

test = CDLL('test.dll') //the dll from the code above, yes it works.

arr = test.create_arr_person(6)

test.print_arr_person(arr)

arr2 = test.create_2darr_person(2, 3)

#test.print_2darr_person(arr2)

raw_input('h')

当我试图打印2d数组时，我会因为打印person数组而收到垃圾，并从windows收到访问冲突错误。在

以下是我的问题，按重要性排序（我不想在dll中使用pythonapi，因为dll也可以被其他语言使用）

1）如何使专用于array/2darray的内存保留在内存中，这样就不会出现访问冲突错误。我试过做静态的Arrayofperson，但没用。在

2）怎样才能更容易地访问2d数组的子数组中的person，而不是这样做呢。 pp.subarray[a].p[b]。（我想这样做：pp[a][b]，其中pp是2darray of person）。我相信这与重载[ ]运算符有关，但我不熟悉生成类（这就是我现在创建结构的原因）。在

3）如何使用相同的方法访问python中的array/2darray（我想在python中这样做：

test = CDLL('test.dll')
array_of_person = test.create_arr_person(5)
print (array_of_person[0]) #something like this

Answer 1

可以使用这样一个事实：向量被保证是一个连续的内存块，并返回指向第一个元素的指针。在

T * p = &v[0]

然后可以将此指针作为普通数组访问，并且跨模块边界是安全的。 同样的技术也适用于std:：strings，这些字符串可以通过一个原始的存储指针进行访问。在

^{pr2}$

您只需确保保存存储的对象不会在操作之前意外超出范围。在

多维数组总是可以投影到一维上。在

1 1 1

2 2 2

3 3 3

可存储为：

1 1 1 2 2 2 3 3 3