是否可以取消引用指向结构的指针？

Question

我有一个指向结构的二维数组。 我正在尝试将结构复制到其他数组元素指向的点。 对我来说，最简单的方法就是使用解引用运算符分配每个值。 我不想做array[0][1] = array[1][0]; 因为那会分配结构的地址。 所以我想知道我是否可以做到

*array[0][1] = *array[1][0];

作为复制结构的更快方法？

Answer 1

要复制struct ，一个简单的赋值就可以了。 memcpy()不是必需的 - 也不是首选的函数调用。

struct {
  int piece;
  int color;
} chessman;

chessman p1, p2;
...
p1 = p2;

使用指向struct的指针数组，也可以。

chessman *array[8][8] = { 0 };

array[1][0] = malloc(sizeof *(array[1][0]));
assign_data(array[1][0]);

array[0][1] = malloc(sizeof *(array[0][1]));
assign_data(array[0][1]);
...
chessman empty = { 0 };
*array[0][1] = *array[1][0];
*array[1][0] = empty;

回想一下，这样的副本是浅副本。 下面的赋值复制成员other_data的指针，而不是other_data引用的内容。

struct {
  int piece;
  int color;
  foo *other_data;
} chessman2;

chessman q1, q2;

q1 = q1; 

Answer 2

你可以做*(array[0][1]) = *(array[1][0]); 要复制结构对象，但您必须确保array[0][1]已经指向一些正确分配的内存。 所以如果array[0][1]到目前为止还没有被初始化，你会写

array[0][1] = malloc(sizeof(*array[0][1]));
*(array[0][1]) = *(array[1][0]);

Answer 3

假设数组元素（指针）引用正确分配的位置，没有更有效的分配结构的方法。

编译器知道结构的大小，并会为它发出最有效的代码。 memcpy方式会更慢。

typedef struct 
{
    int a;
    double b;
    char c;
}a;

typedef struct 
{
    int a[5];
    double b[10];
    char c[100];
}b;

typedef struct 
{
    int a[50];
    double b[100];
    char c[100];
}l;


volatile a c[5];
volatile a *d[5] = {&c[0], &c[1], &c[2], &c[3], &c[4]};

volatile b e[5];
volatile b *f[5] = {&e[0], &e[1], &e[2], &e[3], &e[4]};

volatile l m[5];
volatile l *n[5] = {&m[0], &m[1], &m[2], &m[3], &m[4]};


void foo(void)
{
    *d[2] = *d[4];
}

void foo1(void)
{
    *f[2] = *f[4];
}

void foo2(void)
{
    *n[2] = *n[4];   
}

---

和结果代码：

foo:
        mov     rdx, QWORD PTR d[rip+32]
        mov     rax, QWORD PTR d[rip+16]
        movdqu  xmm0, XMMWORD PTR [rdx]
        movups  XMMWORD PTR [rax], xmm0
        mov     rdx, QWORD PTR [rdx+16]
        mov     QWORD PTR [rax+16], rdx
        ret
foo1:
        mov     rdx, QWORD PTR f[rip+32]
        mov     rax, QWORD PTR f[rip+16]
        movdqu  xmm0, XMMWORD PTR [rdx]
        movups  XMMWORD PTR [rax], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+16]
        movups  XMMWORD PTR [rax+16], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+32]
        movups  XMMWORD PTR [rax+32], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+48]
        movups  XMMWORD PTR [rax+48], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+64]
        movups  XMMWORD PTR [rax+64], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+80]
        movups  XMMWORD PTR [rax+80], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+96]
        movups  XMMWORD PTR [rax+96], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+112]
        movups  XMMWORD PTR [rax+112], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+128]
        movups  XMMWORD PTR [rax+128], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+144]
        movups  XMMWORD PTR [rax+144], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+160]
        movups  XMMWORD PTR [rax+160], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+176]
        movups  XMMWORD PTR [rax+176], xmm0
        movdqu  xmm0, XMMWORD PTR [rdx+192]
        movups  XMMWORD PTR [rax+192], xmm0
        ret
foo2:
        mov     rsi, QWORD PTR n[rip+32]
        mov     ecx, 138
        mov     rdi, QWORD PTR n[rip+16]
        rep movsq
        ret