C++ 定义具有任意跨度的指针

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

例如，假设我有1000000个整数，每个整数有4个字节

int* p_int = my_int_array;

这给了我*（p_int+1）=我的数组[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是编译时变量。

如果

b

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

int (*big_span_p_int)[b]

每次递增时将移动

b*sizeof（int）

字节

---

在C语言中，您可以使用运行时值代替

b

，但由于您的问题被标记为[C++]，因此这不适用。

使用一些代码。不需要声明额外的指针/数组。在

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            |     .....

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

int* p_int = my_int_array;

    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            |     .....

将内存想象成一个非常大的数组，在这个数组中，您可以通过其内存地址访问位置（在本例中，我们将地址简化为自然数。实际上，它们是十六进制值）。“n”是内存的总量（或大小）。由于内存计数和开始时间为0，因此大小相当于n-1

使用上述示例：

    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            |     .....

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

int* p_int = my_int_array;

    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            |     .....

1。调用时：

    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            |     .....

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

int* p_int = my_int_array;

    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            |     .....

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

my\u int\u 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 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            |     .....

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

int* p_int = my_int_array;

    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            |     .....

记忆又变了。例如，内存地址8（由编译器决定）现在有一个名为*p_int的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。如果您现在在程序中说：

    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            |     .....

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

int* p_int = my_int_array;

    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值。只需将值添加到指针，您将得到下一个整数

，因为

*p\u int=my\u int\u array[0]

，然后

*（p\u int+1）==my\u int\u array[2]

实际上应该是

*（p\u int+1）==my\u int\u array[1]

。这仍然是一个很好的问题，我投了赞成票：）你的问题不清楚，因为如果你有一个

int*

它已经在你每次添加

1

时移动了

4个字节（如果
int
是4个字节宽）。那么，您希望它与当前发生的情况有什么不同？那么，为什么您希望它具有内置的“跨度”？如果要将
int*p
指针移动
b*sizeof（int）
字节，只需执行
p+=b
。创建一个具有内置跨距的指针，当递增1时，该指针会跳转相同的距离，这只是语法上的甜点。诚然，它在通用代码中很有用。。。但是你到底在做什么，阻止你仅仅使用
p+=b
？@AnT我想答案是通用代码，可能涉及到第一句中提到的复杂交错。您不需要一页来说明为什么要回答“使用二进制
运算符+
、一元
运算符*
、
运算符->
等创建一个类”。如果没有人比我更忙的话，这就是我在空闲时打算做的。谢谢，不幸的是，我正在寻找一个基于编译时变量的跨度，而不是常数。我更新了问题以澄清。