static void Main(string[] args)
    {
        print(1000);
        System.Console.ReadKey();
    }

    static bool print(int val)
    {
        try
        {
            print( ((val/val)*val) - 1);
            System.Console.WriteLine(val.ToString());
        }
        catch (Exception ex)
        {
            return false;
        }
        return true;
    }

printf("%d\n", 2);
printf("%d\n", 3);

它不会打印所有的数字，但它会“打印从1到1000的数字”。暧昧的问题求赢!：）

我不想破坏它，但递归和循环在机器级别本质上是相同的事情。

区别在于JMP/JCC与CALL指令的使用。两者都有大致相同的周期时间，并刷新指令管道。

我最喜欢的递归技巧是手工编写返回地址的PUSH，并对函数使用JMP。然后函数正常工作，并在结束时返回，但返回到其他地方。这对于更快地解析非常有用，因为它减少了指令管道刷新。

最初的海报可能是一个完整的展开，这是模板的人想出的;或者将页内存放入终端，如果您确切地知道终端文本存储在哪里。后者需要大量的洞察力和风险，但几乎不需要计算能力，并且代码没有像连续1000个打印文件那样的麻烦。

使用递归，可以使用函数指针算术替换条件:

#include <stdio.h>
#include <stdlib.h> // for: void exit(int CODE)

// function pointer
typedef void (*fptr)(int);

void next(int n)
{
        printf("%d\n", n);

        // pointer to next function to call
        fptr fp = (fptr)(((n != 0) * (unsigned int) next) +
                         ((n == 0) * (unsigned int) exit));

        // decrement and call either ``next'' or ``exit''
        fp(n-1);
}

int main()
{
        next(1000);
}

注意，这里没有条件句;n !=0和n==0是无分支操作。(不过，我们在尾部调用中执行了一个分支)。

预处理程序滥用!

#include <stdio.h>

void p(int x) { printf("%d\n", x); }

#define P5(x) p(x); p(x+1); p(x+2); p(x+3); p(x+4);
#define P25(x) P5(x) P5(x+5) P5(x+10) P5(x+15) P5(x+20)
#define P125(x) P25(x) P25(x+50) P25(x+75) P25(x+100)
#define P500(x) P125(x) P125(x+125) P125(x+250) P125(x+375)

int main(void)
{
  P500(1) P500(501)
  return 0;
}

预处理程序(参见gcc -E input.c)非常有趣。

不懂足够的C(++)来写代码，但你可以使用递归而不是循环。为了避免这种情况，可以使用在第1000次访问后抛出异常的数据结构。例如，某种带有范围检查的列表，在每次递归时增加/减少索引。

从评论中判断，c++中似乎没有任何范围检查列表?

相反，你可以用1/n作为递归函数的参数，每次调用都减少1。从1000开始。DivisionByZero异常将停止递归