C Как избежать разыменования одной и той же переменной несколько раз?

Question

У меня есть массив структур, и у меня есть некоторые функции, которые будут использовать несколько членов этих структур. Я хотел бы избежать разыменования в каждой строке. Я думаю, что был бы какой-то способ объявить переменную в определенной области памяти ... что-то вроде:

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 ++, но для C. Несмотря на это, они разрешают присваивание только один раз (инициализация), что не сработает в моем примере. Я решил положиться на компилятор, чтобы оптимизировать несколько обращений к одному и тому же разделу памяти.

Спасибо, Джеймс Ньюман

Answer 1

Вы пытаетесь сделать то, что оптимизация компилятора делает намного лучше, чем вы можете сделать вручную.Кроме того, 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 генерируют идентичные выходные данные сборки, используя gcc -O2 на платформе x86_64:

        .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

Answer 2

Но .. не нужно говорить о накладных расходах!

То, что вы пытаетесь сделать, это на самом деле добавление накладных расходов.

Я думаю, вам нужно понять, что вы не должны работать противязык, вы должны вместо этого работать с ним;в противном случае это становится так, как будто вы пытаетесь протолкнуть квадратный колышек через круглое отверстие с помощью молотка.

Answer 3

Ваша идея не спасет вас.Указатели позволяют работать с нелокальной памятью.По определению, структура в вашем массиве находится далеко, и вы не можете объявить локальную переменную далеко - это будет оксюморон.

Когда вы говорите 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;
  

  Возможно, он будет более читабельным, но сгенерированный код может быть похож иважно, что вы запутались в далекой памяти столько же раз .

Answer 4

Я думаю, вы ищете оператор размещения, но это C ++, а не C.

Кроме этого, я согласен с остальными - оставь это в покое.