Указатель на массив указателей на структуры

struct {
char str[n]
int x
float a
}

mov [eax+edx*4+00320], ecx

Ваш вопрос на самом деле полон наземных мин, что продемонстрирует, почему точность сборки очень важна, к несчастью.

Итак, что у меня есть …

Вы показываете синтаксически неправильную анонимную структуру, и вдруг у вас есть какой-то указатель? Это не работает так. У вас анонимная структура и пара синтаксических ошибок, не более того.

Теперь здесь я действительно чувствую себя хорошо, чтобы остановиться на ответе, потому что остальная часть вашего вопроса не имеет смысла без фактического определения данных. Но допустим, вы имели в виду что-то вроде этого:

struct STRUCT_A {
char     str[17];
int      x;
float    a;
};

STRUCT_A testA[3]{
{"a1", 1111, 1.111},
{"a2", 2222, 2.222},
{"a3", 3333, 3.333}
};

int foo(unsigned index) {
return testA[index].x;
}

Итак, что у меня здесь есть массив testA, Массив — это не просто указатель, он немного больше в C ++ во время компиляции, хотя он с радостью «затухает» в указателе при использовании как таковой, он не совсем тот же.

Когда я буду использовать testA как указатель, он не указывает на дальнейшие указатели, он указывает непосредственно на данные.

Таким образом, у вас есть не один уровень, а два уровня дополнительной косвенности в ОП. Читать x для первого элемента вы просто делаете mov eax,[testA + 20], Указатель не загружен (пример от цели x86 32b, на других целях +20 может отличаться).

Были бы вы:

STRUCT_A* testA_alias = testA;
// now this ^^ alias is no more array, it's just pointer
// (array silently decays into pointer during compilation, when asked to)
STRUCT_A** testA_indirect = &testA_alias;

Тогда, чтобы получить x второго элемента:

mov  eax,[testA_indirect]   ; eax = &testA_alias
mov  eax,[eax]              ; eax = testA (or &testA .. not sure how to write it, "address of data")
mov  eax,[eax + 28*1 + 20]  ; eax = testA[1].x

Мне удалось создать два уровня косвенности (на самом деле мне пришлось редактировать ответ в этой части, так как я неправильно читал сборку из C ++, неполный синтаксис Intel меня смутил).

Тем не менее я не уверен, где вы берете все эти указатели и почему? Это не Java, это C ++, вы просто храните свои данные в памяти напрямую. Как видите, мне пришлось приложить немало усилий, чтобы получить два уровня косвенности.

Теперь вы можете спросить, почему x я сидела +20 и не в +17, Поскольку заполнение, C ++ будет выравнивать элементы структуры в соответствии с их типом, int любит быть выровненным, так оно и есть.

Это также должно объяснить 28, который является размером этой структуры.

Также в вашем вопросе у вас есть:

step2result + п + 1

Где это сделал +1 родом из? Может быть, вы смущены этим:

char str[]{"abc"};              // str[4]

Но это потому, что "abc" как db 'a', 'b', 'c', 0 = четыре байта определены. Когда вы определяете его только как a, b, c как три байта, массив будет 3 байта:

char str2[]{'a', 'b', 'c'};     // str2[3]

Как вы определяете, что char массив по [n], +1 не участвует, этот массив имеет точно n символы. Если вы поместите в него литералы C-строки, они могут быть длиной не более (n-1) символов, потому что n-й байт будет занят нулевым ограничителем.

---

Вы можете проверить, как этот источник выглядит после компиляции Вот.

Который, вероятно, ответит на ваш вопрос наилучшим образом.

Вы можете обратить особое внимание на определение содержимого памяти, я добавил некоторые комментарии к начальным строкам testA определение массива:

testA:
.string "a1"       ; three bytes 'a', '1', 0 defined
.zero   14         ; remaining 14 zeroed to have char[17]
.zero   3          ; padding for "int x".long   1111       ; int x
.long   1066284351 ; float a
.string "a2"       ; char[17] of second element
...

//This answer is architecture and compiler dependent
//My settings are TDM GCC 4.9.2 64bit and Windows 10
const int n = 5;

#pragma pack(push, 1)
struct A{
char str[n];
int x;
float a;
};
#pragma pack(pop)

struct B{
char str[n];
int x;
float a;
};

int main(){

printf("Size of A is %d\n", sizeof(A));
printf("Size of B is %d\n", sizeof(B));
B k;

for(int i=0; i<n; i++)
printf("Address of str[%d] in k is %x\n",i, &(k.str[0]));

printf("Address of int x in k is %x\n", &(k.x));
printf("Address of float a in k is %x\n", &(k.a));

}
/*
Result -

Size of A is 13
Size of B is 16
Address of str[0] in k is 9ffe30 Address of array
Address of str[1] in k is 9ffe30 Address of str[1] in k is 9ffe31
Address of str[2] in k is 9ffe30 Address of str[2] in k is 9ffe32
Address of str[3] in k is 9ffe30 And so on..
Address of str[4] in k is 9ffe30
Address of int x in k is 9ffe38 Address of Array + 8Bytes
Address of float a in k is 9ffe3c //Address of Array + 2*8Bytes

n -- padding
4k+1 -- 3
4k+2 -- 2
4k+3 -- 1
4k -- 0 */