Assembler'ные вставки и goto

[netrino]

Сообщение от nacgull

Для общего случая да (где много команд ассемблера), но у нас адрес передается в регистр корректно через C++ стандартную переменную _EAX. Если применить макрос (зачем одно и тоже прописывать много раз?) - это будет только в одном месте проги - вероятность ошибки мала.

Ну, вообще говоря, _EAX, по всей видимости, стандарт только для билдера. Ну да ладно, для простоты опустим несовместимости между компиляторами, предположим что мы пишем только на билдере под 32-х битную виндовс

Сообщение от nacgull

Адрес метки можно получить скажем так - ничего ассемблерного:

Metka_1: int Label( (int)&Label );    
 ... // код юзера для метки
.
.
.
Metka_2: int Label = (int)&Label_2;
 ... // код юзера для метки

Весьма сомнительный способ, с учётом того, что все переменные в любом случае будут размещены в стеке, то есть максимум чего мы можем добиться это адрес текущего стекового фрейма, но никак не адрес метки.

Сообщение от nacgull

Слышал о таком, но руки пока не дошли до изучения. Можете в двух словах растолковать? Как я понимаю, речь идет об интерфейсе объекта?

Интерфейс - это некий протокол взаимодействия между объектом и пользователем. Хорошим примером применения интерфейсов есть технология COM, можете почитать на досуге, помню видел на эту тему хорошую статью, где очень подробно всё рассматривалось, но сейчас не вспомню где и как она называлась. Вкратце, мы можем сказать, что некий класс реализует какой-то интерфейс и потом, обладая лишь сигнатурой этого интерфейса работать с объектом класса, реализующего этот интерфейс, например:

class Interface { 
/* C++ не имеет полноценной поддержки интерфейсов, потому они 
    реализуются через чисто абстрактные классы */
public:
    virtual void showMessage(const char*) = 0;
    virtual ~Interface() { }
};

class MsgBox : public Interface {
public:
    void showMessage(const char* message) {
        MessageBoxA(0, message, "", MB_OK);
    }
};

class Console : public Interface {
public:
    void showMessage (const char* message) {
        std::cout << message << std::endl;
    }
};

/* Мы объявили два класса, реализующий интерфейс Interface.
    Теперь мы можем обратится к ним через интерфейс и попросить вывести некое сообщение */
int main()
{
    Interface* msgr = new Console;
    
    msgr->showMessage("Show in console");
    delete msgr;
    
    msgr = new MsgBox;
    
    msgr->showMessage("Show in MessageBox");
    delete msgr;
    return 0;
}

Естественно и Console и MsgBox могут при этом находится в DLL. Ясное дело, придётся завести метод, который будет создавать и возвращать указатель на объект в самой DLL. Да и тут иначе никак )

[nacgull]

Сообщение от coNsept

Доброго времени суток уважаемые форумчане!

У меня возник такой вопрос, на который я так и не нашел не одного ответа в googl'e.

Можно ли при помощи ассемблерных вставок, переместиться на какой-то отрезок кода, примерно так.

void main()
{
    // Тут что-то типа метки
    printf("Hello world!");
    _asm
    {
        jmp МЕТКА 
    }
}

Идея думаю понятна, не знаю можно ли вообще такое, просто не очень хочется использовать goto...

За ранее благодарен за любую помощь

Кое-что всё же есть, продемонстрирую некоторые возможности компилятора C++.
Автору темы, думаю, такое очень понравится, но отход от "линии партии" ему, наверно, не простят .
Можно использовать в рекурсивных алгоритмах, для теоретического интереса, студентам в лабораторной изучения компилятора или хакерских упражнений (за зацикливание релиз-версии программы и выгорание компа ответственности не беру ).
Реализовано и протестировано на C++ Builder 2009, 32 bit WindowsXP Prof 2002 rus sp2, CPU Celeron II 1100 MHz.

Для начала посмеёмся над простотой реализации :

int Abc = 123;
char Char = '9';

		Abc = (int)Char;   //код юзера
Metka:	Char = '0';        //код юзера
		Abc = (int)Char;   //код юзера

asm  jmp Metka;   //автору темы наверно пора признать, что ступил не один раз ;)

можно и так:

int AbC = 123;
char ChaR = '9';

int h = 0;

Metka0:	AbC = (int)ChaR;   //код юзера
		ChaR = '0';        //код юзера
		AbC = (int)ChaR;   //код юзера

Metka1: AbC = (int)ChaR;   //код юзера
		ChaR = '1';        //код юзера
Metka2:	AbC = (int)ChaR;   //код юзера

h++;

if(h == 1)
			asm  jmp Metka1;

asm  jmp Metka2;

усложним:

int AbC = 123;
char ChaR = '9';

int h = 0;

Metka0:	AbC = (int)ChaR;   //код юзера
		ChaR = '0';        //код юзера
		AbC = (int)ChaR;   //код юзера
Metka1: AbC = (int)ChaR;   //код юзера
		ChaR = '1';        //код юзера
Metka2:	AbC = (int)ChaR;   //код юзера

h++;

if(h == 1)
{
			ChaR = '2';        //код юзера
MetkaX:		AbC = (int)ChaR;   //код юзера
			asm  jmp Metka1;
}
		AbC = (int)ChaR;   //код юзера
		ChaR = '3';        //код юзера
		AbC = (int)ChaR;   //код юзера

if(h == 8)
			asm  jmp Metka3;

		ChaR = '4';        //код юзера

asm  jmp MetkaX;  // goto MetkaX;

Metka3:	AbC = (int)ChaR;   //код юзера
		ChaR = '5';        //код юзера
		AbC = (int)ChaR;   //код юзера

И немного пофилософствуем:

//================== main.h ==============================

void GetLabel(int* pLabel)
{
	_asm
	{
		mov ebx, [esp+8]    //берем со стека адрес возврата функции
		inc ebx            // корректируем на 1 байт
	}
	*pLabel = _EBX; //*pLabel = _EAX;  -так не получится, переменная _EAX портится
}

int RetGetLabel()
{
	__asm
	{
		mov eax, [esp+4]    //берем со стека адрес возврата функции
		add eax,11            // корректируем на 11 байт
	}
	return _EAX;
}

//====================== main.cpp ========================
int Metka_ ;
register int _Metka_2;

int Abc_ = 123;
char Char_ = '9';


GetLabel(&Metka_);         //размещаем непосредственно перед меткой
Metka_:     Abc_ = (int)Char_;   //код юзера
		Char_ = '0';         //код юзера
		Abc_ = (int)Char_;   //код юзера

_Metka_2 = Metka_;

static const int _Metka_A( RetGetLabel() );  //хранитель адреса метки  Metka_A, размещаем непосредственно перед меткой
Metka_A:	        Abc_ = (int)Char_;   //код юзера
			Char_ = '1';         //код юзера
			Abc_ = (int)Char_;   //код юзера


asm  jmp _Metka_2; // прыжок на  Metka_2:

//--------- возможные варианты --------------------------------
asm  jmp  Metka_; // прыжок на  Metka_:

asm  jmp  _Metka_A;  // прыжок на  _Metka_A:

_EBX = Metka_;		asm  jmp ebx ; // прыжок на  Metka_:

_EBX = _Metka_2; 	asm  jmp ebx ; // прыжок на  _Metka_2:

asm  mov ebx,_Metka_2 ;	asm  jmp ebx ;  // прыжок на  _Metka_2:

		//или макрос
#define  jmp( varLabel )          asm  jmp varLabel; //определение универсального макроса
jmp( Metka_ )  // прыжок по адресу через Metka_

goto Metka_;  //компилятор такое не везде примет

[coNsept]

asm jmp Metka; //автору темы наверно пора признать, что ступил не один раз

Как бы я и в самом начале признал, что немного тупонул, да и время было уже довольно позднее, что думаю простительно :D
А вообще собственно nacgull большой пасяб