L'

ordre de poussé sur la pile est déterminé au moment de la compilation.

La principale chose qui doit être placée sur la pile avant un appel de fonction, ce sont les paramètres de la fonction, et les paramètres sont tous fixes (les paramètres variables ne sont que des décalages déterminés par les macros).
Le code pour appeler les fonctions est placé dans le segment de code, et le transfert sur la pile se fait sous forme d'instructions, donc l'ordre est déterminé au moment de la compilation.

@lianera l'a bien dit, l'ordre de poussée sur la pile est déterminé au moment de la compilation.

Laissez-moi vous montrer un exemple :
J'ai un morceau de code comme celui-ci

#include <stdio.h>

int test_fun(int a, int b)
{
    return a + b;    
}

int main(int argc, char *argv[])
{
    int A, B, ret;

    A = 3;
    B = 4;
    ret = test_fun(A, B);

    return 1;
}

Après compilation, son code assembleur ressemble à ceci

int test_fun(int a, int b)
{
  400474:    55                       push   %rbp
  400475:    48 89 e5                 mov    %rsp,%rbp
  // $edi存的是A的值，$esi存的是B的值，将他们压入栈中
  400478:    89 7d fc                 mov    %edi,-0x4(%rbp)
  40047b:    89 75 f8                 mov    %esi,-0x8(%rbp)
    return a + b;    
  40047e:    8b 45 f8                 mov    -0x8(%rbp),%eax
  400481:    8b 55 fc                 mov    -0x4(%rbp),%edx
  400484:    8d 04 02                 lea    (%rdx,%rax,1),%eax
}

int main(int argc, char *argv[])
{
  400489:    55                       push   %rbp
  40048a:    48 89 e5                 mov    %rsp,%rbp
  40048d:    48 83 ec 20              sub    rrreeex20,%rsp
  400491:    89 7d ec                 mov    %edi,-0x14(%rbp)
  400494:    48 89 75 e0              mov    %rsi,-0x20(%rbp)
    int A, B, ret;
  
  // 压入本地变量A
    A = 3;
  400498:    c7 45 f4 03 00 00 00     movl   rrreeex3,-0xc(%rbp)
  // 压入本地变量B
    B = 4;
  40049f:    c7 45 f8 04 00 00 00     movl   rrreeex4,-0x8(%rbp)
    ret = test_fun(A, B);
  4004a6:    8b 55 f8                 mov    -0x8(%rbp),%edx
  4004a9:    8b 45 f4                 mov    -0xc(%rbp),%eax
  // 将A和B的值放入相应的寄存器
  4004ac:    89 d6                    mov    %edx,%esi
  4004ae:    89 c7                    mov    %eax,%edi
  // 调用test_fun
  4004b0:    e8 bf ff ff ff           callq  400474 <test_fun>
  4004b5:    89 45 fc                 mov    %eax,-0x4(%rbp)

    return 1;
  4004b8:    b8 01 00 00 00           mov    rrreeex1,%eax
}

Peu importe si vous ne comprenez pas l'assemblage. Pendant le processus de compilation, l'ordre dans lequel les paramètres sont passés et l'endroit où sur la pile (position relative) les paramètres, les variables locales, etc. doivent être placés sont. tous déterminés. Lorsque le programme s'exécute sur le programme correspondant, la pile sera exploitée dans l'ordre compilé.

Le transfert sur la pile n'est-il pas un processus qui ne se produit que pendant l'exécution ? La compilation n'est qu'un processus de traduction en bytecode. Pourquoi y a-t-il une poussée sur la pile ?