incrémenter les membres de la structure

Dire que j'ai une structure définie comme suit

struct my_struct
{
     int num;
};

....

Ici, j'ai un pointeur vers my_struct et je veux faire un incrément sur num

void foo(struct my_struct* my_ptr)
{
     //increment num
     //method #1
     my_ptr->num++;

     //method #2
     ++(my_ptr->num);

     //method #3
     my_ptr->++num;

}

Faire ces 3 façons de l'incrémentation num faire la même chose?
Pendant que nous y sommes, est-il vrai que la pré-incrémentation est plus efficace que la post-incrémentation?

Merci!

OriginalL'auteur user1508893 | 2012-09-30

  1. 9

    Deux premiers auront le même effet (en ligne sur leur propre comme que), mais la troisième méthode n'est pas valide code C (vous ne pouvez pas placer le ++).

    Que de l'efficacité, il n'y a pas de différence. La différence que vous avez peut-être entendu des gens parler, c'est quand, en C++, vous incrémenter un non-pointeur de type de données, comme un itérateur. Dans certains cas, la pré-incrémentation peut être plus rapide.

    Vous pouvez voir le code généré à l'aide de GCC Explorer.

    void foo(struct my_struct* my_ptr)
{
    my_ptr->num++;
}

void bar(struct my_struct* my_ptr)
{
    ++(my_ptr->num);
}

    De sortie:

    foo(my_struct*):                      # @foo(my_struct*)
    incl    (%rdi)
    ret

bar(my_struct*):                      # @bar(my_struct*)
    incl    (%rdi)
    ret

    Comme vous pouvez le voir, il n'y a pas de différence du tout.

    La seule différence possible entre les deux premiers est le moment de les utiliser dans des expressions:

    my_ptr->num = 0;
int x = my_ptr->num++; //x = 0

my_ptr->num = 0;
int y = ++my_ptr->num; //y = 1

    OriginalL'auteur Peter Alexander

  2. 2

    Si votre seul objectif est d'incrémenter la valeur de num puis le 1er et le 2ème méthode donnera même été conçue suite à l'appel de la méthode.

    Toutefois, si vous modifiez votre code à la suivante, vous pouvez voir la différence entre le code généré par gcc (au niveau de l'assemblée de code):

    struct my_struct
{
     int num;
};

void foo(struct my_struct* my_ptr)
{
        printf("\nPost Increment: %d", my_ptr->num++);
}

int main()
{
        struct my_struct a;
        a.num = 10;

        foo(&a);
}

    Maintenant, le compiler à l'aide de: gcc-masm=intel -S structTest.c -o structTest.s
    Cette demande de gcc de générer le code assembleur:

    Ouvrir structTest.s dans un éditeur de texte.

    foo:
.LFB0:
         push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        **mov     QWORD PTR [rbp-8], rdi**
        mov     rax, QWORD PTR [rbp-8]
        mov     eax, DWORD PTR [rax]
        mov     edx, eax
        **lea     ecx, [rax+1]**
        mov     rax, QWORD PTR [rbp-8]
        mov     DWORD PTR [rax], ecx
        mov     eax, OFFSET FLAT:.LC0
        mov     esi, edx
        mov     rdi, rax
        mov     eax, 0
        call    printf
        leave
        ret
        .cfi_endproc

main:
.LFB1:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        **mov     DWORD PTR [rbp-16], 10
        lea     rax, [rbp-16]
        mov     rdi, rax
        call    foo**
        leave
        ret
        .cfi_endproc

    Et lorsque vous changez l'opération de pré-incrémentation, la suivante de code est généré:

    foo:
.LFB0:
        .cfi_startproc
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        **mov     QWORD PTR [rbp-8], rdi**
        mov     rax, QWORD PTR [rbp-8]
        mov     eax, DWORD PTR [rax]
        **lea     edx, [rax+1]**
        mov     rax, QWORD PTR [rbp-8]
        **mov     DWORD PTR [rax], edx**
        mov     rax, QWORD PTR [rbp-8]
        **mov     edx, DWORD PTR [rax]**
        mov     eax, OFFSET FLAT:.LC0
        mov     esi, edx
        mov     rdi, rax
        mov     eax, 0
        call    printf
        leave
        ret
        .cfi_endproc

    Donc, vous voyez que dans le second cas, le compilateur incrémente le num de la valeur et passe sur ce num de la valeur à printf().

    En termes de performances, je m'attends à la post-incrémentation d'être plus efficace car les emplacements de mémoire sont touché à un moins grand nombre de fois.

    Les lignes importants ont été marquées entre ** dans le code ci-dessus.

    OriginalL'auteur FunBoy