57段让编译器崩溃的C语言代码

最新推荐文章于 2024-02-29 13:59:12 发布
最新推荐文章于 2024-02-29 13:59:12 发布
阅读量604 收藏
点赞数
分类专栏： C/C++

导读：本文由犹他州大学的计算机系的 John Regehr 整理。

虽然我不清楚到底有多少人喜欢看让编译器崩溃的程序，但这篇文章就是给这些的人（包括我）。我们讨论编译器Bug测试案例的论文就包括很多这种崩溃型的Bug。下文是就是这些 C 语言代码段，由工具逐字输出，代码格式上肯定会有些问题。（代码段后面申明了对应被崩溃的编译器，有读者问为什么没有 MSVC 编译器的，Regehr 回复说他们并没有测试MSVC 。）

看完这些程序，我们就能总结出什么东西吗？这很难说…… 很多 C 语言代码段是不容易看出来有问题，如果了解其中问题，我们需要知道一个特定编译器内部解析代码的细节。

C1 : Crashes Clang 2.6 at -O0:

1
2
3
4
5
6
7
8
9
10
#pragma pack(1)
struct S1 {
   int f0;
   char f2
};
struct {
   struct S1 f0
     }
a[] = { 0 }
       ;

C2 : Crashes Clang 2.6 at -O2:

1
2
3
4
5
6
7
8
9
10
struct S0 {
   int f0:1;
   int f4
}
a;
void
fn1 () {
   struct S0 b[][1][1] = { 0 };
   b[0][0][0] = a;
}

C3 : Crashes Clang 2.6 at -O2:

1
2
3
4
5
6
7
8
9
10
11
12
13
unsigned short a;
int b;
char c;
short
fn1 () {
   return 1 / a;
}
void
fn2 () {
   b = fn1 ();
   char d = b;
   c = d % 3;
}

C4 : Crashes Clang 2.6 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int a, b, c, d, e;
#pragma pack(1)
struct S0 {
   int f0:14;
   int f1:13;
   int f2:28;
   int f3:23;
   int f4:12
};
void fn1 ( struct S0);
void
fn2 () {
   int f;
lbl_2311:
   ;
   struct S0 g = { 0, 0, 1 };
   fn1 (g);
   b && e;
   for (; c;) {
     if (d)
       goto lbl_2311;
     f = a && 1 ? 0 : 1;
     g.f4 = f;
   }
}

C5 : Crashes Clang 2.6 at -O2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int crc32_context, g_2 = 0, g_5;
int g_8;
int *g_39, *g_371;
int g_81;
int func_1_l_15 ;
static short safe_add_func_int16_t_s_s ( short si1, int si2 ) {
     return si1 > 67 ? si1 : si1 + si2;
   }
 
     static int func_1 (  ) {
     int l_462 = 0;
     g_2 = 0;
     for ( ;
   g_2 < 12;
   g_2 = safe_add_func_int16_t_s_s ( g_2, 5 ) )     {
        g_5 = 1;
        for ( ;
  g_5;
  ++g_5 )    {
       g_8 = 1;
       for ( ;
  g_8 >= 0;
  g_8 = g_8 - 1 )        {
           func_1_l_15 = 1;
           for ( ;
  func_1_l_15;
             func_1_l_15 =   func_1_l_15  - 1  )         if ( g_8 )        break ;
         }
       g_371 = &l_462;
       int *l_128 = &g_81;
       *l_128 = *g_39;
     }
  *g_371 =    0 != 0   ;
      }
     return 0;
   }
    int main (  ) {
     func_1 (  );
     crc32_context = g_2;
     crc32_context += g_5;
   }

C6 : Crashes Clang 2.6 at -O0:

1
2
3
4
5
6
7
8
9
10
11
12
13
#pragma pack(1)
struct S2 {
   int f1;
   short f4
};
struct S3 {
   struct S2 f1;
   int f3:14
};
struct {
   struct S3 f3
     }
a = { 0, 0, 0 };

C7 : Crashes Clang 2.6 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int *a;
static int **b;
int c, d, e;
void
fn1 () {
   d = &b == c;
   for (;;) {
     int **f = &a;
     if (e) {
     } else
       b = f;
     if (**b)
       continue ;
     **f;
   }
}

C8 : Crashes Clang 2.6 at -O1:

1
2
3
4
5
6
7
8
9
10
#pragma pack(1)
struct S0 {
   int f3;
   char f4
};
struct {
   struct S0 f6;
   int f8
}
a = { 0, 0, 0 };

C9 : Crashes Clang 2.6 at -O2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
struct S0 {
   int f0;
   int f1;
   short f3;
   int f7;
   int f8
}
b;
int a, c, d, e, f;
void
fn1 ( struct S0 p1) {
   d++;
   c = p1.f8;
   e = 0;
   a = p1.f7;
}
void
fn2 () {
   e = 0;
   for (; e; e++) {
     if (d)
       for (;;) {
       }
     --f;
   }
   fn1 (b);
}

C10 : Crashes Clang 2.6 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
union U2 {
   int f0;
   unsigned short f2
}
b;
static int a = 1;
void
fn1 ( int p1, unsigned short p2) {
}
int fn2 ( union U2);
union U2 fn3 ();
static unsigned long long
fn5 () {
   fn1 (b.f2, b.f0);
   return 0;
}
static char
fn4 () {
   fn5 ();
   return 0;
}
int
main () {
   a || fn2 (fn3 (fn4 () ) );
}

C11 : Crashes Clang 2.7 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int *a;
static int **b;
int c, d, e;
void
fn1 () {
   d = &b == c;
   for (;;) {
     int **f = &a;
     if (e) {
     } else
       b = f;
     if (**b)
       continue ;
     **f;
   }
}

C12 : Crashes Clang 2.7 at -O0:

1
2
3
4
5
6
7
char a;
unsigned char b;
int c;
void
fn1 () {
   (b ^= c) != a;
}

C13 : Crashes Clang 2.7 at -O2:

1
2
3
4
5
6
7
8
9
int a, b;
void fn1 ();
void
fn2 ( short p1) {
   short c;
   c = (65532 | 3) + p1;
   fn1 (c && 1);
   b = (0 == p1) * a;
}

C14 : Crashes GCC 3.2.0 at -O1:

1
2
3
4
5
6
7
8
void
fn1 () {
   struct S0 *a;
   struct S0 *b, *c = &a;
   struct S0 **d = &c;
   if (&b == &a) {
   }
}

C15 : Crashes GCC 3.2.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
volatile int a, b, c, i;
char d;
void
fn1 () {
   int e;
   {
     for (;; c++) {
       int f[50] = { };
       if (b) {
         {
           0;
           {
             {
               int g = a, h = d;
               e = h ? g : g / 0;
             }
           }
           a = e;
         }
       }
     }
   }
}
void
main () {
   i = 0 / 0;
   a;
}

C16 : Crashes GCC 3.2.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int a, c;
volatile int b;
void
fn1 () {
   b;
   for (;;)
     break ;
   int d = b, e = a;
   c = a ? d : d % 0;
}
void
fn2 () {
   if (0 % 0)
     b;
}

C17 : Crashes GCC 3.2.0 at -O2:

1
2
3
4
5
6
7
8
9
10
union U1 {
   int f0;
   char f1
};
void
fn1 ( union U1 p1) {
   p1.f1 = 0;
   for (; p1.f1;) {
   }
}

C18 : Crashes GCC 3.2.0 at -O1:

1
2
3
4
5
int a, b;
void
fn1 () {
   b = 4294967290UL <= a | b;
}

C19 : Crashes GCC 3.2.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int a, b, c;
int
fn1 ( int p1, int p2) {
   return p1 - p2;
}
void
fn2 () {
   int d;
   int **e;
   int ***f = &e;
   d = a && b ? a : a % 0;
   if (fn1 (f == 0, 2) )
     c = ***f;
}

C20 : Crashes GCC 3.3.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int a, b, d;
struct S0 {
   int f3
};
int * volatile c;
void fn1 ( struct S0);
void
fn2 () {
   int e;
   struct S0 **f;
   struct S0 ***g = &f;
   (a && b && b ? 0 : b) > (&c && 0);
   e = 0 == g;
   d = e >> 1;
   for (;;)
     fn1 (***g);
}

C21 : Crashes GCC 3.4.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
int a, b;
struct U0 {
   char f0;
   int f2
};
void
fn1 () {
   struct U0 c;
   for (; c.f0 != 1; c.f0 = c.f0 + a)
     b -= 1;
}

C22 : Crashes GCC 3.4.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int a, b, d, e;
struct S0 {
   int f3
};
int *c;
void fn1 ( struct S0);
void
fn2 () {
   struct S0 **f;
   struct S0 ***g = &f;
   (a && b && b ? 0 : b) > (&c == d);
   e = 1 < (0 == g);
   for (;;)
     fn1 (***g);
}

C23 : Crashes GCC 4.0.0 at -O2:

1
2
3
4
5
6
7
8
int ***a;
int b;
int *c;
void
main () {
   if (&c == a)
     b = 0 == *a;
}

C24 : Crashes GCC 4.0.0 at -O2:

1
2
3
4
5
6
int a[][0];
int * const b = &a[0][1];
int
fn1 () {
   return *b;
}

C25 : Crashes GCC 4.0.0 at -O0:

1
2
3
4
5
6
int a, b;
unsigned char c;
void
fn1 () {
   (0 >= a & (0 || b) ) > c;
}

C26 : Crashes GCC 4.0.0 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
struct {
   int f9:1
}
a;
const int b[] = { 0 };
void fn1 ();
void
main () {
   for (;;) {
     a.f9 = b[0];
     fn1 ();
   }
}

C27 : Crashes GCC 4.0.0 at -O0:

1
2
3
4
5
6
int a, c;
unsigned char b;
void
fn1 () {
   b > (c > 0 & 0 < a);
}

C28 : Crashes GCC 4.0.0 at -O2:

1
2
3
4
5
6
7
8
9
10
11
12
int **a[][0];
static int *** const b = &a[0][1];
void fn1 ();
int
fn2 () {
   return ***b;
   fn1 ();
}
void
fn1 () {
   **b;
}

C29 : Crashes GCC 4.1.0 at -O1:

1
2
3
4
5
6
7
8
volatile int ***a;
int b;
int **c;
void
fn1 () {
   if (&c == a)
     b = 0 == *a;
}

C30 : Crashes GCC 4.1.0 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
struct {
   int f0;
   int f2
}
a;
int b;
void
fn1 () {
   a.f2 = 0;
   int *c[] = { 0, 0, 0, 0, &a.f0, 0, 0, 0, &a.f0 };
   b = *c[4];
}

C31 : Crashes GCC 4.1.0 at -O2:

1
2
3
4
5
6
7
8
int a, b;
unsigned c;
void
fn1 () {
   for (; c <= 0;)
     if (b < c)
       a = 1 && c;
}

C32 : Crashes GCC 4.1.0 at -O1:

1
2
3
4
5
6
7
8
unsigned a;
int b;
void
main () {
   unsigned c = 4294967295;
   int d = c;
   b = a <= d || a;
}

C33 : Crashes GCC 4.1.0 at -O1:

1
2
3
4
5
const volatile long a;
void
main () {
   printf ( "%d\n" , ( int ) a);
}

C34 : Crashes GCC 4.1.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
int a, b;
union U1 {
   int f0;
   int f1
};
void
fn1 () {
   union U1 c = { 1 };
   int d = 1;
   if ( (c.f1 & a ? c.f1 : 1 - a) ^ d) {
   } else
     b = 0;
}

C35 : Crashes GCC 4.2.0 at -O1:

1
2
3
4
5
6
7
8
volatile int ***a;
int b;
int **c;
void
fn1 () {
   if (&c == a)
     b = 0 == *a;
}

C36 : Crashes GCC 4.2.0 at -O1:

1
2
3
4
5
6
7
8
9
struct S2 {
   volatile int f5:1;
   int f6
};
static struct S2 a;
void
main () {
   printf ( "%d\n" , a.f5);
}

C37 : Crashes GCC 4.3.0 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
long long *a;
int b;
void
fn1 () {
   long long **c = &a;
   int d = 7;
lbl_2890: {
     long long **e = &a;
     b = (e == c) < d;
     d = 0;
     goto lbl_2890;
   }
}

C38 : Crashes GCC 4.3.0 at -O2:

1
2
3
4
5
6
7
8
9
struct S2 {
   volatile int f5:1;
   int f6
};
static struct S2 a;
void
main () {
   printf ( "%d\n" , a.f5);
}

C39 : Crashes GCC 4.3.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
int a;
short b;
void
fn1 () {
   int c[0];
   for (;;) {
     a = c[0];
     b = 0;
     for (; b < 7; b += 1)
       c[b] = 0;
   }
}

C40 : Crashes GCC 4.3.0 at -O1:

1
2
3
4
5
6
7
volatile int **a;
int *b;
void
fn1 () {
   if (a == &b)
     **a;
}

C41 : Crashes GCC 4.3.0 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
int a, b, c, d, e, f;
void
fn1 () {
   char g;
lbl_120:
   if (b || e >= 0 & d >= 0 || a)
     return ;
   g = f < 0 ? 1 : f;
   d = g == 0 || ( char ) f == 0 && g == 1 ? 0 : 0 % 0;
   if (c)
     goto lbl_120;
}

C42 : Crashes Intel CC 12.0.5 at -O1:

1
2
3
4
5
6
7
8
9
10
11
12
13
struct U0 {
   int f0
}
a;
struct U0
fn1 () {
   return a;
}
void
main () {
   0 > a.f0;
   fn1 ();
}

C43 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
int a;
int *b;
unsigned c;
void
fn1 () {
   for (; a; a--)
     if (*b) {
       c = 0;
       for (; c >= 5; c++) {
       }
     }
}

C44 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
7
short a;
void
fn1 () {
   long b;
   b = 44067713550;
   a |= b;
}

C45 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
volatile int a;
void
fn1 () {
   int b = 1;
   a || b--;
}

C46 : Crashes Open64 4.2.4 at -O2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int a, b;
void fn1 ();
void fn2 ();
void
fn3 () {
   fn2 ();
   fn1 ();
}
void
fn2 () {
   if (1) {
   } else
     for (;; b++) {
       int c = 0;
       int *d = &a;
       int **e = &d;
       *e = &c;
       *d = 0;
       *d |= 0;
     }
}

C47 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct S0 {
   int f1:1
};
int a, b;
void
fn1 () {
   for (; b;) {
     struct S0 c = { };
     if (1) {
       c = c;
       a = c.f1;
     }
   }
}

C48 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
int a, b;
int
fn1 () {
   int *c = &b;
   a = 0;
   for (; a >= -26; --a) {
     unsigned d = 18446744073709551615;
     int *e = &b;
     *e &= d;
   }
   return *c;
}

C49 : Crashes Open64 4.2.4 at -O3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static int a, c, d;
int b;
int *e;
void
fn1 () {
   for (; a; a += 1) {
     b = 0;
     for (; b > -16; --b)
       for (; c;) {
         int *f = &d;
         *f = 0;
       } *e = 0;
   }
}

C50 : Crashes Sun CC 5.11 at -xO4:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
unsigned char a, d;
struct {
   int f2
}
b;
int c, e;
void
fn1 (p1) {
}
void
fn2 () {
   c = 0;
   for (; c <= 0;)
     e = b.f2;
   fn1 (0);
   b = b;
   d = -a;
}

C51 : Crashes Sun CC 5.11 at -fast:

1
2
3
4
5
6
7
8
9
10
int a, c;
int b[1];
void
fn1 () {
   short d;
   for (; a; a -= 1) {
     d = b1 = b1;
     b[0] = 0;
   }
}

C52 : Crashes Sun CC 5.11 at -xO4:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int a, b, d;
short c;
int
fn1 (p1) {
   return a ? 0 : p1;
}
void
fn2 () {
   int e = 0;
   for (;;) {
     c = 0;
     d = fn1 (e ^ ~~c);
     d && b;
   }
}

C53 : Crashes Sun CC 5.11 at -fast:

1
2
3
4
5
6
7
8
9
10
11
12
long a;
int b, d;
int *c;
void
fn1 () {
   int *e;
   for (;; b--)
     for (; d;) {
       *c = 0;
       *c &= (&e != 1) / a;
     }
}

C54 : Crashes Sun CC 5.11 at -xO0:

1
2
3
4
5
6
#pragma pack(1)
struct {
   int f3:1;
   int f4:16
}
a = { 1, 0 };

C55 : Crashes Sun CC 5.11 at -xO3:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int a, c;
static int b = 1;
void fn1 ();
void
fn2 () {
   for (; a; a--) {
     c = 0;
     for (; c != 1;) {
       if (b)
         break ;
       fn1 ();
     }
   }
}

C56 : Crashes Sun CC 5.11 at -xO4:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#pragma pack(1)
struct S0 {
   int f1;
   int f3:1
}
a;
void
fn1 ( struct S0 p1) {
   p1.f3 = 0;
}
void
fn2 () {
   fn1 (a);
}

C57 : Crashes Sun CC 5.11 at -fast:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int a, c, d, e, f, g, h, i, j, k;
volatile int b;
int
fn1 () {
   for (; d; d = a) {
     int *l = &c;
     c = -3;
     for (; c > -23; --c)
       if (k) {
         if (*l)
           continue ;
         return b;
       }
     for (; i; ++i) {
       j = 0;
       g = h;
       for (; f <= 1; f += 1) {
       }
     }
   }
   return e;
}
qiangchen99
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【转】最短的崩溃程序（C语言版）
areful的专栏
09-22 1058
想写个崩溃的C语言小程序，看起来是个奇怪的主意，不过在我曾经教过的一门实验课上，这是作业之一！实际上，这是一件非常有教学意义的事情。 通常学生们要么尝试反向引用一个非法地址，要么就是除0.除0会引发SIGFPE信号（浮点异常）。这里有一个小例子程序，使用除零方法来使之崩溃： 1 2 3 4 int main() {
赌徒破产问题
https://gitcode.net/liuyuan185442111
06-27 1960
罗伯特席勒的《金融市场》第19课结尾提到一个“gambler’s ruin problem”：初始有s块钱，每次交易可能赚钱或赔钱，赚钱的概率是p，赔钱的概率是1-p，每次赚或赔的金额是1块钱，那他破产的概率是多少。 知乎上有个类似问题的解答，依照他的思路，我尝试计算赌徒破产的概率： 问题先等价转换为，坐标轴上AB两点，A左B右相距s，从A出发，赢往左走1步，输往右走1步，走到B点破产。 从任意一点开始，首次到达他+1的点的概率都是相等的，记为f1f_{1}f1​。 从任意一点开始，首次到达他+n的点的概
C语言常见的程序崩溃问题分析
sinat_32152141的博客
05-31 1693
1. 常见的程序崩溃示例 常见的崩溃类型有以下几种： 对空指针指向的内存非法写操作 对空指针指向的内存非法读操作 除0操作 大的临时变量或者递归等导致栈溢出 对只读内存进行写操作 堆越界写操作 对已经释放的内存进行写操作
编译器的编译错误和运行崩溃
contest_away的博客
02-01 453
在产生汇编指令时发生的错误，即不能产生汇编代码。1.只对空指针解引用却不使用解引用返回值，不会报错。在执行文件时出现的错误，即不会产生预计结果。2使用指向空地址的对象的成员函数：不报错。在一次编译器中，不会执行。
银行家算法C语言代码.doc
05-18
银行家算法C语言代码 银行家算法是操作系统中的一种资源分配算法，用于避免死锁的产生。该算法通过跟踪每个进程的资源需求和当前可用的资源量来避免死锁的产生。 在本文档中，我们提供了银行家算法的C语言代码实现...
c语言入门 代码 c语言数组
01-18
这段代码会遍历整个数组并打印所有元素，`sizeof(myArray)`返回数组占用的总字节数，而`sizeof(myArray[0])`返回单个元素的字节数，这样可以计算出数组的长度。 数组还可以作为函数参数传递，但需要注意的是，当...
最近对问题 分治法 ——C语言代码
05-23
- **控制结构**：if-else语句用于条件判断，for和while循环用于重复执行某段代码，switch-case用于多分支选择。 3. **分治法实例：归并排序（Merge Sort）**： - **分解**：将一个大数组分为两个相等或接近相等的...
c代码-C语言作业2
07-16
10. **编译和链接**：C程序首先由编译器编译成中间的汇编代码，再由汇编器转换为机器代码，最后通过链接器将所有目标文件连接成可执行文件。 为了完成这个C语言作业，学生需要熟悉上述所有概念，并能将它们应用于...
C++常见崩溃问题分析处理
Z18292832663的博客
03-15 2494
C++常见崩溃问题分析处理 使用Visual Studio 2013进行c++编码的时候经常会遇到一些编译不通过或者编译通过了链接出错，好不容易运行了又出现崩溃的问题，第一种问题编译器会自动检测出来，这种只需要仔细看错误描述就能知道问题出在哪，最麻烦的就是运行中崩溃了。 我整理了一些c++常见的错误，并进行了分析，给出了解决方案。（记录下来以便后面解决问题） 1、编译链接错误 （1）error C...
如何解决 C/C++ 编译器优化导致的编译BUG（程序崩溃）支援VC++/CLANG/GCC
最新发布
liulilittle的博客
02-29 1228
根据审视这些汇编代码，来推论属于哪一类的情况，但通常，我们并不需要这么复杂的具体分析，这么分析是为了最高效能，极致 C/C++ 代码性能吞吐优化，所以需要细微入致，谨慎分析、代码调效。所以，本文说的很明白，不适合没有这种精气神，跟捣鼓的童靴，如果只是会点 C/C++ 语法，写点 C/C++ 程序，那么你并不懂 C/C++，不愿意折腾研究换语言，C语言或许更好一点。大多数简单的 C/C++ 开发的程序，并不需要这样的捣鼓，但当 C/C++ 大量的应用宏、模板元编程的时候，遭遇类似的编译器BUG，将无法避免。
57 个让 C 编译器崩溃的代码
churehill123的专栏
07-22 989
我不清楚你是否很高兴看到你的程序会让编译器崩溃的情况，反正我很喜欢，相当于发现了编译器的 bug。 本文列出 57 段代码以及相应的编译器版本和编译参数，在这个环境下对代码进行编译会导致编译器崩溃。 C1 : Crashes Clang 2.6 at -O0: #pragma pack(1) struct S1 { int f0; char f2 }; struct {
c语言错误代码举例,C语言常见错误代码释义.doc
weixin_33814090的博客
05-17 780
C语言常见错误代码释义错误代码及错误信息 错误释义error 1: Out of memory 内存溢出error 2: Identifier expected 缺标识符error 3: Unknown identifier 未定义的标识符error 4: Duplicate identifier 重复定义的标识符error 5: Syntax error 语法错误error 6: Error i...
c语言错误代码及改正,C语言小BUG（已找到错误代码，，在线等 急，）
weixin_42191359的博客
05-17 278
这是链队列的代码，其中有个小问题调试说是113行错了，实在不知道哪里错了从111行开始看就行了，从111行以下是想根据输入“+”，“-”字符实现入队、出队一个一个进行，求指导#include#defineMAXLEN10typedefstruct{intdata[MAXLEN];intfront,rear;}SeQueue;SeQueueInitSeQueue(){SeQueu...
c语言程序 坑人的代码,C语言刷题坑收集1
weixin_34711401的博客
05-17 471
第一题： (注意加黑字体的宾语)int *p[4]; //指针数组。 是个有4个元素的数组， 每个元素的是指向整型的指针。(每个元素都是指针的数组)int (*p)[4]; //数组指针。 它是一个指针，指向有4个整型元素的数组。(指向有4个整型元素的数组的指针)int *func(void); //指针函数。 无参函数...
C语言编程常见问题分析，以及错误解决办法！
热门推荐
HUYA69的博客
02-28 1万+
遇到错误怎么办 在遇到错误的时候不要慌，首先看报错，中文直接看，英文翻译看。根据报错找到错误发生的行数，一般错误就在这一行的上下几行代码。不要偷懒遇到问题马上问别人是对自己的不负责，成长是需要经历困难的，只有自己被折磨过才能记住它。根据报错解决不了先在网上搜索寻找答案，自己把代码过一遍基本上能找到问题，实在不行可以找群里的大佬问，值得注意的是问问题要讲究方法：首先描述你程序的功能，...
深入理解现代编译器：C语言实现与实践
此外，书中特别设计了一个C语言编写的实习项目，学生可以实际动手构建一个编译器，涵盖前端（词法分析、语法分析、语义分析）和后端（代码生成、优化）。这个项目旨在让学习者通过实践深入理解和掌握编译器设计的全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值