C/C++不使用循环输出1~1000
今天突然想到 C/C++ 不用循环输出 1 ~ 1000 的数，发现还是很有意思的。

虽然资料是我整理的，但是由于大部分代码都是抄的，所以还是贴成转载吧

文章目录
C/C++不使用循环输出1~1000
不使用循环
使用递归
使用 goto
不使用循环和条件语句
宏
模板
逻辑判断
另一种逻辑判断
构造函数
使用迭代器
使用生成器
使用函数地址

不使用循环
使用递归
#include <stdio.h>
#include <stdlib.h>

void print(){
    static int i = 0;
    if(i < 1000) printf("%d ", i);
    else exit(EXIT_SUCCESS);
    ++i;
    print();
}

int main(){
    print();
    return 0;
}

使用 goto
#include <stdio.h>
#include <stdlib.h>

int main(){
    int i = 0;
print:
    if( i >= 1000) goto exit;
    printf("%d ",i++);
    goto print;
exit:
    return 0;
}


不使用循环和条件语句
宏
#define A(x) x;x;x;x;x;x;x;x;x;x;
int main(){
    int i = 1;
    A(A(A(printf("%d ", i++))));
    return 0;
}

这个方法是网上找到的，不知道为什么网上转载的宏定义都不完整。
A(x) 等于是连续执行 10 次 x 代表的语句。A(A(A())) 等于是连续嵌套三次，执行 $10^3$ 次 x 代表的语句。
模板
使用 C++ 的模板也可以实现这个东西，而且还不需要用到条件语句

也就是一个模板的迭代和特化，算是比较基础的东西
#include <iostream>
using std::cout;

template <int i>
void print(){
    print<i-1>();
    cout<<i<<' ';
}

template <>
void print<0>(){
    cout<<0<<' ';
}

int main(){
    print<1000>();
    return 0;
}

不过我在编译的时候发现默认情况下 GCC 最多只能迭代 900 个，CLang++ 最多可以迭代到 1024 个。（倒是 Clang 还凑个整数）

100 个时生成的文件是 29 K

1000 个生成的文件是 143 K

逻辑判断
void f2(int N)
{
    N && (f2(N-1), cout << N << ' ');
}

另一种逻辑判断
void yesprint(int i);
void noprint(int i);

typedef void(*fnPtr)(int);
fnPtr dispatch[] = { noprint, yesprint };

void yesprint(int i) {
    printf("%d ", i);
    dispatch[i < 1000](i+1);
}

void noprint(int i) { /* do nothing. */ }

int main() {
    yesprint(1);
    return 0;
}

构造函数
class A {
public:
    A() {
        static int N = 1;
        cout << N++ << ' ';
    }
};
int main() {
    new A[1000];
   return 0;
}

使用迭代器
#include <iterator>

class number_iterator{
    int value;
public:
    typedef std::input_iterator_tag iterator_category;
    typedef int                     value_type;
    typedef std::size_t             difference_type;
    typedef int*                    pointer;
    typedef int&                    reference;
    number_iterator(int v): value(v){}
    bool operator!=(number_iterator const& rhs){
        return value != rhs.value;
    }
    number_iterator operator++(){
        ++value;
        return *this;
    }
    int operator*(){
        return value;
    }
};

int main()
{
    std::copy(number_iterator(1),
              number_iterator(1001),
              std::ostream_iterator<int>(std::cout," "));
}

使用生成器

int num() {
    static int i = 1; return i++;
}
int main() {
    generate_n(ostream_iterator<int>(cout," "), 1000, num); 
}

使用函数地址
#include <stdio.h>
#include <stdlib.h>

void main(int j) {
  printf("%d ", j);
  (&main + (&exit - &main)*(j/1000))(j+1);
}

这个现在只能 在 C 下面编译。

j 在初始时被赋值为1
j < 1000 时， (j/1000) 一直是 0，(main + 0)(j+1)一直在递归调用 main()
当 j == 1000, j/1000 == 1,第二行代码就变成了 (main + exit - main) = exit，整个代码就变成了调用 exit(1001)

但是退出代码最高是255,更高的退出代码是对 256 求模算出来的， 1001%256 = 233。因此，在 shell 输入 echo $? 会发现它的退出代码是233。
这样，我们可以在给出一份 C++ 版本的代码：
typedef int (*PM)(int);

int main(int j) {
    cout<<j<<' ';
    long addr = (long)main + ((long)exit - (long)main)*(j/1000);
    ((PM)addr)(j+1);
}

啧啧,一行行的强制类型转换，C++虽然变得更安全了，但是也更麻烦了。Rust 应如是

还有一些其他的方法，这里不再一一放出：
不用循环，不用递归，输出1到100的整数

关于c ++：在没有循环或条件的情况下打印1到1000

输出从1到1000的数

linux退出状态码及exit命令
代码是转载的，但是内容是我自己写的。。。

原文链接随便填一个吧

1.有一道如下的面试题（事件循环，宏任务微任务）


请先思考一下答案

倒计时开始

3

2

1

正确答案：

1，2，3，7，5，4，6

是不是和你想的一样呢 （如果和你想的一样，大佬请直接Ctrl+F4）

下面我们来分析一下为什么会这样输出
2.单线程

首先我们都知道，JavaScript是一门单线程的语言，所谓单线程指的是在JavaScript引擎中负责解释和执行代码的线程只有一个，通常称为主线程。那么问题来了，js为什么不能是多线程的
因为这是js所运行的浏览器环境决定的，他只能是单线程的。可以想一下，如果js可以开启多个线程，页面上有一个dom，我们同时在多个线程上面修改这一个dom，那这个dom会以哪个线程为准，最后会成什么样子，这样的话整个都乱了，但是虽然js不能开启多个线程，但是人家有任务队列呀！！！

3.任务队列 (task queue)

所有的任务都可以分为同步任务和异步任务，

同步任务，顾名思义就是在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务。


异步任务，就是不进入主线程、而进入"任务队列"（task queue）的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。


异步任务的运行机制如下
（1）所有同步任务都在主线程上执行，形成一个执行栈

（2）主线程之外，还存在一个"任务队列"（task queue）。只要异步
任务有了运行结果，就在"任务队列"之中放置一个事件。

（3）一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，
看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入
执行栈，开始执行。

（4）主线程不断重复上面的第三步。



4.事件和回调函数

任务队列是一个事件的队列（也可以理解成一个消息的队列）
任务队列还包括鼠标点击，页面滚动等，只要指定回调函数，这些事件发生时，就会进入任务队列，等待主线程的读取
所谓回调函数（callback）就是会被主线程挂起来的代码，异步任务必须指定回调函数，异步任务执行完成，会通知回调函数，从而让回调函数做出某些操作
任务队列是一个先进先出的数据结构，只要执行栈一空，主线程就会去任务队列里面读取排在最前面的事件

5.事件循环（Event Loop）

主线程从任务队列中读取事件，这个过程是循环不断的，所以又称事件循环（Event Loop）

这图网上有很多哈，所以我就直接拿过来用了

下面我们来讲解一下这个图


js在执行的时候会产生堆（heap）和栈（stack），栈中代码会调用各种外部api，
他们在 `任务队列` 中加入各种事件（onClick，onLoad， onDonc），
栈中代码一但为空就会去检查 `任务队列`，如果 `任务队列` 中有待执行的事件，
则依次执行这些事件，这个过程是不断重复的

6.微任务 宏任务

如果任务队列中有多个异步任务，那么先执行哪个任务呢？于是在异步任务中，也进行了等级划分，分为宏任务（macrotask）和微任务（microtask）；不同的API注册的任务会依次进入自身对应的队列中，然后等待事件循环将它们依次压入执行栈（即主线程）中执行。

宏任务包括： script(整体代码) setTimeout, setInterval, setImmediate, I/O UI rendering


微任务包括：process.nextTick，Promise.then catch finally，Object.observe(已废弃)，MutationObserver(html5新特性)

我们可以把整体的JS代码也看成是一轮宏任务，主线程也是从宏任务开始的。
我们来看一下宏任务，微任务的流程图


解析上图

执行一轮宏任务
执行过程中如果遇到微任务就加入微任务队列，遇到宏任务就加入宏任务队列
下一轮宏任务开始之前，检查当前微任务队列，如果有，就依次执行（一轮事件循环结束）开始下一轮宏任务
开始下一轮宏任务

现在我们回到刚开始的面试题


js开始执行（宏任务开始）
从上往下执行，先区分一下宏任务和微任务
宏任务（第45，46，50，51，57，61行）
微任务（第54行）
注意js是从上往下执行的，所以先打印1
Promise在new的时候会先执行内部代码，所以第二个打印2
js主线程此时走到第50行，50行为宏任务，直接打印3
setTimeout是个异步宏任务，压入任务队列，等待主线程空出执行（注意，此时setTimeout没有设置执行时间，代表着主线程一但空出，就立马执行setTimeout）此时，js的主线程还没有空出来
js走到第50行，Promise.then是一个微任务，放入微任务队列，等待下一轮宏任务开始之前执行
57行 同理第8条
js走到61行，直接打印7
此时第一轮宏任务执行完毕，第二轮宏任务准备开始执行，在执行前去看看微任务队列有没有事件，哎？有！那我就先执行微任务打印5
微任务队列执行完毕之后，第二轮宏任务开始执行，去事件队列里面把两个setTimeout捞出来，按照先进先出原则，先执行打印4，在执行打印6
第二轮宏任务执行结束，第三轮宏任务准备开始，开始前依旧去检测微任务队列有没有微任务，此时是没有微任务的，所以准备开始执行第三轮宏任务
此时的js主线程（宏任务）是空的，去任务队列里面检测，也是空的，执行完毕，停止执行
所以结果打印1，2，3，7，5，4，6

结尾
希望大家看了本篇文章都有收获 …
如果文章有什么不对的地方，请斧正，感谢大家
新手一个，大佬勿喷，感谢
        
转载请注明出处，再次感谢

问题描述：借助于宏定义来读for循环输出结果。

程序源码：

#include "stdio.h"
#define M 5
void main()
{int a[M]={1,2,3,4,5};
int i,j,t;
i=0;j=M-1;
while(i {t=*(a+i);
*(a+i)=*(a+j);
*(a+j)=t;
i++;j--;
}
for(i=0;i printf("%d",*(a+i));
}

 

喜欢排队吧，它能保护你的时间和精力 - 排队纪律维护员Event Loop
Promise和事件循环概览图
请注意上面这张图，Promise和事件循环的那些事，将在这个图上缓缓展开。
微任务和(宏)任务
好了，(经过上一节对Promise的理解)现在我们对如何创建Promise以及如何从Promise中获取值多了一些了解。让我们在script中添加更多的代码，然后再次运行它：
等等，发生了什么？！
首先，输出了"Start!"。好吧，显而易见的：console.log('Start!') 就在第一行！但是，输出的第二个值是"End！"而不是Promise的值！只有在"End！"输出后，Promise的值才被输出。这是怎么回事？
我们终于见识到Promise的真正力量！虽然JavaScript是单线程的，但是我们可以使用Promise添加异步行为！
但是稍等一下，我们以前不是见过了吗？在JavaScript事件循环中(「翻译」JavaScript的可视化学习之一：事件循环)，我们不也可以使用浏览器的本地方法(如setTimeout)来创建某种异步行为吗？
没错！但是，在事件循环中，实际上有两种类型的队列：(宏)任务队列(或简称为任务队列)：(macro) task queue 和微任务队列：microtask queue。(宏)任务队列用于(宏)任务，微任务队列用于微任务。
那么什么是(宏)任务，什么是微任务呢？下面表格罗列了一些最常用的！
(Macro)task： 
setTimeout
 setInterval
setImmediate
Microtask：
process.nextTick 
Promise callback
queueMicrotask
啊，我们在微任务列表中看到了Promise！当Promise处理并调用其then()、catch()或finally()方法时，该方法内的回调将添加到微任务队列中！这意味着then()、catch()或finally()方法中的回调不会立即执行，这实际上是在我们的JavaScript代码中添加了一些异步行为！
那么then()、catch()或finally()回调函数在什么时候执行呢？事件循环为任务设定了不同的优先级：
1、当前在调用堆栈中的所有函数被执行，当它们返回一个值时，它们将从堆栈中弹出。
2、当调用堆栈为空时，所有排队的微任务将一个接一个的弹出到调用堆栈中，并执行！(微任务本身也可以返回新的微任务，实际创建了一个无限的微任务循环)
3、如果调用堆栈和微任务队列都为空，则事件循环将检查(宏)任务队列中是否还有任务。如果有，任务被弹出到调用堆栈，执行，然后弹出调用堆栈！
让我们看一个简单的例子，简单地使用：
Task1: 一个立即添加到调用堆栈中的函数，例如在代码中立即调用它。
Task2, Task3, Task4: 微任务，例如一个Promise的then回调，或使用queueMicrotask添加的任务。
Task5, Task6: (宏)任务，例如setTimeout或setImmediate回调。
首先，Task1返回一个值并从调用堆栈中弹出。然后，引擎检查微任务队列中排队的任务。一旦所有任务都被放入调用堆栈并最终弹出，引擎将检查(宏)任务队列中的任务，任务将弹出到调用堆栈中，并在它们返回值时弹出。
好吧，好吧，粉色盒子够多了。让我们用一些真正的代码来使用它！
console.log('Start!')setTimeout(() => {console.log('Timeout!')}, 0)Promise.resolve('Promise').then(res => console.log(res))console.log('End!')
在这段代码中，我们有宏任务setTimeout和微任务Promise的 then()回调。定位到setTimeout函数的行，让我们一步一步地运行这段代码，看看会输出了什么！
小提示 - 在下面的示例中，我展示了如下方法console.log，setTimeout和Promise.resolve，他们被添加到调用堆栈中。它们是内部方法，实际上不会出现在堆栈跟踪中 — 因此，如果您正在使用调试器并且在任何地方都看不到它们，请不要担心！这么做只是为了让解释这个概念更容易，而不需要添加一堆示例代码。
在第一行，引擎遇到console.log()方法。它被添加到调用堆栈中，然后输出"Start！"到控制台。方法从调用堆栈中弹出，引擎继续运行。
引擎遇到setTimeout方法，该方法被弹出到调用堆栈中。setTimeout方法是浏览器的本地方法：它的回调函数(() => console.log('In timeout')) 将被添加到Web API中，直到计时器完成。虽然我们为计时器提供了值 0，但是回调仍然会首先被推送到Web API，之后它会被添加到(宏)任务队列中：setTimeout是一个宏任务！
引擎遇到Promise.resolve()方法。这个Promise.resolve()方法被添加到调用堆栈中，之后处理并返回"Promise！"。然后它的then回调函数被添加到微任务队列中。
引擎遇到console.log()方法。它会立即添加到调用堆栈中，然后输出"End！"到控制台，从调用堆栈中弹出，引擎继续运行。
引擎发现调用堆栈现在是空的。由于调用堆栈是空的，它将检查微任务队列中是否有排队的任务！是的，Promise的then回调正在等待！它被弹出到调用堆栈中，然后输出Promise的值：在这里是字符串"promise！"。
引擎发现调用堆栈是空的，因此它将再次检查微任务队列，以查看是否有排队的任务。不，微任务队列都是空的。
是时候检查(宏)任务队列了：setTimeout回调仍在那里等待！setTimeout回调被弹出到调用堆栈。回调函数返回console.log方法，该方法输出字符串“In timeout！”。setTimeout回调从调用堆栈中弹出。
终于，一切都完成了！现在看来我们之前看到的输出结果并不是那么出乎意料。
翻译来源：https://dev.to/lydiahallie/javascript-visualized-promises-async-await-5gke