恩。看了楼上两位,我认识到了,的确能实现。

我不认为能实现，除非固定输入数字的位数

如果要保证编译后没有条件跳转指令,那么即使实现也是位数受限制的,要实现字符串逆序就无法实现.
其实本不必限制在汇编层上,利用&&或||做条件,递归做循环就能符合楼主的要求.

Try compile the following code under VS2005, with /W4 warning level,for x86

逆序输出16进制和10进制数，不能使用循环和If，无非是更麻烦一些而已：

// reverse 0x89ABCDEF to 0xFEDCBA98

VOID SwapIt( LPBYTE b1, LPBYTE b2 )
{
    BYTE b = *b1;
    *b1 = (*b2)<<4 + (*b2)>>4;
    *b2 = b<<4 + b>>4;
}

HRESULT ReverseInt_Hex( LPDWORD pInt, LPDWORD pdwResult )
{
    DWORD   i = 0;
    LPBYTE  p = NULL;
/*
    if( NULL == pInt )                  well, since we CANNOT use if, assume the parameter is valid here
        return E_INVALIDARG;
*/
    i = *pInt;
    p = (LPBYTE) &i;

    SwapIt( p[0], p[3] );
    SwapIt( p[1], p[2] );
    *pdwResult = i;
    return S_OK;
}

// since 0xFFFFffff = 4294967295, there are 10 digits at most for a decimal unsigned integer
// e.g. reverse 12345678 to 87654321

HRESULT ReverseInt_Decimal( LPDWORD pInt, LPDWORD pdwResult )
{
    DWORD   i = 0;
    DWORD   j = 0;
    BYTE    k[10] = {0};                                    // stores the digits, from left to right
/*
    if( NULL == pInt )                  again, we trust you, man :-)
        return E_INVALIDARG;
*/
    i = *pInt;
    k[0] = i / 1000000000;    j = i - k[0] * 1000000000;
    k[1] = j /  100000000;    j-= k[1] * 100000000;
    k[2] = j /   10000000;    j-= k[2] * 10000000;
    k[3] = j /    1000000;    j-= k[3] * 1000000;
    k[4] = j /     100000;    j-= k[4] * 100000;
    k[5] = j /      10000;    j-= k[5] * 10000;
    k[6] = j /       1000;    j-= k[6] * 1000;
    k[7] = j /        100;    j-= k[7] * 100;
    k[8] = j /         10;    j-= k[8] * 10;
    k[9] = j;

    *pdwResult = k[9] * 1000000000 +
                 k[8] * 100000000  +
                 k[7] * 10000000   +
                 k[6] * 1000000    +
                 k[5] * 100000     +
                 k[4] * 10000      +
                 k[3] * 1000       +
                 k[2] * 100        +
                 k[1] * 10         +
                 k[0];
    return S_OK;
}

看我这个,我写的strrev,表面上没有判断指令的,使用了循环,但是还是没有使用jmp 而是用push ret,这样至少在心里上好受点,因为没有循环的世界和没有if的世界一样不好受,除非你的内存可以无限的大,我的例子中没有使用if指令,而是使用了%来判断字串结束否,其实也是一种if,但是很不明显而已,没有长度限制
void  __declspec(naked) __stdcall mystrrev(const char*        p_str)
{
        __asm
        {
                mov     eax,dword ptr [esp+4]
                pushad
                pushfd
                push        eax
                call        l_kernel
                pop                eax
                popfd
                popad
                retn        4
l_kernel:
                mov     edi, dword ptr [esp+4]
                xor     eax, eax
                mov     ecx, -1
                repne   scas byte ptr es:[edi]
                neg     ecx
                dec     ecx
                dec     ecx
                mov     eax, ecx
                xor     edx, edx
                mov     ebx, 2
                div     ebx
                add     edx, eax
                mov     ebx, edx
                call    l_Loop
                retn
                dec     ebx
l_Loop:
                xor     edx, edx
                mov     eax, 1
                div     ebx
                mov     esi, dword ptr [esp+8]
                mov     al, byte ptr [ecx+esi-1]
                neg     ecx
                mov     ah, byte ptr [ecx+edi-1]
                mov     byte ptr [ecx+edi-1], al
                neg     ecx
                mov     byte ptr [ecx+esi-1], ah
                dec     ecx
                mov     esi, dword ptr [esp]
                add     esi, edx
                push    esi
                retn
        }

}
int _tmain(int argc, _TCHAR* argv[])
{
        char p_sTest[] = "123456789abcdefghijklmnopqrstuvwxyz";
        puts(p_sTest);
        mystrrev(p_sTest);
        puts(p_sTest);
        gets(p_sTest);
        return 0;
}

TC 2.0 pass

#include <stdio.h>
void pp()
{char c;
if((c=getch())!=27)
{printf("%c",c);
pp();
printf("%c",c);}
else
{printf("\n\r");}
}
void main()
{pp();}

用28楼dwing的方法改了上面的代码

#include <stdio.h>
int pp()
{char c;
(
((c=getch())!=27)
&&
(printf("%c",c)|pp()|printf("%c",c))
)
||
(printf("\n\r"));
return 1;
}
void main()
{pp();
getch();}