5.12 汇编语言:仿写While循环语句

微软技术分享 微软最有价值专家
全栈领域优质创作者
博客专家认证
2023-11-18 13:09:30

循环语句(While)一种基本控制结构,它允许程序在条件为真的情况下重复执行一段代码块,直到条件为假为止。循环语句在处理需要重复执行的任务时非常有用,它可以让程序更加高效地处理大量数据或者重复性操作。

一般来说,While循环由一个条件表达式、一个代码块组成。在每次循环迭代开始时,程序会首先检查条件表达式的值,如果为真,则执行代码块,然后再次检查条件表达式的值。只要条件表达式为真,循环就会一直继续执行;一旦条件表达式为假,循环将停止,程序继续执行循环之后的代码。

12.12 Do-While 循环结构优化

DO语句先执行循环体,后进行判断,如果通过则跳转到循环体首部继续执行,未通过则直接顺序向下走。DO循环效率最高,该循环在结构上非常精简,利用了程序执行时由低到高的特性,由于结构内只在结尾处做了判断,只使用了一条判断语句即实现了循环,因此已经无需在结构上进行任何优化了。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0     ; 初始化循环次数
  S1:
    xor eax,eax                    ; 执行循环体
    mov eax,dword ptr ds:[count]   ; 取出计数器
    add eax,1                      ; 递增
    mov dword ptr ds:[count],eax   ; 回写
    
    cmp dword ptr ds:[count],10    ; 与10做对比
    jl S1                          ; 小于则继续循环

    int 3
    invoke ExitProcess,0
  main ENDP
END main

12.13 While 循环结构优化

While语句先判断循环条件,后执行循环体,由于需要判断,该循环的构建需要使用两个跳转语句方可实现。While循环结构的效率要比Do循环结构低,While循环结构先比较再循环,因此无法利用程序执行顺序来完成循环,又因为While循环结构使用了2个跳转指令,在程序流程上就弱于Do循环。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0            ; 设置while初始化
  S1:
    cmp dword ptr ds:[count],10           ; 设置最大循环数
    jge loop_end                          ; 判断是否循环结束
    
    xor eax,eax                           ; 执行循环体
    
    mov eax,dword ptr ds:[count]           ; 取出循环条件
    add eax,1                              ; 递增
    mov dword ptr ds:[count],eax           ; 写回
    jmp S1
  
  loop_end:
    int 3

    invoke ExitProcess,0
  main ENDP
END main

为了提升While循环执行效率,编译器通常会将其转换为对等的Do循环,如果循环无法转成对等的Do循环,则可使用单层IF结构内部嵌套Do循环的方式来实现,外层IF则用来判断Do循环是否执行,例如如下案例中,首先外层使用IF语句判断循环条件,该语句内部则嵌套一个Do循环,以此来将While转为Do。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
.code
  main PROC
    mov dword ptr ds:[count],0            ; 设置初始条件
    
    ; 初次判断条件是否满足
    cmp dword ptr ds:[count],10
    jge loop_end
  S1:
    ; 循环体内部语句
    xor eax,eax
    
    ; 递增
    add dword ptr ds:[count],1
    
    ; 比较条件是否满足
    cmp dword ptr ds:[count],10
    jl S1
    
  loop_end:
    int 3

    invoke ExitProcess,0
  main ENDP
END main

12.15 Loop 循环结构优化

上方提到过的三种循环模式都是通过跳转指令与计数器构建的,与这三者不同汇编中默认提供了loop指令,专门用来实现循环计数功能,由于是汇编指令,所以此loop语句必须读入ECX寄存器内的次数作为循环终止条件,每次读入会自动递减,具体汇编代码如下。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
  result DWORD ?
  ArrayDW DWORD 8,7,9,4,3,7,5,8,9,3,0h

.code
  main PROC
    ; 通过loop实现的单层循环体
    xor eax,eax                       ; 用于累加数据
    mov ecx,10                        ; 设置循环次数
  s1:
    mov dword ptr ds:[count],ecx      ; 将循环次数备份
    xor ecx,ecx                       ; 清空寄存器
    mov ecx,10
    add eax,ecx                       ; 结果想加到eax
    mov ecx,dword ptr ds:[count]      ; 恢复循环次数
    loop s1
    
    mov dword ptr ds:[result],eax     ; 获取相加后的结果
    
    invoke ExitProcess,0
  main ENDP
END main

如果是双层循环体,则在使用loop语句构建时,必须考虑外层ECX中的循环计数该如何处理,通常会把外层循环计数保存在栈中,这是非常的理想的,保存在一个变量内也勉强凑活,只是效率上没有直接压入栈中高。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

.data
  count DWORD ?
  result DWORD ?
  ArrayDW DWORD 8,7,9,4,3,7,5,8,9,3,0h

.code
  main PROC
    ; 通过loop实现嵌套循环体
    mov ecx,9                   ; 控制外层循环数
  s2:
    push ecx                    ; 保存外层循环数
    mov ecx,9                   ; 设置内层循环数
  s3:
    mov eax,dword ptr ds:[ArrayDW + ecx * 4]
    cmp eax,3                    ; 与3作比较大于则跳
    ja jump
    loop s3
  jump:
    xor eax,eax
    pop ecx
    loop s2
    
    invoke ExitProcess,0
  main ENDP
END main

运用Loop指令实现对数组MyArray的由大到小排序,其中ArraySort子过程用于由大到小排序,子过程PrintArray用于循环输出排序后的结果。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 25,74,89,33,24,67,93,15,78,92
  Count DWORD 10
  PrCount DWORD ?
  szFmt BYTE '%d ',0dh,0ah,0

.code
  ; 数组排序函数
  ArraySort PROC
      mov ecx,dword ptr ds:[Count]      ; 获取到数组元素数
      dec ecx                           ; 数组减1
    L1:
      push ecx                          ; 入栈保存
      lea esi,dword ptr ds:[MyArray]    ; 得到数组基地址
      
    L2:
      mov eax,dword ptr ds:[esi]
      cmp eax,dword ptr ds:[esi + 4]    ; 比较第一个数组与第二个
      jg L3
      
      xchg eax,[esi + 4]                ; 交换数据
      mov [esi],eax
    L3:
      add esi,4
      loop L2
      
      pop ecx                           ; 弹出数据
      loop L1
      ret
  ArraySort ENDP
  
  ; 循环输出元素
  PrintArray PROC
      mov dword ptr ds:[PrCount],0            ; 初始化元素
      
    L1:
      mov ecx,dword ptr ds:[PrCount]          ; 获取循环次数
      cmp ecx,10                              ; 对比十次
      jge lop_end                             ; 判断是否可结束循环
      
      lea eax,dword ptr ds:[MyArray]          ; 获取数组基地址
      mov ebx,dword ptr ds:[eax + ecx * 4]    ; 比例因子寻址
      invoke crt_printf,addr szFmt,ebx
      
      mov ecx,dword ptr ds:[PrCount]          ; 取循环计数
      add ecx,1
      mov dword ptr ds:[PrCount],ecx          ; 递增后回写
      jmp L1
      
    lop_end:
      int 3
      ret

  PrintArray ENDP

  main PROC
    invoke ArraySort
    invoke PrintArray
  main ENDP
END main

12.16 仿写Do-While循环体

这段C++代码定义了一个包含10个元素的整型数组,然后在do-while循环中对数组进行遍历,并检查每一个数组元素是否满足下面的条件:它的值大于10并且下一个数组元素的值小于等于20。如果找到了满足条件的数组元素,则输出它和下一个数组元素的值,并跳出循环。如果循环结束都没有找到符合条件的数组元素,则直接退出程序。这段代码展示了如何使用循环和条件判断对数组进行遍历和筛选。

#include <stdio.h>
#include <Windows.h>

int main(int argc, char *argv[])
{
  int Array[10] = { 56,78,33,45,78,90,32,15,56,67 };
  int index = 0;

  do
  {
    if (Array[index] > 10 && Array[index + 1] <= 20)
    {
      printf("array[1] => %d array[2] => %d \n", Array[index], Array[index + 1]);
      break;
    }

    index = index + 1;
  } while (index < 10);

  system("pause");
  return 0;
}

由于是自己仿写,所以此处我使用了For形式的循环模式,首先初始化count=0进入L1循环后先来判断数组中第一个元素是否小于10,接着通过add eax,1将比例因子向后移动4字节,继续比较第二个数值是否小于等于20,如果都存在则直接输出该结果,并通过jmp lop_end跳转到程序结尾,否则递增count元素,并跳转到循环开头继续查找。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 56,78,33,45,78,90,32,15,56,67
  count DWORD ?
  szFmt BYTE 'array[1] => %d array[2] => %d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[count],0                     ; int index = 0;

  L1:
    mov eax,dword ptr ds:[count]
    cmp dword ptr ds:[MyArray + eax * 4],10        ; Array[index] > 10
    jle L2
    
    mov eax,dword ptr ds:[count]
    add eax,1
    cmp dword ptr ds:[MyArray + eax * 4],20        ; Array[index + 1] <= 20
    jg L2
    
    mov esi,dword ptr ds:[MyArray + eax * 4 - 4]   ; esi = Array[index]
    mov edi,dword ptr ds:[MyArray + eax * 4]       ; edi = Array[index+1]
    invoke crt_printf,addr szFmt,esi,edi
    jmp lop_end                                    ; break

  L2:
    mov eax,dword ptr ds:[count]
    add eax,1                                      ; index = index + 1;
    mov dword ptr ds:[count],eax
    cmp dword ptr ds:[count],10                    ; index < 10
    jl L1

  lop_end:                                           ; break
    int 3
  main ENDP
END main

12.17 仿写While循环体

这段C++代码定义了一个包含10个元素的整型数组,然后在while循环中对数组进行遍历,输出每一个数组元素的值。循环使用一个count变量作为计数器,从0开始逐步增加,直到count的值等于数组元素的总数。在循环内部,它通过count变量访问数组元素,并将它们的值作为参数传递给printf函数进行输出。这段代码展示了如何使用循环结构遍历数组元素。

#include <stdio.h>
#include <Windows.h>

int main(int argc,char *argv[])
{
  int Array[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int count = 0;

  while (count < sizeof(Array) / sizeof(int))
  {
    printf("value = %d \n", Array[count]);
    count = count + 1;
  }
  return 0;
}

首先初始化部分,设置ecx寄存器为比例因子,进入循环体后,通过寻址公式ds:[esi + ecx * 4]实现对数组地址的递增输出,此代码中的ds:[count]只用于控制循环体循环次数,ecx寄存器则只用做寻址因子使用。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 1,2,3,4,5,6,7,8,9,10
  count DWORD ?
  szFmt BYTE 'value = %d ',0dh,0ah,0
.code
  main PROC
    mov dword ptr ds:[count],0                 ; 初始化循环
    mov ecx,0                                  ; 设置循环计数(比例因子)

  S1:
    cmp dword ptr ds:[count],lengthof MyArray  ; 与数组总长度对比
    jge lop_end                                ; 是否结束
    
    lea esi,dword ptr ds:[MyArray]             ; 获取数组基地址
    mov ebx,dword ptr ds:[esi + ecx * 4]       ; 比例因子寻址
    invoke crt_printf,addr szFmt,ebx           ; 调用系统crt
    
    mov ecx,dword ptr ds:[count]
    add ecx,1                                   ; 计次循环递增
    mov dword ptr ds:[count],ecx
    jmp S1

  lop_end:
    int 3
    invoke ExitProcess,0
  main ENDP
END main

12.18 仿写While三层循环体

这段C++代码实现了一个三重循环,用于生成所有由1到4中不重复的三个数字组成的序列。在外层循环中,它使用变量x从1开始逐个增加,直到其值大于等于5。在中间循环中,它使用变量y从1开始逐个增加,直到其值大于等于5。在最内层循环中,它使用变量z从1开始逐个增加,直到其值大于等于5。然后它检查当前的x、y、z变量是否满足三个数不重复的条件,如果满足,则输出这三个数字,并进入第三个循环。循环结构使用变量z逐项增加,并在检查条件后继续下一个序列的生成。当z逐项增加完成后,中间循环使用变量y逐项增加。如此循环,直到所有由1到4的三个数字序列都被产生出来为止。

#include <windows.h>
#include <stdio.h>

int main(int argc,char * argv[])
{
  int x=1, y=1, z=1;

  while (x < 5)
  {
    while (y < 5)
    {
      while (z < 5)
      {
        
        if (x != z && x != y && y != z)
        {
          printf("%d,%d,%d \n", x, y, z);
        }
        z = z + 1;
      }
      z = 1;
      y = y + 1;
    }
    y = 1;
    x = x + 1;
  }
  return 0;
}

由于这段C代码使用了三层While循环,其构建为汇编代码时稍有些难度,我们首先把外层框架构建好,先来构建一个二层While循环结构,如下汇编代码中,我们通过变量x DWORD控制外层循环次数,内层循环次数则使用y DWORD变量来控制,当每次需要修改或读取变量时,则通过mov ecx,dword ptr ds:[x]指令将计数次数读入到ecx寄存器内,以此来保证循环次数不冲突。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  szFmt BYTE '外层循环: %d ---> 内层循环:%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1:
    mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 内层循环
    mov dword ptr ds:[y],1           ; y = 1
    
  L2:
    mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3
    
    ; 循环过程执行(存放循环过程代码)
    mov esi,dword ptr ds:[x]
    mov edi,dword ptr ds:[y]
    invoke crt_printf,addr szFmt,esi,edi

    mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3:
    mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

既然二层结构可以被构建出来,那么我们利用这个原理,在二层基础之上增加一个z DWORD变量,用于对最内部的While语句进行计数,由此我们就可以构建出三层While循环结构,汇编代码如下所示,仔细看完全能看懂的。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  z DWORD ?
  szFmt BYTE '外层循环: %d ---> 中间层循环: %d ---> 内层循环: %d  ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1: mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 中间循环
    mov dword ptr ds:[y],1           ; y = 1
  L2: mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3                           ; 大于跳到最外层

    ; 内层循环
    mov dword ptr ds:[z],1           ; z = 1
    
  L5: mov ecx,dword ptr ds:[z]
    cmp ecx,5                        ; z < 5
    jge L4                           ; 大于跳到中间层
    
    ; 三层循环框架
    mov eax,dword ptr ds:[x]
    mov ebx,dword ptr ds:[y]
    mov ecx,dword ptr ds:[z]
    invoke crt_printf,addr szFmt,eax,ebx,ecx
    
    mov ecx,dword ptr ds:[z]
    add ecx,1                         ; z = z + 1
    mov dword ptr ds:[z],ecx
    
    jmp L5
    
  L4: mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3: mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

最后我们用上方三层结构作为框架使用,在其基础之上增加内部的IF判断功能实现,这样一来我们的三层While嵌套循环体的仿写就实现了,多说一句,在仿写时一定要注意次序跟规律谨慎些,写出来并不难。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  x DWORD ?
  y DWORD ?
  z DWORD ?
  szFmt BYTE '%d,%d,%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[x],1           ; x = 1
  
    ; 外层循环
  L1: mov ecx,dword ptr ds:[x]
    cmp ecx,5                        ; x < 5
    jge lop_end
    
    ; 中间循环
    mov dword ptr ds:[y],1           ; y = 1
  L2: mov ecx,dword ptr ds:[y]         ; ecx = y
    cmp ecx,5                        ; y < 5
    jge L3                           ; 大于跳到最外层

    ; 内层循环
    mov dword ptr ds:[z],1           ; z = 1
    
  L5: mov ecx,dword ptr ds:[z]
    cmp ecx,5                        ; z < 5
    jge L4                           ; 大于跳到中间层
    
    ; 三层循环框架
    ;mov eax,dword ptr ds:[x]
    ;mov ebx,dword ptr ds:[y]
    ;mov ecx,dword ptr ds:[z]
    ;invoke crt_printf,addr szFmt,eax,ebx,ecx
    
    ; 开始在框架中搞事情
    mov eax,dword ptr ds:[x]
    cmp eax,dword ptr ds:[z]
    je L6
    mov eax,dword ptr ds:[x]
    cmp eax,dword ptr ds:[y]
    je L6
    mov eax,dword ptr ds:[y]
    cmp eax,dword ptr ds:[z]
    je L6
    
    invoke crt_printf,addr szFmt,dword ptr ds:[x],dword ptr ds:[y],dword ptr ds:[z]
    
  L6: mov ecx,dword ptr ds:[z]
    add ecx,1                         ; z = z + 1
    mov dword ptr ds:[z],ecx
    
    jmp L5
    
  L4: mov ecx,dword ptr ds:[y]
    add ecx,1                        ; y = y + 1
    mov dword ptr ds:[y],ecx
    jmp L2

  L3: mov ecx,dword ptr ds:[x]
    add ecx,1                        ; x = x + 1
    mov dword ptr ds:[x],ecx
    jmp L1
  
  lop_end:
    int 3 

  main ENDP
END main

12.19 仿写While实现二分法

该C++代码实现了一个二分查找算法,用于在已排序的数组中查找指定值的位置。代码中定义了一个BinSearch函数,通过对传入数组进行二分查找,最终返回要查找的值在数组中的索引值。main函数调用了BinSearch函数,在已知数组中查找指定值并输出其在数组中的索引。

#include <windows.h>
#include <stdio.h>

int BinSearch(int value[], const int SearchVal, int Count)
{
  int first = 0;
  int last = Count - 1;

  while (first <= last)
  {
    int mid = (last + first) / 2;      // 取中位数
    if (value[mid] < SearchVal)        // 中位数小于searchVal
    {                                  // 说明元素在后面
      first = mid + 1;
    }
    else if (value[mid] > SearchVal)
    {                                  // 否则说明元素在前
      last = mid - 1;
    }
    else
    { // 找到后返回中位数
      return mid;
    }
  }
  return -1;
}

int main(int argc, char *argv[])
{
  // 二分查找法,必须针对的是有序数组
  int Array[10] = { 1,2,3,4,5,6,7,8,9,10 };

  // 查找数组Array中索引7所在的下标
  int ret = BinSearch(Array, 7, 10);
  printf("数组下标: %d \n", ret);

  system("pause");
  return 0;
}

接着是尝试使用汇编实现这个查找逻辑,这段代码你一定可以看懂,细心些就好,我写的时候也思考了很长时间才写出来的。

  .386p
  .model flat,stdcall
  option casemap:none

include windows.inc
include kernel32.inc
includelib kernel32.lib

include msvcrt.inc
includelib msvcrt.lib

.data
  MyArray DWORD 1,2,3,4,5,6,7,8,9,10
  
  SearchVal DWORD 7
  Count DWORD 10
  
  first DWORD ?
  last DWORD ?
  mid DWORD ?
  szFmt BYTE '%d ',0dh,0ah,0

.code
  main PROC
    mov dword ptr ds:[first],0         ; first = 0;
    mov edi,dword ptr ds:[SearchVal]   ; 得到要查找的数
    lea ebx,dword ptr ds:[MyArray]     ; 得到数组基地址

    ; int last = Count - 1;
    mov eax,dword ptr ds:[Count]
    sub eax,1
    mov dword ptr ds:[last],eax
    
    ; while(first <=last)
  L1: mov ecx,dword ptr ds:[first]
    cmp ecx,dword ptr ds:[last]
    jg lop_end
    
    ; int mid = (last + first) / 2;
    mov eax,dword ptr ds:[last]
    add eax,dword ptr ds:[first]
    shr eax,1
    mov dword ptr ds:[mid],eax
    
    ; edx = value[mid]
    mov esi,dword ptr ds:[mid]
    shl esi,2
    mov edx,[ebx + esi]
    ;invoke crt_printf,addr szFmt,edx

    ; if(edx < SearchVal(edi))
    cmp edx,edi
    jge L2
    ; first = mid + 1;
    mov eax,dword ptr ds:[mid]
    add eax,1
    mov dword ptr ds:[first],eax
    jmp L1
  L2:
    ; else if (value[mid] > searchVal)
    cmp edx,edi
    jle L3
    ; last = mid - 1;
    mov eax,dword ptr ds:[mid]
    sub eax,1
    mov dword ptr ds:[last],eax
    jmp L1
  
  L3: ; else
    mov eax,dword ptr ds:[mid]
    invoke crt_printf,addr szFmt,eax
    jmp lop_end
    jmp L1
  lop_end:
    mov eax,-1
    int 3

  main ENDP
END main
...全文
15 回复 打赏 收藏 转发到动态 举报
写回复
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复

528

社区成员

发帖
与我相关
我的任务
社区描述
微软技术社区为中国的开发者们提供一个技术干货传播平台,传递微软全球的技术和产品最新动态,分享各大技术方向的学习资源,同时也涵盖针对不同行业和场景的实践案例,希望可以全方位地帮助你获取更多知识和技能。
windowsmicrosoft 企业社区
社区管理员
  • 微软技术分享
  • 郑子铭
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告

微软技术社区为中国的开发者们提供一个技术干货传播平台,传递微软全球的技术和产品最新动态,分享各大技术方向的学习资源,同时也涵盖针对不同行业和场景的实践案例,希望可以全方位地帮助你获取更多知识和技能。

予力众生,成就不凡!微软致力于用技术改变世界,助力企业实现数字化转型。

试试用AI创作助手写篇文章吧