ассемблерная вставка

[f.hump]

class A {
private:
	static const int AWX = 3;
	static const int AHY = 5;
	int a[AWX][AHY];

public:
	A() {

		for (int i(0);i<AWX;i++)
                         for(int j(0);j<AHY;j++) a[i][j] = rand();

	}

	int Calc(int i, int j)
	{
		__asm {
                           PUSH esi
                           PUSH ebx

                           MOV esi, ecx
                           ADD esi, A::a

                           XOR edx, edx
                           MOV ecx, [i]
                           MOV eax, A::AHY
                           SHL eax, 2
                           MOV ebx, eax
                           MUL ecx
                           ADD esi, eax

                           MOV ecx, [j]
                           SHL ecx, 2
                           XOR eax, eax
                           ADD esi, ecx

                           ADD eax, [esi-4]
                           ADD eax, [esi+4]

                           ADD eax, [esi+ebx]
                           SUB esi, ebx
                           ADD eax, [esi]

                           SAR eax, 2
                           ADD eax, 1

                           POP ebx
                           POP esi
		}

	}

};

void main()
{
	A a;
	printf("%d\r\n", a.Calc(1, 3));

}

типа так

[Somebody]

Сообщение от f.hump

                           ADD eax, [esi+edx-ebx]

fail... double fail...

[Vort]

Сообщение от f.hump

		__asm {
                           PUSH esi
                           PUSH ebx

это, кстати, делать не обязательно
компилятор сам в состоянии понять какие регистры надо сохранить
(если, конечно, не делать naked функцию)

[f.hump]

2Vort
ассемблерная вставка в VS, это ассемблерная вставка в VS.
и по личному опыту компилятор себя сильно не утруждает в плане сохранения регистров, используемых во вставке. возможно, это к лучшему, и возможно, по этой причине вставки не поддерживаются для 64-х битного кода.

[Vort]

а вот вариант, подсказанный самим компилятором

// VS2010
#include <stdio.h>
#include <memory.h>

#define AWX 3
#define AHY 5

class A
{
public:
	int i, j, s;
	int a[AWX][AHY];

public:
	A()
	{
		i = 1;
		j = 3;
		s = -1;

		memset(a, 0x00, AWX * AHY * 4);

		a[i][j-1] = 4000;
		a[i-1][j] = 800;
		a[i+1][j] = 120;
		a[i][j+1] = 12;
	}

	void __thiscall Calc();

	void Print()
	{
		printf("%d\r\n", s);
	}
};

__declspec(naked) void __thiscall A::Calc()
{
	__asm
	{
		push eax
		push edx
		mov  edx, [ecx + A::i]
		imul edx, edx, AHY
		add  edx, [ecx + A::j]
		mov  eax, [ecx + A::a + edx * 4 - 1 * 4]
		add  eax, [ecx + A::a + edx * 4 + 1 * 4]
		add  eax, [ecx + A::a + edx * 4 - 4 * AHY]
		add  eax, [ecx + A::a + edx * 4 + 4 * AHY]
		sar  eax, 2
		inc  eax
		mov  [ecx + A::s], eax
		pop  edx
		pop  eax
		ret
	}
}

void main()
{
	A a;
	a.Calc();
	a.Print();
}

[Веди]

всем спасибо, буду пробовать!