C++ 内联asm和c数组问题

这是一个家庭作业。我有3个数组，v1={5,4,3,2,1}，v2={1,2,3,4,5}和v3={2,3,5,1,4}，赋值是将1改为6。当然，在asm或c中，任何类似v1[4]=6的解决方案都是禁止的。这就是我的代码：

第一个代码

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[ecx] //moving the content on myArray in position ecx to eax
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[ecx],6 //changing the content in myArray position ecx to 6
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void changingArray(int myArray[]){
__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
   //for some odd reason, they arent changing
   int v1[5]={5,4,3,2,1}; 
   int v2[5]={1,2,3,4,5};  
   int v3[5]={2,3,5,1,4};
   changingArray(v1);
   changingArray(v2);
   changingArray(v3);
}

这不起作用，尝试了很多方法，如

moveax，6

或

mov[eax+ecx]，6

，直到我发现

以后多次尝试代码

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[ecx] //moving the content on myArray in position ecx to eax
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[ecx],6 //changing the content in myArray position ecx to 6
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void changingArray(int myArray[]){
__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
   //for some odd reason, they arent changing
   int v1[5]={5,4,3,2,1}; 
   int v2[5]={1,2,3,4,5};  
   int v3[5]={2,3,5,1,4};
   changingArray(v1);
   changingArray(v2);
   changingArray(v3);
}

这就像一个符咒。但是我不明白

MOV数组[TYPE array*index]，value

是如何或为什么工作的（除了在link中解释的TYPE返回大小之外），为什么其他的不工作

另外，由于我必须对3个数组执行此操作，因此我尝试将所有代码复制并粘贴到

ChanginArray（int myArray[]）

，在main中声明3个数组，并将它们传递给ChanginArray，但现在没有更改它们。我很确定，有了vector，你不必用&，我可能错了。但是，我不明白为什么它不能改变他们。所以

最终代码

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[ecx] //moving the content on myArray in position ecx to eax
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[ecx],6 //changing the content in myArray position ecx to 6
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
int myArray[5]={5,4,3,2,1};

__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void changingArray(int myArray[]){
__asm {
    mov ecx,0 //using ecx as counter
myLoop: 
    mov eax, myArray[TYPE myArray*ecx] //I don't understand how this works
    cmp eax,1            //comparing eax to 1
    je is_one            //if its equal jump to label is_one
    inc ecx              //ecx+1
    cmp ecx,5     //since all vectors have size 5, comparing if ecx is equal to 5
    jne myLoop          //if not, repeat
    jmp Done            //if true, go to label Done
is_one: 
    mov myArray[TYPE myArray*ecx],6 //Uhh...
    inc ecx            //ecx+1
    cmp ecx,5          // ecx=5?
    jne myLoop         //no? repeat loop
    jmp Done           //yes? Done
Done:
    }
printArray(myArray);
}

void main(){
   //for some odd reason, they arent changing
   int v1[5]={5,4,3,2,1}; 
   int v2[5]={1,2,3,4,5};  
   int v3[5]={2,3,5,1,4};
   changingArray(v1);
   changingArray(v2);
   changingArray(v3);
}

TL:DR部分：

将3个数组中的数字1改为6的作业v1={5,4,3,2,1}，v2={1,2,3,4,5}和v3={2,3,5,1,4}

1-我不明白为什么第一个代码不起作用，但后来多次尝试代码都起作用（MOV数组[TYPE array*index]，value指令）

2-由于我需要对3个数组执行此操作，我将所有代码放在

changingArray（int myArray[]）

中，并且在main中声明了我的3个数组，如最终代码所示。虽然许多代码确实改变了数组，但事实并非如此。也许我只是在c中犯了一个错误，而不是在asm中，但我看不出来

对不起，英语不好，这不是我的第一语言

mov eax, myArray[TYPE myArray*ecx]

---

这里提到的地址是（myArray的基址）+sizeof（myArray的元素类型）*ecx。在汇编语言中，索引应以字节为单位。

int

占用4个字节。如果不使用

键入myarray

，您将按字节索引，而不是乘以

int

的大小。谢谢，现在我知道了。