Here is a C++ procedure:
int main()
{
int total=0;
int termindex=0;
while (termindex < 6)
{
// calculate the next term value
int TermValue = raiseToThePower(bases[termindex],exponents[termindex]);
total = determineOperations(operations[termindex],total,TermValue);
termindex++;
}
std::cout << total;
}
Here is an assembly procedure:
doit proc
push eax
push edx
push ebx
push ebp
push ecx
sub esp,4 ; allocating termindex so we can use it
mov ebp,esp
mov dword ptr [ebp],0
restart:
mov eax,4 ; calculate 4-byte offset into our data
mul dword ptr [ebp] ; Multiply term index
mov edx,eax ; Saving the 4-byte offset into edx
; calculate the next term value
mov ecx,bases[edx]
mov ebx,exponents[edx]
call raiseToThePower
; do the operation
mov ecx,eax
mov ebx,total
mov eax,operations[edx]
call determineOperations
mov total,ebx
; See if we need to repeat
inc dword ptr [ebp]
cmp dword ptr [ebp],6
jl restart
pop ecx
pop ebp
pop ebx
pop edx
pop eax
add esp,4 ; deallocating termindex
ret
doit endp
You see in assembly we need to define everything to the right register and it takes so much time and dudududududududu but in C++ it doesn't take so long and you don't have to worry about the registers because C++ takes care of them for us. And you don't have to worry about the "Leave No Trace"rule because C++ automatically does the pushes and pops. Now, you know how we carry certain values back and forth between the different procedures? Well how we do that in C++ is we say "return"and then the name of the dword that has the value that we want to pass to a different procedure. But still don't let it get the best of you because assembly is still pretty important.
Well the previous post (Assembly Town) had a program didn't it. This is that same program except in C++.
#include <iostream>
// We go from main to raiseToThePower
// with the bases and exponents (2,7) and go
// into the loop to multiply them together
// as many times as the exponent
int determineOperations(int operation, int currentTotal, int termValue)
{
int newtotal;
switch(operation)
{
case 0:
newtotal=currentTotal + termValue;
break;
case 1:
newtotal=currentTotal - termValue;
break;
case 2:
newtotal=currentTotal * termValue;
break;
}
return newtotal;
}
int raiseToThePower(int base, int exponent)
{
int count=0;
int answerToThePower=1;
while (count <exponent)
{
answerToThePower=answerToThePower * base;
count++;
}
return answerToThePower;
}
int bases [] = {2,3,6,9,4,2};
int exponents [] = {7,5,3,2,3,3};
int operations [] = {0,0,1,2,0,2};
int main()
{
int total=0;
int termindex=0;
while (termindex < 6)
{
// calculate the next term value
int TermValue = raiseToThePower(bases[termindex],exponents[termindex]);
total = determineOperations(operations[termindex],total,TermValue);
termindex++;
}
std::cout << total;
}
