C 语言速成 · 从 C++ 到 51 单片机

0写在前面：做减法，再做加法

C 和 C++ 不是两门语言的关系，而是「C++ 是 C 加上一大堆东西」。你学 C 不是从零开始，而是把已经会的东西换个写法，再补几个 C++ 里没有、单片机里却天天用的东西。

一、为什么单片机用 C 而不是 C++

二、你要「砍掉」的（C++ 独有，C 里没有）

三、你要「加上」的（单片机必需）

1第一个 C 程序与输入输出

同一个程序，两种写法

左边是你现在写的，右边是 C 版本 —— 除了输入输出，其余一模一样：

// ===== C++ 版 =====
#include <iostream>
using namespace std;
int main(){
    int a, b;
    cin >> a >> b;
    cout << a + b << endl;
    return 0;
}

// ===== C 版 =====
#include <stdio.h>          // 注意：不是 iostream，也没有 using namespace
int main(void){
    int a, b;
    scanf("%d %d", &a, &b);   // 每个变量前面要加 & 取地址
    printf("%d\n", a + b);
    return 0;
}

printf / scanf 格式符对照表

输出格式控制

printf("%d\n", 42);          // 42
printf("%5d|\n", 42);        //    42|   宽度 5，右对齐
printf("%-5d|\n", 42);       // 42   |   左对齐
printf("%05d\n", 42);        // 00042   补前导零
printf("%.2f\n", 3.14159);   // 3.14    保留两位小数
printf("%x\n", 255);         // ff      十六进制（单片机调试常看）
printf("你输入的是 %d\n", a);  // 中文也能直接输出

单片机里的 printf 是要「改造」的

在 PC 上 printf 输出到屏幕，在 51 单片机上它默认没有出口。标准做法是：把 printf 的底层输出函数 putchar 重定向到串口。这段代码你在 Day 5（串口通信）会直接用到：

/* 51 单片机：把 putchar 重定向到串口，之后 printf 就能发到电脑串口助手 */
#include <stdio.h>

void UartInit(void);        // 串口初始化（略，见 Day 5）
void UartSendByte(unsigned char b);

char putchar(char c)        // Keil C51 的库会调用这个函数
{
    UartSendByte((unsigned char)c);
    return c;
}

void main(void)
{
    UartInit();
    printf("Hello MCU\r\n");     // 电脑串口助手就能看到
    printf("温度 = %d C\r\n", 25);
    while (1);
}

scanf 的坑

// 坑 1：%d 和 %ld / %lld 必须和变量类型匹配
long long n;
scanf("%d", &n);        // ✗ 错！读进来的值不对
scanf("%lld", &n);      // ✓ 对

// 坑 2：格式串里的空格和换行
scanf("%d %d", &a, &b);  // ✓ scanf 会把任意多个空白（空格/回车/Tab）都吃掉

// 坑 3：读字符时前面的回车会被吃掉
scanf("%c", &ch);        // 如果前面刚读完数字，这里读到的可能是 '\n'
scanf(" %c", &ch);       // ✓ 前面加个空格，跳过空白字符

2数据类型与 stdint.h

为什么单片机必须用 stdint.h

C 标准只规定了「int 至少 16 位」这种下限，没有规定确切长度。同一个 int，在 51 上是 16 位，在 PC 上是 32 位。写单片机时这是灾难 —— 你以为它在存 0~65535，结果只存了 8 位。

解决办法就是 stdint.h，它给出长度确定的类型名：

#include <stdint.h>

uint8_t   a;   // 无符号  8 位   0 ~ 255
int8_t    b;   // 有符号  8 位   -128 ~ 127
uint16_t  c;   // 无符号 16 位   0 ~ 65535
int16_t   d;   // 有符号 16 位   -32768 ~ 32767
uint32_t  e;   // 无符号 32 位   0 ~ 4294967295
int32_t   f;   // 有符号 32 位

// 只要看到 u 开头就是 unsigned，看到 int 开头就是有符号，后面的数字就是位数

PC 上常见的类型（洛谷用）

sizeof：自己量一量

#include <stdio.h>
int main(void){
    printf("char        = %d\n", (int)sizeof(char));         // 1
    printf("int         = %d\n", (int)sizeof(int));          // PC 上 4，51 上 2
    printf("long long   = %d\n", (int)sizeof(long long));    // 8
    printf("double      = %d\n", (int)sizeof(double));       // 8
    printf("int[10]     = %d\n", (int)sizeof(int[10]));      // 40
    return 0;
}

注意 sizeof 返回的是 size_t（无符号），所以打印时要强制转成 int，否则会出警告。

无符号数的坑

unsigned int a = 0;
a = a - 1;              // 不是 -1，而是 4294967295（绕回去了）
printf("%u\n", a);

// 循环变量尤其危险：条件永远成立
for (unsigned int i = 10; i >= 0; i--)   // ✗ 死循环！i 永远 >= 0
    printf("%u\n", i);

51 单片机的类型（Keil C51）

/* 51 里你会反复看到这三行，它们都在头文件 reg51.h 里 */
sfr P1 = 0x90;          // 把地址 0x90 的寄存器命名为 P1
sbit LED = P1^0;        // 把 P1 的第 0 位命名为 LED

LED = 0;                // 直接操作那一位，不用位运算

3位运算（单片机最核心的技能）

六个运算符

四个必背惯用法

这四行你要练到不用想就能写出来：

/* ① 置位：把第 n 位变成 1，其它位不动 */
reg |= (1 << n);

/* ② 清零：把第 n 位变成 0，其它位不动 */
reg &= ~(1 << n);

/* ③ 翻转：第 n 位取反，其它位不动 */
reg ^= (1 << n);

/* ④ 读取：判断第 n 位是 0 还是 1 */
if (reg & (1 << n)) { /* 第 n 位是 1 */ }

手推一遍：把 P1 的第 3 位点亮

P1 初值          = 0b0000 0000
1 << 3           = 0b0000 1000
P1 |= (1<<3)     → 0b0000 1000    // 第 3 位亮了，其它位没动

// 再把第 5 位也点亮（不影响第 3 位）
P1 |= (1<<5)     → 0b0010 1000

// 现在把第 3 位关掉
~(1<<3)          = 0b1111 0111
P1 &= ~(1<<3)    → 0b0010 0000    // 第 3 位灭了，第 5 位还在

你学过的流水灯，现在能解释清楚了

/* Day 2 的流水灯：8 个 LED 依次点亮 */
#include <reg51.h>
#include <intrins.h>

void delay(unsigned int ms);

void main(void)
{
    unsigned char i;
    while (1) {
        for (i = 0; i < 8; i++) {
            P1 = ~(1 << i);   // 只有第 i 位是 0，其余是 1
            delay(200);
        }
    }
}

这就是「流水」的来历：那个唯一的 0 在 8 位里移动。

更多单片机里的实际用法

/* 判断按键是否按下（P3 的第 2 位接按键，按下为 0） */
if ((P3 & (1 << 2)) == 0) {
    // 按下
}

/* 一次清掉低 4 位，保留高 4 位 */
reg &= 0xF0;

/* 一次点亮低 4 位，不影响高 4 位 */
reg |= 0x0F;

/* 取低 4 位的值 */
unsigned char low = reg & 0x0F;

/* 交换高低 4 位 */
reg = (reg << 4) | (reg >> 4);

/* 把两个 8 位数拼成一个 16 位数（传感器数据常见） */
unsigned int v = ((unsigned int)high << 8) | low;

/* 从 16 位数里拆出高、低字节 */
unsigned char h = (unsigned char)(v >> 8);
unsigned char l = (unsigned char)(v & 0xFF);

自测

不看上面，说出这几行的作用：

P1 |= 0x01;
P1 &= ~0x01;
P1 ^= 0x01;
if (P1 & 0x01) { }
x = (a << 8) | b;

4指针

指针是 C 最出名也最容易劝退的地方。但对你来说它其实只有两件实际用途：

1. 让函数能修改外面的变量（C 没有引用，只能靠指针）
2. 用地址直接访问硬件寄存器（单片机的命根子）

两个符号：& 和 *

#include <stdio.h>
int main(void){
    int a = 10;
    int *p = &a;        // p 存放 a 的地址

    printf("%d\n", a);    // 10        —— a 的值
    printf("%p\n", (void*)p); // 0x7ffd... —— a 的地址
    printf("%d\n", *p);   // 10        —— 顺着地址取出来的值

    *p = 20;              // 通过指针修改 a
    printf("%d\n", a);    // 20
    return 0;
}

用途一：让函数修改外部变量（替代 C++ 的引用）

这是你从 C++ 过来最容易写错的地方：

// ===== C++ 的写法（C 里不支持）=====
void addOne(int &x) { x++; }      // ✗ C 没有引用
int a = 5; addOne(a);             // a 变成 6

// ===== C 的写法：传指针 =====
void addOne(int *x) { (*x)++; }   // ✓ 注意括号不能省！
int a = 5; addOne(&a);            // a 变成 6

用途二：直接访问寄存器（单片机核心）

芯片手册会告诉你「某个功能对应的寄存器在地址 0x80」，代码就是：

/* 把 0x80 这个地址当成一个可读写的 8 位寄存器 */
*(volatile unsigned char *)0x80 = 0x55;

/* 拆开看，从里往外读：*/
// 0x80                   一个整数
// (unsigned char *)0x80  把它当成「指向 8 位无符号数的指针」
// volatile               告诉编译器：这个值随时可能自己变，别优化
// 最前面的 *             往这个地址里写 0x55

/* 读出寄存器的值 */
unsigned char v = *(volatile unsigned char *)0x80;

你可能会问：那 P1 = 0x55; 是怎么来的？就是芯片头文件里替你把上面那句写成了 sfr P1 = 0x80;，让你能直接写名字。所以两种写法是同一件事。

指针与数组的关系

int a[5] = {10, 20, 30, 40, 50};
int *p = a;          // 数组名本身就是首元素的地址，不用写 &a[0]

printf("%d\n", a[2]);    // 30
printf("%d\n", *(a+2));  // 30   —— a[i] 本质就是 *(a+i)
printf("%d\n", p[2]);    // 30   —— 指针也能用下标

所以 a[i] 只是 *(a+i) 的语法糖。理解这一点，第 5 讲的字符串就通了。

指针的坑

// 坑 1：野指针 —— 没初始化的指针指向随机地方
int *p;          // p 里是垃圾值
*p = 5;          // ✗ 程序崩溃
int *p = NULL;   // ✓ 先给个 NULL

// 坑 2：用之前不检查
if (p != NULL) { *p = 5; }   // ✓ 好习惯

// 坑 3：返回局部变量的地址
int *bad(void) {
    int x = 10;
    return &x;   // ✗ x 是局部变量，函数返回后它就没了
}

5数组与字符串

你学过的数组在 C 里一模一样，唯一区别：C 没有 string，字符串就是 char 数组。

字符串 = char 数组 + 结束符 '\0'

// 两种等价的写法
char s1[] = "hello";                        // 编译器自动补 '\0'，共 6 字节
char s2[] = {'h','e','l','l','o','\0'};     // 手动写，必须自己加 '\0'

// 长度
printf("%d\n", (int)sizeof(s1));   // 6  —— 数组占几个字节（含 '\0'）
printf("%d\n", (int)strlen(s1));   // 5  —— 字符串有几个字符（不含 '\0'）

char s[3] = {'a','b','c'};   // ✗ 没有 '\0'
printf("%s\n", s);           // 会打印出 abc 后面一串随机字符

char s[4] = {'a','b','c','\0'};  // ✓ 正确

string.h 常用函数

C 没有 s.length()，这些是你要改用函数的地方：

#include <stdio.h>
#include <string.h>

int main(void){
    char a[20] = "hello";
    char b[20] = "world";

    printf("%d\n", (int)strlen(a));      // 5

    strcpy(a, b);                        // a 变成 "world"
    printf("%s\n", a);

    strcat(a, "!");                      // a 变成 "world!"
    printf("%s\n", a);

    if (strcmp(a, "world!") == 0)        // 比较内容要用 strcmp
        printf("相等\n");

    return 0;
}

char s[5];
strcpy(s, "hello world");   // ✗ 目标只有 5 字节，写进去 12 字节 → 内存被踩坏
char s[20];
strcpy(s, "hello world");   // ✓

读整行字符串

// scanf("%s") 遇到空格就停 —— 只能读一个单词
scanf("%s", s);              // 输入 "hello world" 只会读到 "hello"

// 想读整行（含空格），用 fgets
fgets(s, sizeof(s), stdin);  // ✓ 连空格一起读，最多读 sizeof(s)-1 个字符
// 注意 fgets 会把行尾的 '\n' 也读进来，通常要手动去掉：
s[strcspn(s, "\n")] = '\0';

单片机里几乎不用读整行（数据来自串口和传感器），但你在洛谷做题会用得上。

二维数组（你 Day 7 学过，语法完全一样）

int a[3][4];                  // 3 行 4 列
a[1][2] = 5;

// 初始化
int b[2][3] = { {1,2,3}, {4,5,6} };

6结构体 / typedef / 枚举 / 联合

你在 ACM Day 11 学过 C++ 的 struct。C 里它几乎一样，但有两个必须记住的差别。

差别一：定义变量时必须写 struct 关键字（除非用 typedef）

// C++ 写法
struct Point { int x, y; };
Point p;                  // ✓ C++ 可以直接用 Point

// C 里这样写会报错
struct Point { int x, y; };
Point p;                  // ✗ C 必须写 struct Point p;
struct Point p;           // ✓ 但要一直带着 struct 很烦

所以 C 代码里到处都是 typedef —— 给类型起个别名：

typedef struct Point {
    int x;
    int y;
} Point;                  // 现在 Point 就是一个类型名了

Point p;                  // ✓ 和 C++ 一样好写
p.x = 3; p.y = 4;

差别二：C 的结构体里不能有函数

// C++ 可以
struct Led {
    int pin;
    void on() { /* ... */ }   // ✗ C 不允许
};

// C 的做法：结构体只放数据，操作写成独立的函数
typedef struct {
    unsigned char pin;
    unsigned char state;
} Led;

void Led_On(Led *l)  { l->state = 1; }
void Led_Off(Led *l) { l->state = 0; }

这就是你在单片机代码里看到的 XXX_Init()、XXX_Send() 这种命名风格的由来 —— 假装是「对象的方法」，实际是普通函数。

箭头 -> ：指针访问成员

Point p = {3, 4};
Point *ptr = &p;

printf("%d\n", p.x);        // 3   —— 变量用点
printf("%d\n", (*ptr).x);   // 3   —— 先解引用再取成员（写法啰嗦）
printf("%d\n", ptr->x);     // 3   —— 箭头是上面那种写法的简写

记住：变量用 .，指针用 ->。

单片机实战：用结构体映射一组寄存器

这是嵌入式里最重要的结构体用法。把连续地址的一堆寄存器，用一个结构体描述出来：

/* STM32 风格：一个 GPIO 端口有 7 个 32 位寄存器，地址连续排列 */
typedef struct {
    volatile uint32_t MODER;    // 偏移 0x00
    volatile uint32_t OTYPER;   // 偏移 0x04
    volatile uint32_t OSPEEDR;  // 偏移 0x08
    volatile uint32_t PUPDR;    // 偏移 0x0C
    volatile uint32_t IDR;      // 偏移 0x10
    volatile uint32_t ODR;      // 偏移 0x14
} GPIO_TypeDef;

/* 把基地址强制转换成这种结构体指针 */
#define GPIOA  ((GPIO_TypeDef *)0x40020000)

/* 之后就能像访问成员一样访问寄存器 */
GPIOA->MODER |= (1 << 10);   // 配置 PA5
GPIOA->ODR   |= (1 << 5);    // 点亮 PA5

原理就是第 4 讲的指针：结构体成员在内存里是依次排列的，所以 GPIOA->OTYPER 自然就落在 0x40020004 上。

枚举 enum

// 给一组状态起名字，比裸数字可读得多
typedef enum {
    LED_OFF = 0,
    LED_ON  = 1,
    LED_BLINK = 2
} LedState;

LedState s = LED_ON;

C 的 enum 本质就是整数，可以直接和 int 混用（这点比 C++ 宽松）。

联合 union（单片机专属技巧）

联合的所有成员共用同一块内存。用它可以在「一个 16 位数」和「两个 8 位数」之间自由切换 —— 处理传感器数据时特别好用：

typedef union {
    uint16_t word;          // 整体当 16 位看
    uint8_t  bytes[2];      // 拆成两个 8 位看
} Data16;

Data16 d;
d.word = 0x1234;
printf("%02X %02X\n", d.bytes[0], d.bytes[1]);   // 34 12（小端）

不用 union 的话，你就得手写 (v >> 8) & 0xFF 和 v & 0xFF —— 第 3 讲学过，但 union 更直观。

7函数、宏与多文件工程

函数：和 C++ 基本一样，除了没有重载/默认参数/引用

// 函数声明（放在使用之前，或者放在 .h 里）
int add(int a, int b);

// 函数定义
int add(int a, int b) {
    return a + b;
}

// 没有返回值就写 void
void Led_On(void);      // (void) 表示"不接收参数"，比空括号更严谨

// C++ 允许（重载）
int  max(int a, int b);
double max(double a, double b);   // ✗ C 报重复定义

// C 的做法：起不同名字
int    max_int(int a, int b);
double max_double(double a, double b);

宏 #define

// ① 常量宏 —— 单片机里到处都是
#define LED_PIN     1
#define MAX_SIZE    100
#define PI          3.1415926

// ② 带参数的宏 —— 必须给每个参数和整体都加括号！
#define SQUARE(x)   ((x) * (x))
#define MAX(a, b)   ((a) > (b) ? (a) : (b))

// ③ 位掩码宏（配合第 3 讲的位运算）
#define BIT(n)      (1 << (n))
#define LED_ON()    (P1 &= ~BIT(LED_PIN))
#define LED_OFF()   (P1 |=  BIT(LED_PIN))

#define SQUARE(x)  x * x

SQUARE(2+3)   // 展开成 2+3 * 2+3 = 2+6+3 = 11  ← 错！应该是 25

#define SQUARE(x)  ((x) * (x))     // ✓ 每个参数和整体都加括号
SQUARE(2+3)   // 展开成 ((2+3) * (2+3)) = 25  ✓

#include：尖括号和双引号的区别

多文件工程：单片机项目的标准结构

真实项目绝不会把所有代码塞进 main.c。典型结构：

project/
├── main.c          // 主程序：初始化 + 主循环
├── led.c           // LED 模块的实现
├── led.h           // LED 模块对外暴露的接口
├── uart.c / uart.h // 串口模块
└── timer.c / timer.h

led.h —— 只放「别人需要知道的东西」：

#ifndef __LED_H__          // 头文件保护，防止被重复包含
#define __LED_H__

#include <reg51.h>

// 宏定义
#define LED_PORT   P1
#define LED_COUNT  8

// 函数声明（只有声明，没有实现）
void Led_Init(void);
void Led_On(unsigned char index);
void Led_Off(unsigned char index);
void Led_Blink(unsigned char index, unsigned int ms);

#endif

led.c —— 放实现：

#include "led.h"

void Led_Init(void) {
    LED_PORT = 0xFF;      // 全部熄灭（低电平点亮）
}

void Led_On(unsigned char index) {
    LED_PORT &= ~(1 << index);     // 第 3 讲的位运算
}

void Led_Off(unsigned char index) {
    LED_PORT |= (1 << index);
}

main.c —— 只关心流程：

#include "led.h"
#include "uart.h"

void delay(unsigned int ms);

void main(void)
{
    Led_Init();
    Uart_Init();

    while (1) {
        Led_On(0);
        delay(500);
        Led_Off(0);
        delay(500);
    }
}

extern 和 static

// extern：告诉编译器"这个变量/函数在别的文件里定义了"
extern unsigned int g_tick;      // 声明（不分配内存）
unsigned int g_tick = 0;         // 定义（分配内存，只能有一处）

// static 修饰全局变量/函数：只在本文件可见
static void internal_helper(void) { }   // 别的 .c 文件看不到它
static unsigned char buf[16];           // 别的 .c 文件访问不到

static 的作用是「限制作用域在本文件」，相当于给模块做了封装 —— 别人只能通过你在 .h 里声明的接口来用它。

8const / volatile / static

这三个关键字在 PC 上不太要紧，在单片机上是决定程序能不能跑起来的东西。

volatile —— 嵌入式第一关键字

// 错误示范：等待串口收到数据
unsigned char flag = 0;

void Uart_ISR(void) interrupt 4    // 中断服务函数
{
    flag = 1;                      // 中断里改 flag
}

void main(void)
{
    while (flag == 0);             // ✗ 编译器认为 flag 永远是 0
                                   //   于是把整个循环优化掉 → 死循环卡死
}

// 正确写法：加 volatile
volatile unsigned char flag = 0;

void Uart_ISR(void) interrupt 4
{
    flag = 1;
}

void main(void)
{
    while (flag == 0);             // ✓ 每次都真的去内存里读 flag
}

规则：凡是满足下面任一条的变量，都要加 volatile：

• 会被中断服务函数修改
• 对应硬件寄存器（值可能被硬件自己改变）
• 在多任务/主循环与中断之间共享

这也是为什么第 6 讲那个 GPIO_TypeDef 里每个成员都写了 volatile —— 那些地址的内容是硬件在改，不是程序在改。

const —— 只读

// 常量：放在 Flash 里，不占 RAM（单片机 RAM 很宝贵）
const unsigned char seg_code[10] = {0xC0,0xF9,0xA4,0xB0,0x99,
                                    0x92,0x82,0xF8,0x80,0x90};

// const 指针的两种位置，含义不同
const char *p1;        // p1 指向的内容不能改，p1 自己能改
char * const p2 = buf; // p2 自己不能改，指向的内容能改
const char * const p3 = "abc";  // 都不能改

单片机里把大数组（数码管段码表、字库）标成 const 是省 RAM 的常规操作。51 只有 128~512 字节 RAM，一张 10 字节的表都要省。

static 的两种用法

// 用法一：修饰全局变量/函数 → 只在本文件可见（第 7 讲讲过）
static unsigned char internal_buf[16];

// 用法二：修饰函数内部的变量 → 只初始化一次，函数退出后值还在
void Count(void)
{
    static unsigned int times = 0;   // 只初始化一次
    times++;
    printf("被调用了 %u 次\n", times);
}
// 第 1 次调用输出 1，第 2 次输出 2 …… 而不是每次都输出 1

三者的速记

9C++→C 速查对照表

写题或写单片机代码时遇到「这个在 C 里怎么写」，回来查这张表。

基础

类型

数组与容器

函数与结构

C 独有（C++ 里也能用，但单片机里天天见）

10易错清单（含你踩过的坑）

一、你已经踩过的两个坑，在 C 里更危险

// C 里正确的写法
int arr[10005];
for (int i = 0; i <= a; i++) arr[i] = 1;   // 逐个赋值

// 或者用 memset（只能填 0 或 -1 这种"字节重复"的值）
#include <string.h>
int arr[10005];
memset(arr, 0, sizeof(arr));   // 全 0

int c;              // ✗ 垃圾值
printf("%d\n", c);  // 输出什么完全看运气

int c = 0;          // ✓ 声明时就给初值

二、C 语言通用易错清单

三、单片机特有的"现象 → 原因"排查表

11练习：把做过的题用 C 重写

最好的巩固方式：把你已经 AC 过的题，用 C 再写一遍。这样你只需要专注在「输入输出换写法」上，不用分心算法。

#include <stdio.h>

int main(void)
{
    int arr[10005];
    int a, b, i, k, y = 0;

    scanf("%d %d", &a, &b);

    for (i = 0; i <= a; i++) {
        arr[i] = 1;              // 0..a 每个位置都种树
    }

    for (k = 0; k < b; k++) {
        int m, n;
        scanf("%d %d", &m, &n);
        for (i = m; i <= n; i++) {
            arr[i] = 0;          // 区间内移除
        }
    }

    for (i = 0; i <= a; i++) {
        if (arr[i]) y++;
    }

    printf("%d\n", y);
    return 0;
}

#include <stdio.h>

int main(void)
{
    int best = 0;      // 目前最大总时长
    int day  = 0;      // 对应的星期几，0 表示不会不高兴
    int i;

    for (i = 1; i <= 7; i++) {
        int a, b, sum;
        scanf("%d %d", &a, &b);
        sum = a + b;

        // 严格大于：并列时保留更早的一天
        if (sum > 8 && sum > best) {
            best = sum;
            day  = i;
        }
    }

    printf("%d\n", day);
    return 0;
}

40

41
40
32
1

#include <stdio.h>

int main(void)
{
    int v;
    scanf("%d", &v);

    printf("%d\n", v |  (1 << 0));   // 置位：最低位变 1
    printf("%d\n", v & ~(1 << 0));   // 清零：最低位变 0
    printf("%d\n", v ^  (1 << 3));   // 翻转：第 3 位取反

    if (v & (1 << 5))               // 读位：第 5 位
        printf("1\n");
    else
        printf("0\n");

    return 0;
}