【1024特别策划】Show me your bad code！

发布于 2021-10-18 14:07:59 浏览：2296 订阅该版

![ca41660c94d6c2a1dd2763803124dc78.png.webp](https://oss-club.rt-thread.org/uploads/20211018/ca41660c94d6c2a1dd2763803124dc78.png.webp)

感谢大家参与本次活动，获奖名单如下：
![e2300021944c7882e62bc21a79befbd9.png](https://oss-club.rt-thread.org/uploads/20211026/e2300021944c7882e62bc21a79befbd9.png)

恭喜以上小伙伴，请于10月30日前将邮寄信息私发小师弟，或发送至小师弟微信：rtthread2020,奖品将于下周一寄出

![image.png](https://oss-club.rt-thread.org/uploads/20211018/6a2814df59420a84a70351a79586a0d3.png)

1024 程序员日要来啦，在这个属于程序员的重大节日里，RT-Thread社区又来给大家送福利了！

本次活动由**RT-Thread社区特别策划**：**Show me your bad code**，目的是写出有创意又让人印象深刻/难以理解的代码，希望大家在娱乐之余，还能学习点“东西”！

**活动时间：10月18日-10月25日**

**活动流程：**
**1.提供一段【烂】代码：**在本帖下回复一段代码，可以是自己写的代码，也可以是平时工作中遇到的代码，也可以从一些代码中抽象简化而来。
**2.给出【烂】的原因：**从以下几个角度（不限于这几个角度）：可读性、可维护性、运行性能等。
**3.等待评选：**回复完成后，RT-Thread会根据评选标准进行评选
**4.获奖名单公布：**10月26日公布活动获奖名单

【烂】代码回复示例：
![image.png](https://oss-club.rt-thread.org/uploads/20211018/64ce1adb0de3dc30ab4833db12073b07.png.webp)

**活动要求：**
1）编程语言不限，代码行数建议不超过1000行；
2）编译要能通过，代码需要能完成相应的功能（输出hello world也算）；
3）严禁直接从网上抄袭已公开的【烂】代码；
4）本活动最终解释权归RT-Thread所有

**评选标准：**
1）【烂】代码的原创性 25分
2）【烂】代码的泛滥性（有多少人会犯这样的错误）35分
3）【烂】代码创新性 25分
4）【烂】代码的娱乐属性 15分

**活动奖项：**
一等奖1名：STM32H7系列开发板
二等奖2名：RT-Thread双肩背包
三等奖3名：RT-ThreadT恤一件
参与奖：RT-Thread定制周边礼品一份
![微信图片_20211018140414_副本.jpg](https://oss-club.rt-thread.org/uploads/20211018/a20cb8c1edf9f5b6a95187201d75a081.jpg)

PS：获奖作品将会汇总论坛首页展示在，同一用户不可重复获奖

最后感谢开发者recan为本次活动提供idea，祝天下所有的程序员节日快乐，愿你的每一行代码都能改变世界！

**【烂】代码参考：**
1.垃圾实例参考： https://www.eet-china.com/mp/a82672.html
2.github上 垃圾代码书写准则 
https://github.com/trekhleb/state-of-the-art-shitcode/blob/master/README.zh-CN.md

29 条评论

_姗姗_ 2021-10-18

这家伙很懒，什么也没写！

天狼八部 2021-10-18

这家伙很懒，什么也没写！

liuduanfei 2021-10-18

这家伙很懒，什么也没写！

来一颗糖 2021-10-18

这家伙很懒，什么也没写！

CharlesX 2021-10-18

Make science fiction science

**严正声明**：
以下代码不针对、不讽刺任何人，只为和大家一起学习进步、不犯错误。
艺术来源生活，稍有修饰和夸张成分，字迹潦草只为博君一笑~
如有雷同，纯属巧合！[微笑]
请勿对号入座，谢谢！[微笑]
```c
#include <rtthread.h>
#include <rtdevice.h>
#include <board.h>

/* defined the LED0 pin: PC0 */
#define LED0_PIN    GET_PIN(C, 0)
#define biaozhi6    GET_PIN(B, 1)
#define Size        6536
rt_mq_t RS4851_Q;
rt_mq_t RS4852_Q1;

int main(void)
{
    uint8_t i;
    uint8_t flagl[20], flag3[20], flag6[20], first_Flag, Flag_revrese;
    uint16_t k1, k2, k4, a, parament1, a1;
    k1=k2=k4=0;
    RS4851_Q    =rt_mq_create("quea1", 20, 10, RT_IPC_FLAG_PRIO);
    RS4852_Q1   =rt_mq_create("quea2", 20, 10, RT_IPC_FLAG_PRIO);
    rt_pin_mode(LED0_PIN, PIN_MODE_OUTPUT);
    rt_pin_mode(biaozhi6, PIN_MODE_INPUT_PULLDOWN);
    
    /* Known condition:
    The value of flagl and flag3 are read from flash
    */
    for(i= 0;i<20;i++)
    {
        if((flagl[i]==0x01)&&(flag3[i] !=0))
            first_Flag =1;
        if(first_Flag ==1)
            break;
    }
    if(first_Flag ==0)
    {
        a = 0xFb;
        rt_mq_send(RS4851_Q, &a, 1);
        a1 = a*100;
        rt_mq_send(RS4852_Q1, &a1, 1);
    }
    
    if(flag6[i] ==3)
        parament1 = rt_pin_read(biaozhi6);
    
    if(parament1 !=0)
        rt_kprintf("biaozhiwuxiao");
    
    for(k1 =0; k1<Size;k1+=256)
    {
        /*DO SOMETHING*/
        if(k1 <Size/2)
            k4 = 512;
        else
            k4 =256; 
        for(k2=0; k2< k4;k2+=128)
        {
            Flag_revrese = !Flag_revrese;
            rt_pin_write(LED0_PIN, Flag_revrese);
            rt_thread_mdelay(500);
        }
    }
    return RT_EOK;
}
```
这份代码【烂】的原因，且听我慢慢道来：
1. 变量命名，中英横行；
2. 格式混乱，胖虎顿饭；
3. 可读性差，毫无章法；
4. 放飞自我，随心所欲；
5. 复制粘贴，后缀瞎写；
6. flag flag, flying bug。

**PS：**这份代码可是"0 errors, 0 warnings"哦~，甚至能够正常运行呐，嘻嘻~~~

![code.jpg](https://oss-club.rt-thread.org/uploads/20211018/ac2be1c9587fe59368ac613578b85b04.jpg)

值此1024程序员佳节来临之际，祝大家万码奔腾，码到成功！
[愿世上没有【烂】代码，阿弥陀佛]

CharlesX 2021-10-18

Make science fiction science

RTT_ZDQ 2021-10-19

这家伙很懒，什么也没写！

最近在一个项目上看到这个函数嵌套了n多层，如有雷同，纯属巧合，代码结构如下，不包含内容：
```c
void fun(void)
{
    uint16_t i,j,k,m;
    for(i = 0; ...)
    {
        if()
        {
            for(j = 0;...)
            {
                if()
                {
                    for(k = 0;...)
                    {
                        if()
                        {
                            for(m = 0; ... )
                            {
                                if()
                                {
                                    if()
                                    {
                                        if()
                                        {
                                            ...;
                                        }
                                        else
                                        {
                                            ...;
                                        }
                                    }
                                    else
                                    {
                                    
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }       
    }
}

```

chenyaxing 2021-10-19

泥上偶然留指爪，鸿飞那复计东西。

想当诸侯的小蚂蚁 2021-10-19

这家伙很懒，什么也没写！

一个中断把所有业务都做完了，又是带延时的函数调用，又是sprintf
```c
void TIM7_IRQHandler(void)
{
	portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
	STRUCT_QUEUE struct_BBtoMain, struct_CHtoMain;
	STRUCT_QUEUE struct_BluetoMain;

if( LL_TIM_IsActiveFlag_UPDATE( TIM7 ) )
	{
		LL_TIM_ClearFlag_UPDATE( TIM7 );
		
		//Shoe_Inf.u8Updata_Int++;
		
		
		if( BallBearing_Inf.u16ZD_Cnt_BB1>BB_MAX_ZD_CN || \
			BallBearing_Inf.u16ZD_Cnt_BB2>BB_MAX_ZD_CN  )
		{
			BallBearing_Inf.BB_Status = BB_ZHENDONG;

BallBearing_Inf.u8Normal_Cnt = 0;	
			BallBearing_Inf.u16QX_Cnt_BB2 = 0;	
			BallBearing_Inf.u16QX_Cnt_BB1 = 0;
		}
		
		else if( LL_GPIO_IsInputPinSet( GPIOC, LL_GPIO_PIN_13) || \
				 LL_GPIO_IsInputPinSet( GPIOA, LL_GPIO_PIN_2 )	)	
		{
			BallBearing_Inf.u8Normal_Cnt = 0;	
			
			if( LL_GPIO_IsInputPinSet( GPIOC, LL_GPIO_PIN_13) )
			{
				if( BallBearing_Inf.u16QX_Cnt_BB2<BB_MAX_CNT_CN )
					BallBearing_Inf.u16QX_Cnt_BB2++;
			}
			if( LL_GPIO_IsInputPinSet( GPIOA, LL_GPIO_PIN_2) )
			{
				if( BallBearing_Inf.u16QX_Cnt_BB1<BB_MAX_CNT_CN )
					BallBearing_Inf.u16QX_Cnt_BB1++;
			}
			
			if( BallBearing_Inf.u16QX_Cnt_BB2>=BB_MAX_CNT_CN || \
				BallBearing_Inf.u16QX_Cnt_BB1>=BB_MAX_CNT_CN )
			{
				
				BallBearing_Inf.BB_Status = BB_CONTACT;
			}
		}
		else	
		{
			if( BallBearing_Inf.u8Normal_Cnt++ > BB_MAX_CNT_CN )
			{
				BallBearing_Inf.BB_Status = BB_NORMAL;
				BallBearing_Inf.u8Normal_Cnt = 0;
			}
			
			BallBearing_Inf.u16QX_Cnt_BB2 = 0;	
			BallBearing_Inf.u16QX_Cnt_BB1 = 0;
		}
		
		BallBearing_Inf.u16ZD_Cnt_BB1 = 0;
		BallBearing_Inf.u16ZD_Cnt_BB2 = 0; 
		BallBearing_Inf.u8Stt_Keep_Cnt++;
		if( BallBearing_Inf.BB_Status != BallBearing_Inf.Stt_Bck ||
			(BB_NORMAL!= BallBearing_Inf.BB_Status && Shoe_LouChe.u8OffRail_flag == SHOE_OFFRAIL) )// || BallBearing_Inf.u8Stt_Keep_Cnt>10 )
		{
			BallBearing_Inf.u8Stt_Keep_Cnt = 0;
			
			BallBearing_Inf.Stt_Bck = BallBearing_Inf.BB_Status;
			struct_BBtoMain.msg_type = BALL_MSG;
			struct_BBtoMain.u8Code = BallBearing_Inf.BB_Status; 
			struct_BBtoMain.pu8Pack = NULL;
			struct_BBtoMain.u8Lth = 0;
			
			xQueueSendFromISR( xQueue_MAIN, &struct_BBtoMain, &xHigherPriorityTaskWoken);
		}
		if( LL_GPIO_IsInputPinSet( GPIOA, LL_GPIO_PIN_6) )
		{
			if(++BallBearing_Inf.u8Charge_Cnt > 2) {
				Charge_Inf.Tmp_Stt[Charge_Inf.u8Tst_Cnt] = CHARGE_ON;			
				Charge_Inf.Stt_Bck = CHARGE_ON;
			}
		}
		else
		{
			BallBearing_Inf.u8Charge_Cnt = 0;
			Charge_Inf.Tmp_Stt[Charge_Inf.u8Tst_Cnt] = CHARGE_OFF;			
			Charge_Inf.Stt_Bck = CHARGE_OFF;
		}
		
		if( Charge_Inf.Stt_Bck != Charge_Inf.Charge_Stt )
		{
			Charge_Inf.Charge_Stt = Charge_Inf.Stt_Bck;
			struct_CHtoMain.msg_type = CHARGE_MSG;
			struct_CHtoMain.u8Code = Charge_Inf.Charge_Stt;
			struct_CHtoMain.pu8Pack = NULL;
			struct_CHtoMain.u8Lth = 0;
			
			xQueueSendFromISR( xQueue_MAIN, &struct_CHtoMain, &xHigherPriorityTaskWoken);
		}	
#ifdef	SWITCH_ONOFF_RAIL
		//--------------------------------------------------
		STRUCT_QUEUE struct_SWtoMain;
		if( LL_GPIO_IsInputPinSet( GPIOA, LL_GPIO_PIN_0) )
		{
			//Switch_Inf.Tmp_Stt[Switch_Inf.u8Tst_Cnt] = SWITCH_ON;	
			Switch_Inf.Tmp_Stt[0] = SWITCH_ON;	
		}
		else
		{
			//Switch_Inf.Tmp_Stt[Switch_Inf.u8Tst_Cnt] = SWITCH_OFF;  
			Switch_Inf.Tmp_Stt[0] = SWITCH_OFF;  
		}
		
		if( Switch_Inf.Tmp_Stt[0] != Switch_Inf.Switch_Stt )
		{
			
			Switch_Inf.Switch_Stt = Switch_Inf.Tmp_Stt[0];			
			struct_SWtoMain.msg_type = KEY_MSG;
			struct_SWtoMain.u8Code = Switch_Inf.Switch_Stt;
			struct_SWtoMain.pu8Pack = NULL;
			struct_SWtoMain.u8Lth = 0;
			
			xQueueSendFromISR( xQueue_MAIN, &struct_SWtoMain, &xHigherPriorityTaskWoken);
		}
#endif
        
#ifdef	BLUETOOTH
		if( LL_GPIO_IsInputPinSet( GPIOA, LL_GPIO_PIN_0)==0 )
		{
            fnBT_Recv_Date(0, u8Test_buff);
			if(u8Test_buff[3] == 'S'&& u8Test_buff[5] == 'T' && u8Test_buff[4] == 'E')
				{
				if(u8Test_buff[9] == 0x30||u8Test_buff[9] == 0x31||u8Test_buff[9] == 0x35)	
					{
                  
                    struct_BluetoMain.msg_type = CARD_MSG;
					if((u8Test_buff[9] == 0x30) &&( SHOE_ALARM!=Shoe_Inf.Shoe_Stt ))    
						{
						struct_BluetoMain.u8Lth = CARD_rail;
						struct_BluetoMain.pu8Pack = NULL;
						struct_BluetoMain.u8Code = (u8Test_buff[6]-0x30)*10+u8Test_buff[7]-0x30;;
						
						xQueueSendFromISR( xQueue_MAIN, &struct_BluetoMain, &xHigherPriorityTaskWoken);
                        sprintf((char *)u8Test_buff,"T%03d=OK\r\n",Shoe_Inf.u8ID);
                        fnBT_Recv_Date(strlen((char *)u8Test_buff), u8Test_buff);

}
					else if((u8Test_buff[9] == 0x31) &&( SHOE_ALARM==Shoe_Inf.Shoe_Stt ))
						{
						struct_BluetoMain.u8Lth = CARD_rail;
						struct_BluetoMain.pu8Pack = NULL;
						struct_BluetoMain.u8Code = (u8Test_buff[6]-0x30)*10+u8Test_buff[7]-0x30;;
						
						xQueueSendFromISR( xQueue_MAIN, &struct_BluetoMain, &xHigherPriorityTaskWoken);
                        sprintf((char *)u8Test_buff,"T%03d=OK\r\n",Shoe_Inf.u8ID);
                        fnBT_Recv_Date(strlen((char *)u8Test_buff), u8Test_buff);
						}
											
						else if(u8Test_buff[9] == 0x35)
						{
								Ultrasonic_Standby();	
								LORA_Standby();			
								HSJ560_Standby();		
								GPRS_Standby();				
								fnRTC_Backup_Write( SHOE_STT_ADDR, 0);
								fnRTC_Backup_Write( LORA_STT_ADDR, 0x30);
								fnRTC_Backup_Write(WAKEUP_CNT_ADDR,0);
								fnRTC_Backup_Write( BAT_LVL_ADDR,0 );
								fnRTC_Backup_Write( LORA_SNDFAIL_CNT, 0);	
								fnRTC_Backup_Write(OFFCASE_CNT_ADDR,0);
								fnRTC_Backup_Write( IAP_STT_ADDR, 0 );
								LL_RCC_ForceBackupDomainReset();
								LL_RCC_ReleaseBackupDomainReset();
								LL_PWR_DisableBkUpAccess();
							  NVIC_SystemReset();

}
                    else
                        {
                            sprintf((char *)u8Test_buff,"T%03d=ERR\r\n",Shoe_Inf.u8ID);
                            fnBT_Recv_Date(strlen((char *)u8Test_buff), u8Test_buff);
                        }
					}
                    else
                    {
                        sprintf((char *)u8Test_buff,"T%03d=ERR\r\n",Shoe_Inf.u8ID);
                        fnBT_Recv_Date(strlen((char *)u8Test_buff), u8Test_buff);
                    }
                    
				}
			if(u8Test_buff[3] == 'C'&& u8Test_buff[5] == 'G' && u8Test_buff[4] == 'F')
				{
				struct_BluetoMain.msg_type = CARD_MSG;
				struct_BluetoMain.u8Lth = CARD_par;		
				struct_BluetoMain.pu8Pack = NULL;
				struct_BluetoMain.u8Code = (u8Test_buff[7]-0x30)*100 + (u8Test_buff[8]-0x30)*10 + u8Test_buff[9]-0x30;
				xQueueSendFromISR( xQueue_MAIN, &struct_BluetoMain, &xHigherPriorityTaskWoken);
				
                sprintf((char *)u8Test_buff,"T%03d CFG OK\r\n",Shoe_Inf.u8ID);
                fnBT_Recv_Date(strlen((char *)u8Test_buff), u8Test_buff);

}
		}
		
		
#endif
	}
	
	portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
}

```

rt999 2021-10-19

Rt-Thread 6翻啦

```c
void thread_file_send(void *args)
{
    int file_fd=RT_NULL;
    char *filename;
    int len;
    uint8_t temp_data[SINGLE_MAX_SIZE];
    while(1)
    {
       rt_mb_recv(mail_file_read, (void*)&filename, RT_WAITING_FOREVER);
        file_fd=open(filename, O_RDONLY);//以读方式打开文件
        if (file_fd>= 0)
        {
            led_flick_flage=1;
            uint16_t strain_num=1;
            while((len = read(file_fd, temp_data, SINGLE_MAX_SIZE))>0)
            {
                uint8_t *reply=rt_mp_alloc(mp2, RT_WAITING_FOREVER);
                reply[0]=(len+7)>>8;
                reply[1]=(len+7)&0xff;
                reply[2]=0xcb;
                reply[3]=LORA_ADDR;
                reply[4]=0x11;

reply[5]=strain_num>>8;
                reply[6]=strain_num;
                rt_memcpy(reply+7,temp_data,len);

strain_num++;

uint16_t crc_chec=CRC16(temp_data, len);
                reply[len+7]=crc_chec>>8;
                reply[len+8]=crc_chec&0Xff;
                rt_mb_send(mail_wireless_out, (uint32_t)reply);
            }
         }
        close(file_fd);
        rt_mp_free(filename);
    }
}
```

自己真实写过的一个线程，并且正在运行。该线程的作用是接收一个文件名指针，从tf卡读出该文件并依次打包数据到串口发送线程，单包文件大小约为1000 byte
烂的原因：
1.该线程在初始化时分配了一个临时用于存储文件内容的空间，导致线程占用的空间较大
2.在读取文件内容后，又将读取到的文件数据copy到内存池里，浪费了大量的处理时间

正解：在接收到文件名后先获取内存池空间，然后用内存池空间保存文件的内容

出出啊 2021-10-19

恃人不如自恃，人之为己者不如己之自为也

if for switch 嵌套让你们这么厌恶？

今天分享的源码伪代码。
```c
void init()
{
    d_out();
}

void update_sele()
{
    switch() {
    ...
    case x:
        if (segment1) {
            ...
            d_out();
        } else {
            ...
            d_out();
        }
    break;
    ...
    }
}

void d_out()
{
    switch() {
    ...
    case 0:
        init();
    break;
    case 1:
        if (segment1) {
            ...
            d_out();
        } else {
            ...
            d_out();
        }
    break;
    case 2:
        if (segment2) {
            ...
            d_out();
        } else {
            ...
            d_out();
        }
    break;
    case 3:
        update_w();
    break;
    ...
    }
}

void update_w()
{
    ...
    d_out();
}
```

编译会有几个警告
```
*** WARNING L13: RECURSIVE CALL TO SEGMENT
    SEGMENT: ?PR?D_OUT?PROJECT
    CALLER:  ?PR?UPDATE_S?PROJECT
*** WARNING L13: RECURSIVE CALL TO SEGMENT
    SEGMENT: ?PR?D_OUT?PROJECT
    CALLER:  ?PR?UPDATE_W?PROJECT
*** WARNING L13: RECURSIVE CALL TO SEGMENT
    SEGMENT: ?PR?INIT?PROJECT
    CALLER:  ?PR?D_OUT?PROJECT
```

上面所有函数实现均在某一个源码文件内。由 while(1) 死循环扫描执行。

【烂】的原因：非线性函数嵌套调用。
1. 如果把这个源码文件添加到项目，但是不调用初始化以及 while(1) 循环体内的代码。编译是通不过的。几十个 `*** ERROR L107: ADDRESS SPACE OVERFLOW` 以及 `*** ERROR L118: REFERENCE MADE TO ERRONEOUS EXTERNAL` 错误。如果想单独测试其它部分代码，这个文件是千万不能添加到项目的。
2. 未添加这个源码文件之前，用 while nop 实现的 delay 。添加之后就变了，要么仿真的时候 while 循环里的 i++ i 值不变，要么烧写到芯片后 delay 时间变短。
3. 正常使用的时候是有开头的几个 warning 的。但是它能跑起来。

这份代码是一位老师傅留下来的，千万不敢动（没重构能力 !_.）。
祖传代码，千万别动；勿笑代码烂，能跑就行。