Wstawka asm do c+, problem/zlecenie?

Witam, mam problem ze wstawka asm do c++, wyskakuje mi taki błąd: "error C2415: improper operand type"
W jaki sposób mogę uporać się z tym problemem ?

Ps. Jeśli chciałby ktoś przyjąć napisanie programu jako zlecenia to proszę o pw.

Och i na pewno ktoś BEZ KODU będzie ci wstanie udzielić odpowiedzi. Szczęśliwie spamowałeś mi już tym wcześniej na PW więc widziałem kod. Na oko to masz zwyczajnie błąd w kodzie bo robisz

mov sum, a

zamiast jakiegoś

mov [sum], ax

#define N 4
const char k = N;
char tab[N] = { 1, 2, 3, 4};
unsigned short sum;
unsigned short srednia_cal;
unsigned short srednia_reszta;


int main()
{
	__asm{
		mov cl, 0
		mov ax, 0
			mov dh, 0
			mov ebx, offset tab
		start :
		mov dl, byte ptr[ebx]
			add ax, dx
			inc ebx
			inc cl
			cmp k, cl
			jg start
			mov [sum], ax

			mov edx, 0
			mov ecx, N
			div ecx
			mov	[srednia_cal], eax
			
			

	};

	


	cout << sum << endl;
	cout << srednia_cal << endl;
	return 0;
} 

Suma działa dziękuje, a teraz robię średnią i mam taki problem: error C2443: operand size conflict
Wiem że działanie div ecx powinno wynik dzielenia zapisać w eax, reszta w rejestrze edx, ale pewnie coś pokręciłem bo mało to rozumiem, proszę o pomoc

Błąd masz taki że nie rozumiesz co robisz. To nie jest obojętne czy piszesz al czy ah czy ax czy eax a dla ciebie chyba jednak jest.
al -> 8 bitów - 1 bajt
ah -> 8 bitów - 1 bajt
ax to jest złożenie al i ah i ma 16 bitów - 2 bajty
eax ma 32 bity - 4 bajty

char ma 8 bitów - 1 bajt
short int ma 16 bitów - 2 bajty
int ma 32 bity - 4 bajty

Więc operacja

mov    [srednia_cal], eax

nie ma sensu bo eax to 32 bity a srednia_cal to zmienna short int która ma 16 bitów.

Dzięki,

mov dx, 0
	  mov cx, N
	  div cx
	  mov[srednia_cal], ax
	  mov[srednia_reszta], dx 

ale coś mi źle liczy reszte.

Niemożliwe ;] Robisz dzielenie dx:ax / cx i wynik masz w ax a resztę w dx. Dla jakiego przykładu ci nie działa?

#include <iostream>
using namespace std;

#define N 6
const char k = N;
char tab[N] = { 1, 2, 3, 4, 8,3};
unsigned short sum;
unsigned short srednia_cal;
unsigned short srednia_reszta;


int main()
{
	__asm{
		mov cl, 0
		mov ax, 0
			mov dh, 0
			mov ebx, offset tab
		start :
		mov dl, byte ptr[ebx]
			add ax, dx
			inc ebx
			inc cl
			cmp k, cl
			jg start
			mov [sum], ax

			mov dx, 0
			mov cx, N
			div cx
			mov[srednia_cal], ax
			mov[srednia_reszta], dx

	};

	cout << sum << endl;
	cout << srednia_cal << endl;
	cout << srednia_reszta << endl;

	

	return 0;
}

sum 21
srednia 3
reszta 3 a powinna być 5
Dla sumy 20 działa dobrze.

Że co? Robisz dzielenie 21/6 którego wynikiem jest 3 i 3 reszty, bo 3*6 + 3 = 21. Ty znasz matematykę? o_O

EHEHE LOL, a ja wbiłem sobie że tam ma być ta liczba po przecinku. ; ]
Dobra dzięki za pomoc.

A jak można obliczyć tą liczbę po przecinku ? gdy np. średnia wynosi 12.3452 jak obliczyć tą drugą cześć po przecinku ?

To niestety jest dużo dużo trudniejsze bo musisz użyć do tego obliczeń na FPU. Poczytaj co to koprocesor i jak sie z niego korzysta. Tzn oczywiście z twojego punktu widzenia moze to wcale trudniejsze nie być, ot napiszesz

fild [sum] 
fild [N]
fdiv
fstp [wynik]

Ale generalnie jest to dość skomplikowana sprawa.

Za deklarowałem wynik jako float ale nie działa mi to dziwne liczby wychodzą, tylko to co teraz napisałeś powinno mi zwrócić od razu dobra średnia ? jak tak to ja mogę użyć to do obliczenia tej zmiennej po przecinku podając

fild[srednia_reszta]
			fild[k] 
			fdiv
			fstp[wynik] 

fild[N] -> zmieniłem na k bo z N miałem błąd: "error C2415: improper operand type"
"

Przykro mi ale ode mnie nie dostaniesz ani jednej podpowiedzi więcej póki nie zaczniesz się tego UCZYĆ. Bo póki co to stosujesz metodę prób i błędów sklejając gotowce na chybił trafił. Tak sie nie da. Gdybyś poświecił 3 minuty na doczytanie w dokumentacji jaka jest składnia każdej z tych komend i jak działaja to byś wiedział jak to zrobić. Ale nie, lepiej na pałe zmieniać losowe znaki i może coś zadziała. Szkoda słów...

#include <iostream>

using namespace std;

#define N 100000000
const unsigned long k = N;
unsigned long sum = 2242603935;
float wynik;


int main()
{
	__asm{
		
			fild[sum]
			fild[k]
			fdiv
			fstp[wynik]
	};

	cout << wynik << endl;
	return 0;
}

 

Działa dobrze, ale akurat dla tej liczby nie działa poprawnie bo wynikiem jest -20,5236 a powinno być 22,426.
Poczytałem trochę, wiem że tą moją liczbę całkowitą przekształca na rzeczywista i umieszcza na stosie zmiennoprzecinkowym tylko że zmienna sum wrzuca z minusem.
Ed2. Dobra już wiem, wychodzę po zakres(-2147483648 ÷ 2147483647) przy większych wrzuca mi z minusem.
Ed3. W razie czego jakbyś chciał coś napisać to na razie nic nie pisz, sam spróbuje to zrozumieć. ; ]
Ed4. Wychodzi na to, że te polecenia na koprocesor nie interpretują unsigned jak przekroczę dany próg.