标签: pointer-arithmetic

这里的任务有问题.我需要创建一个全局的可用内存块和malloc它.由于类型转换和处理错误而无法初始化它.

像C中的数组,其中第一个数组实际上是指向第一个元素的指针,我的内存块需要类似,我可以使用指针算法来定位内存块.

//global variable
static byte *memory = NULL;

void allocator_init(u_int32_t size){

     *memory = (byte*) malloc(size);
}

这些存储器地址的地址/指针将​​通过结构/链接存储为存储器块的标题.

typedef struct _header {
    int signiture;
    int size;
    header* next;
    header* prev;
} header;

我有一个函数,它接受一个结构数组的指针

typedef struct {
    bool isUsed;
    int count;
} MyStructure;

void Process(MyStructure *timeStamps, int arrayLength){
    for (int i = 0; i < arrayLength; i++){
        MyStructure *myStructure = &(*(timeStamps + i));
        if (myStructure->isUsed == true){
          /*do something*/
        }
    }

}

我访问阵列的方式似乎有些偏差.

&(*(timeStamps + i))

有一个更好的方法吗？

我用atoi命令编写了一个非常基本的c代码,然后执行它.

void
main
(void)
{
    int length;

    length = atoi("Content: 111");
    printf("atoi(\"Content: 111\") =  %d\n",length);

    length = atoi("Content:    111" + 10);
    printf("atoi(\"Content:    111\" + 10) = %d\n",length);

    length = atoi("Content: 1" + 6);
    printf("atoi(\"Content: 1\" + 6) = %d\n",length);

    length = atoi("Content: 111" + 12);
    printf("atoi(\"Content: 111\" + 12) = %d\n",length);

    length = atoi("Content-aaaaaa:            111" + 20);
    printf("atoi(\"Content-aaaaaa:            111\" + 20) = %d\n",length);

    printf("\"aaa\"+7 = %s","aaa"+7);
}

输出如下:

atoi("Content: 111") =  0
atoi("Content:    111" + 10) = 111
atoi("Content: 1" …

我在网上用C编写了一个类似形式的机器代码测试器.

测试人员使用指针算法运行机器代码的缓冲区.

#include <stdio.h>
#include <string.h>

unsigned char code[] = \
"machine code to be executed";

void main() {
    int (*ret)() = (int(*)())code;
    ret();
}

任何人都可以解释上面提到的两条线的指针算法背后的逻辑吗？

它似乎std::byte已经成为（在 C++17 中）处理保存对象表示的缓冲区的方式，但目前尚不清楚这种意图是否仍然允许执行指针算术。

标题中的问题是故意措辞应该的，因为我正在寻找推荐。例如，void*可以作为 gcc 扩展用于指针算术，但不是标准的（至少对于 C是这样），因此可能但不是推荐。

我知道的动机std::byte是将字符和数字方面与byte的概念分开。但与此同时，指针算法是否会留下来？

编辑：调整以澄清我希望使用std::byte*不使用std::bytes 中的指针存储的数值进行“指针算术”

我已经读过Rust的指针算术可以通过该pointer.offset()函数完成，但始终必须在中实现unsafe code：

fn main() {
    let buf: [u32; 5] = [1, 2, 3, 4, 5];
    let mut ptr1: *const u32 = buf.as_ptr();
    unsafe {
        let ptr2: *const u32 = buf.as_ptr().offset(buf.len() as isize);
        while ptr1 < ptr2 {
            println!("Address {:?} | Value {}", ptr1, *ptr1);
            ptr1 = ptr1.offset(1);
        }
    }
}

如果我想安全地在Rust中编码，是否应该不使用指针算术而仅使用数组的相应索引进行编码？还是还有其他方法？

你能解释一下输出如何-4吗？我认为++pp;是UB，但不确定。您的解释将真正有助于理解。big-endian 或 little-endian 机器的输出可能有什么不同吗？

#include <stdio.h>

int a[] = { -1, -2, -3, -4 };
int b[] = { 0, 1, 2, 3 };

int main(void)
{
    int *p[] = { a, b };
    int **pp = p;
    printf("a=%p, b=%p, p=%p, pp=%p\n", (void*)a, (void*)b, (void*)p, (void*)pp);
    ++pp;
    printf("p=%p, pp=%p *pp=%p\n", (void*)p, (void*)pp, (void*)*pp);
    ++*pp;
    printf("p=%p, pp=%p *pp=%p\n", (void*)p, (void*)pp, (void*)*pp);
    ++**pp;

    printf("%d\n", (++**pp)[a]);
}

我的输出：

a=0x107121040, b=0x107121050, p=0x7ffee8adfad0, pp=0x7ffee8adfad0
p=0x7ffee8adfad0, pp=0x7ffee8adfad8 *pp=0x107121050
p=0x7ffee8adfad0, pp=0x7ffee8adfad8 *pp=0x107121054
-4 …

我在 32 位机器上运行一个 C 程序gcc 7.5.0。

为什么第二个数字的值比第一个数字大 14？

#include <stdio.h>
int main(void)
{
    int a[5];
    printf("%p\n", &a);
    printf("%p\n", &a+1);
    return 0;
}

结果是：

0x7ffd7293f560
0x7ffd7293f574

为什么第二个数字比第一个数字大 14？

我对二维数组的了解：

1. 在数组中，数组名称是指向第一个元素地址的指针
2. 这里我们可以将 A 视为数组的数组，因此 A 将指向第 0 个一维数组
3. 所以 A+i 会指向 A 的第 i 个元素
4. *(A+i) 将指向 A 的第 i 个元素的第一个元素
5. 那么在 2D 数组中 A+i 地址值应该与 *(A+i) 相同

但这对我来说没有意义 A 值如何与 *A 相同，有人可以告诉我这是如何在内存中工作的，我知道这是正确的，但我无法向自己解释

从 C17 开始，递减指向数组第一个元素的指针是未定义的行为。这个答案引用了C17标准的说法

C17 6.5.6/8

如果指针操作数和结果都指向同一个数组对象的元素，或者超过数组对象的最后一个元素，则求值不会产生溢出；否则，行为是未定义的。

这是最早定义的标准吗？早期标准中如何定义此类操作？以前合法吗？