Question

如果我有一个大数组，其中数据流以某种复杂的方式交错，我可以定义指针p，使得p + 1是某个任意偏移量b字节。

例如，假设我有1,000,000个整数，每个4个字节。

int* p_int = my_int_array;

这给了我*（p_int + 1）== my_int_array [1]（移动4个字节）

我正在寻找像

这样的东西

something_here(b)* big_span_p_int = my_int_array;

会使*（big_span_p_int + 1）== my_int_array [b]（移动4 * b或b字节，无论哪个可能或更容易）

这可能吗？易？

感谢您的帮助。

编辑：

b是编译时变量。

Answer 1

使用您的一些代码。无需声明其他指针/数组。在p_int上应用指针算术就足以遍历并达到您正在寻找的数字值。

让我们看一下这个例子：

    int main() {
        int my_int_array[5] {1,2,3,4,5};
        int* p_int = my_int_array;
        int b = 2;
        std::cout << *(p_int + b) << std::endl; // Output is 3, because  *p_int == my_int_array[0], so my_int_array[2] will give you the third index of the array.
    }

以图形方式表示：

Memory Address | Stored Value (values or memory addresses)
----------------------------------------------
0              |     .....
1              |     .....
2              |     .....
3              |     .....
4              |     .....
5              |     .....
6              |     .....
7              |     .....
8              |     .....
.              |     .....
.              |     .....
.              |     .....
n-1            |     .....

想象一下，内存是一个非常大的数组，您可以通过其内存地址访问位置（在这种情况下，我们将地址简化为自然数。实际上它们是十六进制值）。＆＃34; N＆＃34;是内存的总量（或大小）。由于存储器计数并从0开始，因此大小相当于n-1。

使用上面的示例：

<强> 1。当您调用时：

int my_int_array[5] {1,2,3,4,5};

操作系统和C ++编译器为您静态分配整数数组内存，但我们可以认为我们的内存已被更改。例如。内存地址2（由编译器决定）现在具有我们的第一个值my_int_array。

Memory Address | Name - Stored Value (values or memory addresses)
-----------------------------------------------------
0              |     .....
1              |     .....
2              |     my_int_array[0] = 1
3              |     my_int_array[1] = 2
4              |     my_int_array[2] = 3
5              |     my_int_array[3] = 4
6              |     my_int_array[4] = 5
7              |     .....
8              |     .....
.              |     .....
.              |     .....
.              |     .....
n-1            |     .....

<强> 2。现在，如果我们说：

int* p_int = my_int_array;

记忆再次改变。例如。内存地址8（由编译器决定）现在有一个名为* p_int的指针。

Memory Address | Name - Stored Value (values or memory addresses)
-----------------------------------------------------
0              |     .....
1              |     .....
2              |     my_int_array[0] = 1
3              |     my_int_array[1] = 2
4              |     my_int_array[2] = 3
5              |     my_int_array[3] = 4
6              |     my_int_array[4] = 5
7              |     .....
8              |     p_int = 2 (which means it points to memory address 2, which has the value of my_int_array[0] = 1)
.              |     .....
.              |     .....
.              |     .....
n-1            |     .....

第3。如果在您的计划中，您现在说：

    p_int += 2; // You increase the value by 2 (or 8 bytes), it now points elsewhere, 2 index values ahead in the array.

    Memory Address | Name - Stored Value (values or memory addresses)
    -----------------------------------------------------
    0              |     .....
    1              |     .....
    2              |     my_int_array[0] = 1
    3              |     my_int_array[1] = 2
    4              |     my_int_array[2] = 3
    5              |     my_int_array[3] = 4
    6              |     my_int_array[4] = 5
    7              |     .....
    8              |     p_int = 4 (which means it points to memory address 4, which has the value of my_int_array[2] = 3)
    .              |     .....
    .              |     .....
    .              |     .....
    n-1            |     .....

在这样的简单情况下执行内存分配和指针算术时，您不必担心以字节为单位的大小一个int（4个字节）。当你声明它们时，这里的指针已经绑定到一个类型（在这种情况下是 int ），所以只需将它们的值增加整数值p_int + 1，这将制造点p_int指向接下来的4个字节或int值。只需将值添加到指针，您将获得下一个整数。

Answer 2

如果b是常量表达式（编译时常量），则指针声明为

int (*big_span_p_int)[b]

每次递增时，

将移动b * sizeof(int)个字节。

在C中，您可以使用运行时值代替b，但由于您的问题已标记为[C ++]，因此不适用。

定义具有任意跨度的指针

2 个答案: