void TheCallingFunction(void)
{
 cout<<"Funktion wurde aufgerufen"<<endl;
}
unsigned long BerechneOffset(unsigned long absprungaddr,unsigned long Zieladdr)
{
 unsigned long sprungweite=0;
 absprungaddr+=5;//Da der Assembler jump Befhel von bytes groß ist 
//und der Compiler erst nach diesen 5 bytes springt
sprungweite=Zieladdr-absprungaddr;
 return sprungweite;
}
int main(int argumentvalue,char **arguments)
{
unsigned char *Saveplace=new unsigned char[5];
//5 Bytes reservieren
//1 byte = jump binär ist 0xE9 =1 Byte
//4 Byte für unsigned long Sprungweg
unsigned long sprungweg=BerechneOffset((unsigned long)Saveplace,(unsigned long)&TheCallingFunction);
//Sprungweite berechnen
unsigned char JmpByte=0xE9;
_asm
 {
[asm]
 mov ebx,Saveplace ; In Register ebx die Addresse vom reservierten Speicher schreiben
 mov al,[JmpByte] ; In das low byte von eax den Inhalt von JmpByte schreiben =0xE9
 mov [ebx],al ; Das Low Byte kopieren und den Wert welcher an der Addresse von ebx steht ersetzen
 add ebx,1 ; die Addresse welche auf die ebx zeigt um eins erhöhen
 mov eax,[sprungweg] ; Inhalt von Sprungweg nach eax kopieren
 mov [ebx],eax ; eax in den Inhalt von ebx kopieren
 jmp Saveplace ; Springe zur Addresse an der der geschriebene Code steht
[/asm]
 }

system("Pause");
return 0;
}
Sofort nach jmp stützt das Programm ab die Funktion wird nicht aufgerufen

MfG

Edit: Hab mal bei meinen alten Sachen gesucht und etwas Vergleichbares gefunden:

#include <iostream>
#include <windows.h>

#pragma optimize( "", off )

#pragma pack( push, 1 )
typedef struct myMessageBoxA
{
	BYTE push_address_1;
	BYTE arg_1;

	BYTE push_address_2;
	DWORD address_2;

	BYTE push_address_3;
	DWORD address_3;

	BYTE push_address_4;
	BYTE arg_4;

	BYTE call;
	DWORD _MessageBox;

	BYTE ret;
}myMessageBoxA;
#pragma pack( pop )

int main( char* arg, char* arvg[ ] )
{
	char* Text = "Hallo";
	char* Title = "Test";
	DWORD addr = reinterpret_cast< DWORD >( &MessageBoxA );

	myMessageBoxA* MyBox;
	ZeroMemory( MyBox, sizeof( myMessageBoxA ) );

	HANDLE m_pHeap = HeapCreate( HEAP_CREATE_ENABLE_EXECUTE, NULL, NULL );
MyBox = reinterpret_cast< myMessageBoxA* >( HeapAlloc( m_pHeap, NULL, sizeof( myMessageBoxA ) ) );

	addr = addr - reinterpret_cast< DWORD >( MyBox ) - 0x13; //Relativ Call!

	MyBox->push_address_1 = 0x6A;
	MyBox->push_address_2 = 0x68;
	MyBox->push_address_3 = 0x68;
	MyBox->push_address_4 = 0x6A;
	MyBox->arg_1 = NULL;
	MyBox->arg_4 = NULL;
	MyBox->address_2 = reinterpret_cast< DWORD >( Text );
	MyBox->address_3 = reinterpret_cast< DWORD >( Title );
	MyBox->call = 0xE8;

	MyBox->_MessageBox = addr;
	MyBox->ret = 0xC3;

	__asm call MyBox;

	HeapFree( m_pHeap, NULL, MyBox );
	HeapDestroy( m_pHeap );

	std::cout << "Alles hat funktioniert !" << std::endl;

	return 0;
}

#pragma optimize( "", on )

Ich hoffe das hilft dir etwas.