026 数组函数的调用

最新推荐文章于 2023-09-27 19:19:33 发布

btsyang

最新推荐文章于 2023-09-27 19:19:33 发布

阅读量423

点赞数

分类专栏： c语言精彩编程百例学习笔记文章标签： c 编程数组

本文链接：https://blog.csdn.net/btsyang/article/details/43565955

版权

c语言精彩编程百例学习笔记专栏收录该内容

28 篇文章 0 订阅

订阅专栏

/******************026 数组函数的调用*************************
 * 编写一个函数，使给定的一个二维数组转置，即行列互换
 * C 语言编程百例的第17个例子 */

# include<stdio.h>
# define N 3

void convert (int element [N][N]);

void main()
{
    int array[N][N];
    int i,j;
    printf("输入数组元素：\n");
    for(i=0;i<N;i++)
        for(j=0;j<N;j++)
            scanf("%d",&array[i][j]);

    printf("\n数组是：\n");
    for(i=0;i<N;i++)
    {
        for(j=0;j<N;j++)
            printf("%5d",array[i][j]);
        printf("\n");
    }
    convert(array);

    printf("\n转置数组是：\n");
    for(i=0;i<N;i++)
    {
        for(j=0;j<N;j++)
            printf("%5d",array[i][j]);
        printf("\n");
    }
}

//转置函数
void convert(int element[N][N])
{
    int i,j,t;
    for(i=0;i<N;i++)
        for(j=i+1;j<N;j++)
        {
            t=element[i][j];
            element[i][j]=element[j][i];
            element[j][i]=t;
        }
}

    .file   "026.c"
    .def    ___main;    .scl    2;  .type   32; .endef
    .text
LC0:
    .ascii "\312\344\310\353\312\375\327\351\324\252\313\330\243\272\12\0"
LC1:
    .ascii "%d\0"
LC2:
    .ascii "\12\312\375\327\351\312\307\243\272\12\0"
LC3:
    .ascii "%5d\0"
LC4:
    .ascii "\12\0"
LC5:
    .ascii "\12\327\252\326\303\312\375\327\351\312\307\243\272\12\0"
    .align 2
.globl _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    pushl   %ebp
    movl    %esp, %ebp
    subl    $72, %esp
    andl    $-16, %esp
    movl    $0, %eax
    movl    %eax, -68(%ebp)
    movl    -68(%ebp), %eax
    call    __alloca
    call    ___main
    subl    $12, %esp      #printf
    pushl   $LC0
    call    _printf
    addl    $16, %esp
    movl    $0, -60(%ebp)      # i=0
L4:
    cmpl    $2, -60(%ebp)      # if i<3
    jle L7
    jmp L5
L7:
    movl    $0, -64(%ebp)      # j=0
L8:
    cmpl    $2, -64(%ebp)      # j<3
    jle L11
    jmp L6
L11:
    subl    $8, %esp       # scanf
    movl    -60(%ebp), %edx     # edx=i
    movl    %edx, %eax      # eax=i
    addl    %eax, %eax      # eax=i*2
    addl    %edx, %eax      # eax=i*3
    addl    -64(%ebp), %eax     # eax=i*3+j
    leal    0(,%eax,4), %edx    # edx=(i*3+j)*4
    leal    -56(%ebp), %eax     # eax=-56(%ebp)=array
    leal    (%eax,%edx), %eax   # eax=-56(%ebp)+(i+j)*4=array[i][j]
    pushl   %eax            # array[i][j]
    pushl   $LC1           # "%d\0"
    call    _scanf
    addl    $16, %esp      # 平衡堆栈
    leal    -64(%ebp), %eax     # eax=&j
    incl    (%eax)          # j++
    jmp L8
L6:
    leal    -60(%ebp), %eax
    incl    (%eax)          # i++
    jmp L4
L5:
    subl    $12, %esp      # printf("\n数组是：\n");
    pushl   $LC2
    call    _printf
    addl    $16, %esp
    movl    $0, -60(%ebp)      # i=0
L12:
    cmpl    $2, -60(%ebp)      # i<3
    jle L15
    jmp L13
L15:
    movl    $0, -64(%ebp)      # j=0
L16:
    cmpl    $2, -64(%ebp)      # j<3
    jle L19
    jmp L17
L19:
    subl    $8, %esp       # printf
    movl    -60(%ebp), %edx         # edx=i
    movl    %edx, %eax              # eax=i
    addl    %eax, %eax              # eax=i*2
    addl    %edx, %eax              # eax=i*3
    addl    -64(%ebp), %eax         # eax=i*3+j
    pushl   -56(%ebp,%eax,4)        # array[i][j]
    pushl   $LC3                    # "%5d"
    call    _printf                 # 
    addl    $16, %esp               # 平衡堆栈 
    leal    -64(%ebp), %eax         # &j
    incl    (%eax)                  # j++      
    jmp L16                     # 
L17:
    subl    $12, %esp
    pushl   $LC4           # "\n"
    call    _printf
    addl    $16, %esp
    leal    -60(%ebp), %eax     # & i
    incl    (%eax)          # i++
    jmp L12
L13:
    subl    $12, %esp      # 准备调用convert
    leal    -56(%ebp), %eax     # eax=array
    pushl   %eax            # 传递参数
    call    _convert
    addl    $16, %esp      # 栈平衡
    subl    $12, %esp      # 准备调用printf
    pushl   $LC5
    call    _printf
    addl    $16, %esp
    movl    $0, -60(%ebp)      # i=0
L20:
    cmpl    $2, -60(%ebp)      # if i<3
    jle L23
    jmp L3
L23:
    movl    $0, -64(%ebp)      # j=0
L24:
    cmpl    $2, -64(%ebp)      # if j<3
    jle L27
    jmp L25
L27:
    subl    $8, %esp       # 准备调用printf
    movl    -60(%ebp), %edx     # 
    movl    %edx, %eax
    addl    %eax, %eax
    addl    %edx, %eax
    addl    -64(%ebp), %eax
    pushl   -56(%ebp,%eax,4)    # array[i][j]
    pushl   $LC3
    call    _printf
    addl    $16, %esp      # 栈平衡
    leal    -64(%ebp), %eax     # &j
    incl    (%eax)          # j++
    jmp L24
L25:
    subl    $12, %esp      #准备printf
    pushl   $LC4
    call    _printf
    addl    $16, %esp
    leal    -60(%ebp), %eax     # &i
    incl    (%eax)          # i++
    jmp L20
L3:
    leave
    ret

    .align 2
.globl _convert
    .def    _convert;   .scl    2;  .type   32; .endef
_convert:
    pushl   %ebp        # 保存ebp
    movl    %esp, %ebp  # 调整栈基址
    pushl   %ebx        # 保存ebx
    subl    $12, %esp  # 调整栈空间
    movl    $0, -8(%ebp)   # i=0
L29:
    cmpl    $2, -8(%ebp)   # if i<3
    jle L32
    jmp L28
L32:
    movl    -8(%ebp), %eax  # eax =i
    incl    %eax        # eax ++
    movl    %eax, -12(%ebp) # j=i+1
L33:
    cmpl    $2, -12(%ebp)   # if j<3
    jle L36
    jmp L31
L36:
    movl    -8(%ebp), %edx  # edx = i
    movl    %edx, %eax  # eax =i
    addl    %eax, %eax  # eax=i*2
    addl    %edx, %eax  # eax=i*3
    addl    -12(%ebp), %eax # eax=i*3+j
    leal    0(,%eax,4), %edx # edx=(i*3+j)*4
    movl    8(%ebp), %eax   # eax=element
    movl    (%eax,%edx), %eax # eax=element+(i*3+j)*4
    movl    %eax, -16(%ebp) # t=eax
    movl    -8(%ebp), %edx  # edx=i
    movl    %edx, %eax
    addl    %eax, %eax
    addl    %edx, %eax
    addl    -12(%ebp), %eax
    leal    0(,%eax,4), %ebx # ebx=(i*3+j)*4
    movl    8(%ebp), %ecx   # ecx=element
    movl    -12(%ebp), %edx # edx=j
    movl    %edx, %eax  # eax=j
    addl    %eax, %eax  # eax=j*2
    addl    %edx, %eax  # eax=j*3
    addl    -8(%ebp), %eax  # eax=j*3+i
    leal    0(,%eax,4), %edx # edx=(j*3+i)*4
    movl    8(%ebp), %eax   # eax=element
    movl    (%eax,%edx), %eax # eax=element+(j*3+i)*4
    movl    %eax, (%ecx,%ebx) # (element+(i*3+j)*4)=(element+(j*3+i)*4)
    movl    -12(%ebp), %edx # edx=j
    movl    %edx, %eax  # eax=j
    addl    %eax, %eax  # eax=j*2
    addl    %edx, %eax
    addl    -8(%ebp), %eax
    leal    0(,%eax,4), %ecx # ecx=(j*3+i)*4
    movl    8(%ebp), %edx   # edx=element
    movl    -16(%ebp), %eax # eax=t
    movl    %eax, (%edx,%ecx) # (element+(j*3+i)*4)=t
    leal    -12(%ebp), %eax # eax=&j
    incl    (%eax)      # j++
    jmp L33
L31:
    leal    -8(%ebp), %eax  # &i
    incl    (%eax)      # i++
    jmp L29
L28:
    addl    $12, %esp  # 函数内栈平衡
    popl    %ebx
    popl    %ebp
    ret
    .def    _convert;   .scl    2;  .type   32; .endef
    .def    _scanf; .scl    2;  .type   32; .endef
    .def    _printf;    .scl    2;  .type   32; .endef

btsyang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
026 数组函数的调用

/******************026 数组函数的调用************************* * 编写一个函数，使给定的一个二维数组转置，即行列互换 * C 语言编程百例的第17个例子 */# include# define N 3void convert (int element [N][N]);void main(){ int array[N][N
复制链接

扫一扫