c89、c99、c11

C99 标准开始引入了 // 单行注释。在此之前，C语言只支持 /* ... */ 多行注释。

具体说明：

// 单行注释：在C99标准（ISO/IEC 9899:1999）引入之前，C语言中没有单行注释。C99标准借鉴了C++的注释风格，引入了这种单行注释。
/* ... */ 多行注释：自C语言的早期版本（包括C89和ANSI C）以来就已经存在。

示例：

在C99之前（例如，使用ANSI C标准的编译器）：

int main() {
    /* 这是一个多行注释 */
    int a = 10;
    /* 这是
       一个多行
       注释 */
    return 0;
}

在C99及之后：

int main() {
    // 这是一个单行注释
    int a = 10;
    // 这是另一个单行注释
    return 0;
}

在现代C编译器中（C99及之后），可以混合使用这两种注释：

int main() {
    // 这是一个单行注释
    int a = 10; /* 这是一个多行注释 */
    return 0;
}

总结：

// 单行注释是从C99标准开始引入的。
/* ... */ 多行注释从C语言的早期版本（包括C89和ANSI C）就已经存在。

C89（也称为ANSI C）和C99是两个主要的C语言标准，它们之间有许多显著的区别。以下是一些关键区别及相应的示例：

1. 单行注释

C89：不支持 // 单行注释。
C99：支持 // 单行注释。

示例：

// 这是一个C99支持的单行注释
int a = 10; // 这是一个单行注释

2. 变量声明

C89：变量必须在函数块的开头声明。
C99：变量可以在代码块中的任意位置声明。

示例：

// C89
void example() {
    int a = 10;
    /* 必须在这里声明所有变量 */
    int b = 20;
    a = a + b;
}

// C99
void example() {
    int a = 10;
    a = a + 10;
    int b = 20; // 可以在任意位置声明变量
    a = a + b;
}

3. 复合字面量

C89：不支持复合字面量。
C99：支持复合字面量。

示例：

// C99
struct Point {
    int x, y;
};
struct Point p = (struct Point){.x = 1, .y = 2}; // 复合字面量

4. 变长数组

C89：不支持变长数组。
C99：支持变长数组。

示例：

// C99
void example(int n) {
    int arr[n]; // 变长数组
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }
}

5. 内联函数

C89：不支持 inline 关键字。
C99：支持 inline 关键字。

示例：

// C99
inline int add(int a, int b) {
    return a + b;
}

6. 数据类型扩展

C89：没有 long long 数据类型。
C99：引入了 long long 数据类型（至少64位）。

示例：

// C99
long long bigNumber = 123456789012345LL;

7. `func` 预定义标识符

C89：没有 __func__ 预定义标识符。
C99：引入了 __func__ 预定义标识符，用于获取当前函数的名称。

示例：

// C99
#include <stdio.h>

void example() {
    printf("Function name: %s\n", __func__);
}

8. 初始化增强

C89：初始化结构体和数组时必须按顺序进行。
C99：允许使用指定初始化器（designated initializers）。

示例：

// C99
struct Point {
    int x, y;
};
struct Point p = {.y = 2, .x = 1}; // 指定初始化器

这些示例展示了C99对C89的多方面增强，使C语言变得更为灵活和功能强大。

C11 是 C 语言的一个标准，全称为 ISO/IEC 9899:2011，相对于 C99 进一步引入了一些新特性和改进。以下是 C11 相对于 C99 和 C89 的一些主要区别及相应的示例：

1. `_Generic` 选择表达式

C89/C99：不支持 _Generic 选择表达式。
C11：引入了 _Generic 选择表达式，用于泛型编程。

示例：

// C11
#include <stdio.h>

#define type_of(x) _Generic((x), \
    int: "int", \
    float: "float", \
    double: "double", \
    default: "other")

int main() {
    int i = 0;
    float f = 0.0;
    printf("i is %s\n", type_of(i)); // 输出：i is int
    printf("f is %s\n", type_of(f)); // 输出：f is float
    return 0;
}

2. 匿名结构体和联合体

C89/C99：不支持匿名结构体和联合体。
C11：支持匿名结构体和联合体。

示例：

// C11
struct {
    union {
        int i;
        float f;
    };
} u;

int main() {
    u.i = 10;
    printf("%d\n", u.i); // 输出：10
    u.f = 5.5;
    printf("%f\n", u.f); // 输出：5.500000
    return 0;
}

3. 静态断言

C89/C99：不支持静态断言。
C11：引入了 _Static_assert 关键字，用于在编译时进行静态断言。

示例：

// C11
#include <assert.h>

_Static_assert(sizeof(int) == 4, "int size is not 4 bytes");

int main() {
    return 0;
}

4. 线程支持

C89/C99：不提供标准化的线程支持。
C11：引入了 threads.h，提供对多线程的标准支持。

示例：

// C11
#include <stdio.h>
#include <threads.h>

int thread_func(void *arg) {
    printf("Hello from thread!\n");
    return 0;
}

int main() {
    thrd_t t;
    thrd_create(&t, thread_func, NULL);
    thrd_join(t, NULL);
    return 0;
}

5. 对齐支持

C89/C99：不提供对齐支持。
C11：引入了 _Alignof 和 _Alignas 关键字，用于指定和查询类型对齐要求。

示例：

// C11
#include <stdio.h>
#include <stdalign.h>

struct S {
    char c;
    _Alignas(16) int i;
};

int main() {
    printf("Alignment of char: %zu\n", alignof(char)); // 输出：1
    printf("Alignment of int: %zu\n", alignof(int)); // 输出：4
    printf("Alignment of struct S: %zu\n", alignof(struct S)); // 输出：16
    return 0;
}

6. 预定义宏

C89/C99：不支持新的预定义宏。
C11：引入了新的预定义宏，例如 __STDC_VERSION__。

示例：

// C11
#include <stdio.h>

int main() {
    #if __STDC_VERSION__ >= 201112L
        printf("C11 or later\n");
    #else
        printf("Before C11\n");
    #endif
    return 0;
}

7. 可选特性宏

C89/C99：不支持可选特性宏。
C11：引入了可选特性宏，例如 __STDC_NO_THREADS__。

示例：

// C11
#include <stdio.h>

int main() {
    #ifdef __STDC_NO_THREADS__
        printf("Threads are not supported\n");
    #else
        printf("Threads are supported\n");
    #endif
    return 0;
}