我有一个结构数组,我有一些函数将使用这些结构的几个成员。我想避免在每一行中取消引用。我认为有一些方法可以在某个内存位置声明变量......类似于:
someStruct &myStruct = arrayOfStructs[i];
myStruct.x = foo+bar*myStruct.y*myStruct.w;
//Instead of myStruct->x = foo+bar*myStruct->y*myStruct->w;
//It would/should even be possible to access the members in a similar way:
int &x = &myStruct.x;
x = x+4*y+2*z;
//This should avoid overhead of dereferencing the pointer, and offsetting to the member
//by just accessing that particular address of memory as though it was where the variable
//had always been.
这段代码示例可能有助于解释:
#define NUM_BIGSTRUCTS 10000
typedef struct {
int a,b,c;
float d,e,f;
} bigStruct;
bigStruct* arrayOfStructs;
void foo() {
for(int i=0; i<NUM_BIGSTRUCTS; i++) {
bigStruct* temp = arrayOfStructs[i];
temp->f = (temp->d+temp->e)*((float)temp->a+temp->e);
//more similar, with conditionals, etc...
//actually I've got nested loops, and a very very large array
//so any gains per inner loop would decrease my number of instructions exponentially
//So, if I could declare a bigStruct and set its address to the location of a bigStruct in the array
//then I could avoid a dereference every time I access a member of that bigStruct
//Leaving just the member access overhead... which could be handled in a similar manner
//if possible, and when appropriate
}
}
int main(int argx, char** argv) {
arrayOfStructs = g_new0(bigStruct,NUM_BIGSTRUCTS); //Allocate and 0 memory for simplicity
foo();
return 0;
}
我从来没有在SO上取得过成功,所以希望我解释了我想要做的事情。我正在使用C99顺便说一句,我相信这是可能的,因为c的低级性质。
[编辑] 看起来我正在寻找来自C ++的'References',但对于C.即便如此,它们只允许赋值一次(初始化),这在我的例子中不起作用。我决定依靠编译器来优化对同一段内存的多次访问。
谢谢, 詹姆斯纽曼
答案 0 :(得分:3)
但是......谈论没有开销!
您要做的是实际增加开销。
我认为你需要知道你不应该反对一种语言,你应该使用它;否则就好像你正试图用锤子将方形钉穿过一个圆孔。
答案 1 :(得分:3)
你正在尝试一些编译器优化比手动更好的东西。另外,C99没有这些引用结构,就像你试图在你的例子中定义它们一样 - 特别是C ++解除引用声明 - 如果你也变得非常大而且深刻,我建议你重新考虑你的算法。如果你试图引入一些临时变量和更多的内存来进行引用,那么你将会更加努力。
例如,如果你看一下:
struct some_struct {
int a;
struct {
float f;
double d;
} s;
};
struct some_struct array[10000];
int process1(struct some_struct *r) {
#define R (*r)
R.a+= 1;
R.s.f = R.s.f/2;
R.s.d = ( R.s.d + R.s.f ) * 2;
}
int process2(struct some_struct *r) {
r->a+= 1;
r->s.f = r->s.f/2;
r->s.d = ( r->s.d + r->s.f ) * 2;
}
int doit() {
int i;
for (i = 0; i < sizeof(array)/sizeof(struct some_struct); i++ ) {
struct some_struct *r = &array[i]; /* via reference */
process1(r);
process2(r);
}
}
process1和process2在x86_64平台上使用gcc -O2生成相同的汇编输出:
.file "foo.c"
.text
.p2align 4,,15
.globl process1
.type process1, @function
process1:
.LFB11:
.cfi_startproc
movss .LC0(%rip), %xmm0
addl $1, (%rdi)
mulss 8(%rdi), %xmm0
movss %xmm0, 8(%rdi)
unpcklps %xmm0, %xmm0
cvtps2pd %xmm0, %xmm0
addsd 16(%rdi), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 16(%rdi)
ret
.cfi_endproc
.LFE11:
.size process1, .-process1
.p2align 4,,15
.globl process2
.type process2, @function
process2:
.LFB12:
.cfi_startproc
movss .LC0(%rip), %xmm0
addl $1, (%rdi)
mulss 8(%rdi), %xmm0
movss %xmm0, 8(%rdi)
unpcklps %xmm0, %xmm0
cvtps2pd %xmm0, %xmm0
addsd 16(%rdi), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 16(%rdi)
ret
.cfi_endproc
.LFE12:
.size process2, .-process2
.p2align 4,,15
.globl doit
.type doit, @function
doit:
.LFB13:
.cfi_startproc
xorl %edx, %edx
movss .LC0(%rip), %xmm2
.p2align 4,,10
.p2align 3
.L4:
leaq (%rdx,%rdx,2), %rax
addq $1, %rdx
leaq array(,%rax,8), %rax
movss 8(%rax), %xmm1
addl $2, (%rax)
mulss %xmm2, %xmm1
cmpq $10000, %rdx
unpcklps %xmm1, %xmm1
cvtps2pd %xmm1, %xmm0
mulss %xmm2, %xmm1
addsd 16(%rax), %xmm0
movss %xmm1, 8(%rax)
unpcklps %xmm1, %xmm1
cvtps2pd %xmm1, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 16(%rax)
jne .L4
rep
ret
.cfi_endproc
.LFE13:
.size doit, .-doit
.comm array,240000,32
.section .rodata.cst4,"aM",@progbits,4
.align 4
.LC0:
.long 1056964608
.ident "GCC: (GNU) 4.6.1"
.section .note.GNU-stack,"",@progbits
答案 2 :(得分:1)
你的想法不会为你节省任何东西。指针可让您使用非本地内存。根据定义,数组中的结构很远,你不能在很远的地方声明一个局部变量 - 这将是矛盾的。
当你说int &x = &myStruct.x;
时,你会混淆两个想法:
本地变量:您可以轻松地
int x = temp->x
//work with x...
temp->x = x
好处是,当你使用它时,你正在处理与你亲近的事情。 缺点是来回复制,但确实可能存在一些问题。
指针:另一种方式是
int *x = &temp->x
//work with x, like you would a pointer
但是,这确实没有太大帮助,因为这与在整个地方使用temp->x
没什么不同。 (除非可能清晰)。想想数组:
假设您有以下代码:
int array[25];
array[3] = array[2] + array[3];
array[7] = array[3]*array[7] + array[3]<<7;
您建议将其转换为:
int array[25]
int *a = &array[3], *b=&array[2], *c=&array[7];
*a = *b+*a;
*c = (*a)*(*c) + *a<<7;
它可能更具可读性,但生成的代码可能类似且重要的是,您将远离内存完全相同的次数。
答案 3 :(得分:0)
我认为你正在寻找贴牌新操作符,但那是C ++,而不是C。
除此之外,我同意其他人 - 不管它。