C++: 基础

gcc --version
g++ --version

#include <iostream>
using namespace std;
int main() {
        cout << "11111" << endl << endl << endl;
        return 0;
}

#include <iostream>
using namespace std;

int main() {

    return 0;
}

#include <iostream>
using namespace std;
int main() {
        // 单行注释
        /*
        多行注释
        22
        33
        */
        cout << "11111" << endl;
        return 0;
}

#include <iostream>
using namespace std;

int main() {
        // 变量的定义
        // 数据类型 变量名 = 初始值;
        int x = 1314 + 6;
        cout << "x = " << x << endl;
        /*
        int v; // 变量没有初始化，如果用它了就会报错
        cout << "v = " << v << endl;*/

        return 0;
}

#include <iostream>
using namespace std;

#define X "你好"
#define Y "世界"
int main() {

        cout << X << endl << Y << endl;
        return 0;
}

#include <iostream>
using namespace std;

#define X 1+2

int main() {

        cout << X * X << endl;
        // 相当于，把X替换为1+2，输出为5
        cout << 1 + 2 * 1 + 2 << endl;
        return 0;
}

#include <iostream>
using namespace std;

#define X (1+2)

int main() {

        cout << X * X << endl;
        // 相当于，把X替换为(1+2)，输出为9
        cout << (1 + 2) * (1 + 2) << endl;
        return 0;
}

const int x = 7;

// x = x + 1; // 常量不可以被修改

int obj;

#include <iostream>
using namespace std;

/*
short      2字节  2^16       (-2^15 -> 2^15-1) (-32768 -> 3267)
int        4      2^32       (-2^31 -> 2^31-1)
long       win 4; linux 4或8
long long  8      2^64       (-2^63 -> 2^63-1)
*/
int main() {
        short a = 32768;  //整数溢出。想像成从-32768到32767是一个环
        int b = 1;
        long c = 1;
        long long d = 1;
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
        cout << "c = " << c << endl;
        cout << "d = " << d << endl;
        return 0;
}

a = -32768
b = 1
c = 1
d = 1

#include <iostream>
using namespace std;

int main() {
        short a = 1;
        int b = 1;
        long c = 1;
        long long d = 1;
        cout << "short size = " << sizeof(short) << endl;
        cout << "int size = " << sizeof(int) << endl;
        cout << "long size = " << sizeof(long) << endl;
        cout << "long long size = " << sizeof(long long) << endl;


        return 0;
}

/*
short size = 2
int size = 4
long size = 4
long long size = 8
*/

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

/*
float   4字节
double  8字节
*/
#define eps 1e-7
int main() {
        float a = 3.1415926f;
        double b = 3.1415926;
        double c = 1.5e5; //1.5*10^5
        double d = 1.5e-5; //1.5*10^-5
        cout << a << endl;
        cout << b << endl;
        cout << c << endl;
        cout << d << endl;
        cout << eps << endl;
        // 输出前做精度控制
        cout << setprecision(10) << a << endl;
        cout << setprecision(10) << b << endl;
        double x = 1.0 / 2343242477777777773 * 2343242477777777773;
        // fabs 浮点数之间的比较。下面给出x-1小于eps时，认为x是等于1的。
        if (fabs(x - 1) < eps) {
                cout << "hahah" << endl;
        }
        cout << x << endl;
        return 0;
}

3.14159
3.14159
150000
1.5e-05
1e-07
3.141592503 // float精度误差
3.1415926
hahah
1

#include <iostream>
using namespace std;


int main() {
        char a = 'y'; // 字符是用单引号括起来的。
        char b = 'z';
        cout << a << endl;
        cout << (int)a << endl; // 转换成整数
        cout << (int)b << endl;
        cout << b - a << endl;
        b = 120;
        cout << b << endl;
        cout << sizeof(a) << endl;

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        char a = '\n';
        char b = '\t';
        cout << (int)a << endl;
        cout << "abc" << a; // \n是一个换行符
        cout << "abc\tdef"; // \t 反斜杠
        cout << "abc\\def\n"; // \\ 变成1个杠
        cout << "abc\0def" << endl; // \0表示字符串结束
        cout << "abc\088def" << endl;
        cout << "abc\077def" << endl;
        cout << "aa\"bb" << endl; // 字符串中加引号

        return 0;
}

/*
\0xx  8进制
\077  表示?
\088  8进制中没有8，所以是\0
*/

10
abc
abc     defabc\def
abc
abc
abc?def
aa"bb

#include <iostream>
#include <string>
using namespace std;

/*
char 变量名[] = "";
*/
int main() {
        // c 风格
        char a[] = "你好啊";
        cout << sizeof(a) << endl;

        // c++风格
        string b = "你好";
        cout << b + "世界"  << endl;

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        bool flag1 = false; // 0 假
        bool flag2 = true;  // 1 真
        cout << flag1 << endl << flag2 << endl;
        flag1 = !flag1; // !表示取反
        cout << flag1 << endl << flag2 << endl;
        cout << sizeof(flag1) << endl;

        return 0;
}

#include <iostream>
// i input
// o output
#include <string>
using namespace std;

int main() {
        // 1. 整型的输入
        int a = 5;
        cin >> a;
        cout << "a的值变成了" << a << endl;
        // 2. 浮点型的输入
        double b = 7;
        cin >> b;
        cout << "b的值变成了" << b << endl;
        // 3. 字符型的输入
        char c = 7;
        cin >> c;
        cout << "c的值变成了" << c << endl;
        // 4. 字符串型
        string d = "";
        cin >> d;
        cout << "d的值变成了" << d << endl;
        // 5. 布尔型
        bool e = false;
        cin >> e;
        cout << "e的值变成了" << e << endl;
        return 0;
}

12
a的值变成了12
6.22
b的值变成了6.22
a
c的值变成了a
akdjf
d的值变成了akdjf
4
e的值变成了1

#include <iostream>
using namespace std;

int main() {
        int x = 6;
        int y = 9;

        x = y; // 将y的值赋值给x
        cout << x << endl; // 9

        x += y; // x = x + y;
        cout << x << endl; // 18

        x -= y; // x = x - y;
        cout << x << endl; // 9

        x *= y; // x = x * y;
        cout << x << endl; // 81

        x /= y; // x = x / y;
        cout << x << endl; // 9

        x %= y; // x = x % y;
        cout << x << endl; // 0

        return 0;
}

#include <iostream>
using namespace std;

/*
== 等于
!= 不等于
<  小于
>  大于
<= 小于等于
>= 大于等于
*/
int main() {
        int a = 6;
        int b = 9;

        cout << (a == b) << endl; // 0 真用1表示，假用0表示
        cout << (a != b) << endl;
        cout << (a < b) << endl;
        cout << (a > b) << endl;
        cout << (a <= b) << endl;
        cout << (a >= b) << endl;

        return 0;
}

#include <iostream>
using namespace std;

/*
&& 与
|| 或
!  非

优先级
|| < && < !
*/
int main() {
        // 1. 与运算: 有假必假
        cout << (0 && 0) << endl;
        cout << (0 && 2) << endl;
        cout << (2 && 0) << endl;
        cout << (2 && 2) << endl;
        cout << "----" << endl;

        // 2. 或运算: 有真必真
        cout << (0 || 0) << endl;
        cout << (0 || 2) << endl;
        cout << (2 || 0) << endl;
        cout << (2 || 2) << endl;
        cout << "----" << endl;

        // 3. 非运算: 非真即假，非假即真
        cout << (!0) << endl;
        cout << (!2) << endl;
        cout << "----" << endl;

        // 复合运算：运算符之间的嵌套
        int a = !((5 > 4) && (7 - 8) && (0 - 1)); // !(1 && 1 && 1) 有假必假，但没有假
        cout << a << endl; // 0

        int b = !(1 || 1 && 0); // 与的优化级比或高
        cout << b << endl; // 0

        return 0;
}

0
0
0
1
----
0
1
1
1
----
1
0
----
0
0

#include <iostream>
using namespace std;

/*
* 逗号表达式优先级很低，比赋值运算符还低
* 逗号表达式是单个分别计算，把最后一个逗号右边的内容作为整个表达式的值
*/
int main() {
        int a = 1;
        a = 5 - 6, 8 + 9, 100 / 7; // -1, 17, 14
        // 上面认为是这样的， (a = 5 - 6), (8 + 9), (100 / 7);
        cout << a << endl; // -1 

        a = (5 - 6, 8 + 9, 100 / 7); // -1, 17, 14
        cout << a << endl; // 14

        // 1. 案例1
        int x = 4;
        int y = 5;
        int tmp = x;
        x = y;
        y = tmp;
        cout << x << ' ' << y << endl; // 5 4

        tmp = x, x = y, y = tmp;
        cout << x << ' ' << y << endl; // 4 5

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        // 1. 数组的定义
        // 数据类型 数组名[数字/常量表达式];  // 数字代表有多少个元素
        int a[1024] = { 1,2,3,45 }; // 具有1024个元素的整型数组
        double b[520];
        char c[1314]; // 具有1314个元素的字符数组
        // double a[1024]; 错误，不能用相同变量
        // a[0] a[1] a[2]
        //int n = 1000;
        //int d[n]; 错误，方括号内必须是常量
        int x1[10], x2[20], x3[30];

        // 注意
        // 1. 数组内的所有元素类型都是相同的
        // 2. 数组名其实就是变量名，不能和其它变量同名，并且要满足标识符的那些规则
        // 3. 数组下标是从0开始。
        // 4. 方括号里是个变量，是不合理的。必须是常量，不是常量就不知道怎么分配内存。
        // 5. 数组定义可以写在一行上

        // 2. 数组元素的访问
        // 数组名[下标]
        a[0], a[1023];
        for (int i = 0; i < 4; ++i) {
                cout << a[i] << endl;
        }

        // 3. 逆序输出
        // 输入一个n(n<100)，和n个数，请逆序输出这n个数
        int n;
        int x[100];
        cin >> n;
        for (int i = 0; i < n; ++i) {
                cin >> x[i];
        }
        for (int i = n - 1; i >= 0; --i) {
                cout << x[i] << ' ';
        }
        cout << endl;

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        // 1. 二维数组的定义
        // 数组类型 数组名[行][列]
        // 数组名就是这个数组的变量名；行代表有多少行；列就是每一行上有多少个元素

        // 定义一个3行4列的二维数组
        int arr[3][4];
        for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 4; ++j) {
                        arr[i][j] = i * j;
                }
        }

        // 初始化部分元素时，未初始化的部分默认为0
        int b[4][4] = {
                {1, 2},
                {2, 3},
                {6, 7 , 8},
                {9, 1}
        };
        for (int i = 0; i < 4; ++i) {
                for (int j = 0; j < 4;  ++j) {
                        cout << b[i][j] << ' ';
                }
                cout << endl;
        }
        // 数组名其实代表了这个数组元素的首地址

        return 0;
}

#include <iostream>
using namespace std;

/*
    1. 返回值类型：可以是整型、浮点型、字符串类型、字符类型等
        2. 函数名
        3. 参数列表：圆括号加上逗号分隔的表达式组成
        4. 函数体
        5. return 表达式(返回值)

返回值类型 函数名(参数列表)
{
    函数体
    return 表达式(返回值);
}
*/

int add(int a, int b) 
{
        int c = a + b;
        return c;
}

void printAaddB(int a, int b) // void 返回类型为空的函数
{
        int c = a + b;
        cout << c << endl;
}

int max1(int a, int b)
{
        return a > b ? a : b;
}

int main() {
        int ret = add(1, 7); // 函数的调用
        cout << ret << endl;
        return 0;
}

#include <iostream>
using namespace std;

/*
    1. 返回值类型：可以是整型、浮点型、字符串类型、字符类型等
        2. 函数名
        3. 参数列表：圆括号加上逗号分隔的表达式组成
        4. 函数体
        5. return 表达式(返回值)

返回值类型 函数名(参数列表)
{
    函数体
    return 表达式(返回值);
}
*/

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

int max(int a, int b) {
        return a > b ? a : b;
}

int sum(int n) {
        /* 枚举算法
        int ret = 0;
        for (int i = 0; i < n; ++i) {
                ret += i;
        }
        return ret;
        */
        return (1 + n) * n / 2; // 公式
}
int main() {
        // 1. 加法的调用
        int a = add(1, 7); // 函数的调用
        int b = add(a, 9);
        cout << b << endl;

        // 2. 最大值的调用
        int c = max(a, b);

        // 3. 求1到n的和
        int n;
        cin >> n;
        int d = sum(n);
        cout << d << endl;
        return 0;
}

#include <iostream>
using namespace std;

/*
| a | b | a | b | tmp |
| 6 | 9 | 6 | 9 |  6  |

| a | b | a | b | tmp |
| 6 | 9 | 9 | 6 |  6  |
函数执行完毕后，函数内部变量会被销毁掉，a, b, tmp

| a | b |
| 6 | 9 |
*/
void swap(int a, int b) {
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
        cout << "----" << endl;
        int tmp = a;
        a = b;
        b = tmp;
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;
        cout << "----" << endl;
}

int main() {
        int a = 6;
        int b = 9;
        swap(a, b); // 值传递。传进去的数只是拷贝了一份，并不是原来的那个数据
        // 虽然函数里进行了交换，但外部无法进行交换
        // 学完指针就知道怎么进行交换了
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;

        return 0;
}

#include <iostream>
using namespace std;

// C++程序从上往下执行

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

int main() {
        int x, y;
        cin >> x >> y;
        int z = add(x, y);
        cout << z << endl;

        return 0;
}

#include <iostream>
using namespace std;

// C++程序从上往下执行
// 把函数写在main的后面就需要声明它
int add(int a, int b);
int add(int, int); // 只要把类型定义好就可以，声明多次也是可以的

// 场景
void func2(int); // func1需要提前调用func2时，需要提前声明
void func1(int x) {
        if (x <= 0) {
                return;
        }
        cout << "func1: " << x << endl;
        func2(x-1);
}
void func2(int x) {
        cout << "func2: " << x << endl;
        func1(x-1);
}

int main() {
        int x, y;
        cin >> x >> y;
        int z = add(x, y);
        cout << z << endl;

        func1(10);
        return 0;
}

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

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

int main() {
        int a;
        //scanf("%d", &a); // 报错 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
        //scanf_s("%d", &a);
        scanf("%d", &a); // 使用#define _CRT_SECURE_NO_WARNINGS

        //C++中还有个函数strcpy
        char str[10];
        //strcpy(str, "hahahaha"); // 报错, 与scanf相同
        //strcpy_s(str, "hahahaha");
        strcpy(str, "hahahaha"); // 使用#define _CRT_SECURE_NO_WARNINGS
        return 0;
}

/*



________________________________________________________________________________________
0X4B32F824|0X4B32F825|0X4B32F826|...|...|...|...|...|                                       内存地址
    11          9                                                                           变量值
    a           b                                                                           变量名
----------------------------------------------------------------------------------------

char a = 10;
char b = 5;
a = 11;
b = 9;

____________________________________________
0x00000010|0x00000011|0x00000012|0x00000013|      内存地址
0X4B32F824                                        变量值
    pa                                            变量名

*/


#include <iostream>

using namespace std;

int main() {

    char a = 10;
    // cout << (&a) << endl; // &a表示a的地址
    // printf( "%#X", &a );   // 0X4B32F824 格式字符串不匹配：%#X 用于格式化无符号整数，但 &a 是 char* 类型
    printf("%p", (void*)&a);   // 使用 %p 格式化指针，并转换为 void*
    return 0;
}

/*
________________________________________________________________________________________
0X00000004|0X00000008|...|...|...|...|...|...|                                              内存地址
        10         20                                                                           变量值
        a           b                                                                           变量名
----------------------------------------------------------------------------------------

____________________________________________
0x00000010|0x00000011|0x00000012|0x00000013       内存地址
0X00000004                                        变量值
        pa                                            变量名
--------------------------------------------------

*/
#include <iostream>
using namespace std;

int main() {
        int a = 10;
        int b = 20;
        // 1. 指针变量的定义
        // 数据类型 * 指针变量名;
        int* pa; // int  * pa; int   *pa; // *号位置跟int、pa或中间都可以
        pa = &a;

        // 指针变量可以多次赋值
        //pa = &b;

        printf("%#X %#X\n", &a, pa); // pa存储的就是a的地址

        // 2. 指针的解引用
        // *指针变量名 = 数值;
        *pa = 7; // *pa 把pa地址里面的值取出来，并且把位置设置成了7。pa指向的地址其实就是a
        cout << a << ' ' << (*pa) << endl; // 7 7
        cout << "-----" << endl;

        // * 和 取地址& 的关系
        // 理解成 * 和 & 是互逆的关系，一个是加号一个是减号
        //*&a 等价于 *(&a) = *pa = a
        //&*pa = &(*pa) = &a = pa;
        cout << (*&a) << endl;
        cout << (*(&a)) << endl;
        cout << (*pa) << endl;
        cout << (a) << endl;
        cout << "-----" << endl;
        cout << (&*pa) << endl;
        cout << (&(*pa)) << endl;
        cout << (&a) << endl;
        cout << (pa) << endl;
        // *号作用：乘法、定义指针、解引用

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        cout << sizeof(int*) << endl;
        cout << sizeof(short*) << endl;
        cout << sizeof(char*) << endl;
        cout << sizeof(long*) << endl;
        cout << sizeof(long long*) << endl;
        cout << sizeof(double*) << endl;
        cout << sizeof(float*) << endl;
        // 结果都是8。
        // 因为所有的指针类型大小是一样的，只跟操作系统有关。
        // 32操作系统，字节数为4；64操作系统，字节数为8；

        return 0;
}

#include <iostream>
using namespace std;

int main() {
        // 1.  空指针
        int* p = NULL;

        // 如果是NULL的情况下，解引用会报错，因为拿不到它的值
        //cout << (*p) << endl;

        // 2. 野指针
        p = (int *)0x121412;
        // 如果是野指针的情况下，解引用会报错，因为不知道
        cout << (*p) << endl;

        return 0;
}

int main() {
    datas ds;
    cout << &ds.i << "," << &ds.d << "," << (void*)ds.s << endl;
}

#include <iostream>

using namespace std;

int main() {
    int(*p)[5];
    int a[4][5] = {
        {4,3,2,1,0},
        {9,8,7,6,5},
        {6,7,8,9,0},
        {5,6,7,8,9}
    };
    p = a;
    cout << p << endl;      // E0    -> EF  ->  F4
    cout << p + 1 << endl;  // F4
    // 20 个字节
    // 20 = 4 * 5 = sizeof(int) * 5

    cout << p << ':' << &a[0] << endl; // 完全相等
    cout << p + 1 << ':' << &a[1] << endl;

    return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 1. 结构体定义
// struct 结构体名 { 结构体成员变量列表 };
// 在c++中结构体在定义时，struct关键字是不能省略。在创建结构体变量时可以省略
struct Book {
        string name;
        double price;
        int value;
};
struct Apple {
        string name;
        double price;
        int value;
}cpp;

// 2. 创建结构体

int main() {
        // 2.1
        Book c; // 创建c语言的书
        c.name = "C语言程序设计";
        c.price = 6.6;
        c.value = 10;
        cout << c.name << ' ' << c.price << ' ' << c.value << endl;

        // 2.2 通过初始化列表方式创建
        Book py = { "Python编程", 1999, 10 };
        cout << py.name << ' ' << py.price << ' ' << py.value << endl;

        // 2.3 直接在结构体定义完后加上
        cpp.name = "C++零基础编程";
        cpp.price = 9999;
        cpp.value = 100000;
        cout << cpp.name << ' ' << cpp.price << ' ' << cpp.value << endl;

        return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 1. 结构体定义
// struct 结构体名 { 结构体成员变量列表 };
// 在c++中结构体在定义时，struct关键字是不能省略。在创建结构体变量时可以省略
struct Book {
        string name;
        double price;
        int value;
}cpp;

int main() {
        // 2. 创建一个结构体数组
        // 结构体名 数组名[元素个数] = { {}, {}, ...};
        Book books[3] = {
                {"C语言程序设计", 199.99, 7},
                {"Python零基础",399.99, 9},
                {"C++零基础", 39.99, 10000}
        };
        // 修改
        books[2].name = "C++从入门到入土"; 
        // 查找
        for (int i = 0; i < 3; ++i) {
                cout << books[i].name << ' ' << books[i].price << ' ' << books[i].value << endl;
        }

        return 0;
}

#include <iostream>
#include <string>
using namespace std;

// 1. 结构体定义
// struct 结构体名 { 结构体成员变量列表 };
// 在c++中结构体在定义时，struct关键字是不能省略。在创建结构体变量时可以省略
struct Book {
        string name;
        double price;
        int value;
}cpp;

int main() {
        Book b = { "C语言", 99.99, 7 };
        Book c = b; // 拷贝
        c.name = "C语言入门";
        cout << b.name << ' ' << b.price << ' ' << b.value << endl;

        // 结构体指针
        Book* pb = &b;
        pb->name = "C++"; // 当是结构体指针时，就不能用.点来访问，要使用箭头 ->
        // pb拿到了b的地址，改pb时，相当于改b，所以下面输出是一样的。
        cout << b.name << ' ' << b.price << ' ' << b.value << endl;
        cout << pb->name << ' ' << pb->price << ' ' << pb->value << endl;

        return 0;
}

#include <iostream>
using namespace std;

struct Point {
        double x, y;
};
struct Circle {
        Point pt;
        double radius;
};

struct Circles {
        int size;
        Circle c[100];
};

int main() {
        Circle c;
        c.pt.x = 9;
        c.pt.y = 8;
        c.radius = 5;

        Circles cs = {
                2, {
                        {{9,8}, 5},
                        {{2,1}, 1}
        }
        };
        for (int i = 0; i < cs.size; ++i) {
                Circle tmp = cs.c[i];
                cout << "(" << tmp.pt.x << "," << tmp.pt.y << ")" << tmp.radius << endl;
        }

        return 0;
}

#include <iostream>
using namespace std;

struct Point {
        double x, y;
};
struct Circle {
        Point pt;
        double radius;
};

// 打印圆
void printCircle(const Circle* c) {
        // 这个做好处：1、如果传的是对象，不是指针的话，那么每次调用这个函数都会进行一次拷贝。拷贝有消耗，传地址没消耗
        // 2、它是个只读函数，c不能变
        // c->pt.x += 1; 报错，常量不可修改
        cout << "(" << c->pt.x << "," << c->pt.y << ") " << c->radius << endl;
}

// 实现一个函数：传入一个圆，让圆往x正方向偏移一个位置，往y的负方向偏移两个位置
void moveCircle(Circle *c, int x, int y) {
        //cout << &c << endl;
        c->pt.x += x;
        c->pt.y += y;
}

int main() {
        Circle c = { {9, 8}, 5 };
        //cout << &c << endl;
        moveCircle(&c, 1, -2);
        printCircle(&c);

        return 0;
}

#include <iostream>
using namespace std;

struct DataS {
        int i;
        double d;
        char s[10];
};

union DataU {
        int i;      // 占用4个字节内存
        double d;   // 8
        char s[10]; // 10
}; // 总共这个union占用10个字节内存，但由于字节对齐，实际上占用16个字节内存

// 区别
// 结构体每个成员都有单独的内存，相互之间没有影响。
// 联合体所有成员都是共享内存的，占用的是同一段内存
// 对于联合体，所有成员都从相同的内存地址开始

/*
1、定义和使用分开
union DataU {
        int i;      // 占用4个字节内存
        double d;   // 8
        char s[10]; // 10
};
DataU a, b, c;

2、定义和使用结合
union DataU {
        int i;      // 占用4个字节内存
        double d;   // 8
        char s[10]; // 10
}a, b, c;

3、匿名：不想让别人使用
union {
        int i;      // 占用4个字节内存
        double d;   // 8
        char s[10]; // 10
}a, b, c;
*/

int main() {
        DataS ds;
        cout << &ds.i << "," << &ds.d << "," << (void*)ds.s << endl;

        DataU du;
        cout << &du.i << "," << &du.d << "," << (void*)du.s << endl;
        return 0;
}

000000C66C5DF728,000000C66C5DF730,000000C66C5DF738
000000C66C5DF768,000000C66C5DF768,000000C66C5DF768

#include <iostream>
using namespace std;

union DataU {
        int i;     // 4
        double d;  // 8
        char s[7]; // 7
};

int main() {
        cout << sizeof(DataU) << endl; // 8
        DataU du;
        du.s[0] = 255;   // 在内存中 11111111
        du.s[1] = 1;     // 00000001
        du.s[2] = 0;     // 00000000
        du.s[3] = 0;     // 00000000
        cout << du.i << endl; // 00000000 00000000 00000001 11111111, 511
        // 上面涉及字节序、大小端问题
        du.i = 256;
        cout << (int)du.s[0] << (int)du.s[1] << (int)du.s[2] << (int)du.s[3] << endl; // 0100  其中s

        return 0;
}

#include <iostream>
using namespace std;

struct Info {
        char _name[20];
        int _role; // 角色 老师、学生
        union {
                double score;    // 学生的分数
                char course[20]; // 老师的课
        }_sc;

        // 定义构造函数
        Info(const char name[20], int role, double s, const char c[20]) {
                strcpy_s(_name, name); // 把传入的参数拷贝给_name
                _role = role;
                if (s > 0) _sc.score = s;
                if (strlen(c) > 0) strcpy_s(_sc.course, c);
        };
};
int main() {
        Info a[4] = {
                Info("周老师", 0, -1, "c++"),
                Info("周老师", 0, -1, "Python"),
                Info("张同学", 1, 90, ""),
                Info("肖同学", 1, 88, ""),
        };
        for (int i = 0; i < 4; ++i) {
                if (a[i]._role == 0) {
                        cout << a[i]._name << "是一位老师，他是教" << a[i]._sc.course << "的" << endl;
                }
                else if (a[i]._role == 1) {
                        cout << a[i]._name << "是一位学生，他的分数是" << a[i]._sc.score << endl;
                }
        }
        return 0;
}

#include <iostream>
using namespace std;

// 代码区、全局区、栈区、堆区

void printMessage() {
    cout << "Hello world!" << endl;
}
int main() {
    printMessage();
    while(1) {}
    return 0;
}

#include <iostream>
using namespace std;

// 全局区
// 主要存放：全局变量、全局常量、静态变量、字符串常量
//

int g_a = 1; // 全局变量存储在全局区
int g_b = 2;
const int c_g_a = 3; // 全局常量
const int c_g_b = 4;

int main() {
        cout << "全局变量g_a的地址：" << &g_a << endl;
        cout << "全局变量g_b的地址：" << &g_b << endl;

        int c = 3; // 局部变量，实际上存储在栈区
        int d = 4;
        static int e = 5; // 静态变量。与全局变量存在一起
        static int f = 6;
        cout << "局部变量 c 的地址：" << &c << endl;
        cout << "局部变量 d 的地址：" << &d << endl;
        cout << "静态变量 e 的地址：" << &e << endl;
        cout << "静态变量 f 的地址：" << &f << endl;

        // 字符串常量
        cout << "字符串常量的地址： " << &"你好" << endl;

        const int g = 7; // 局部常量存储在栈区
        const int h = 8;
        cout << "局部常量 g 的地址：" << &g << endl;
        cout << "局部常量 h 的地址：" << &h << endl;

        cout << "全局常量c_g_a的地址：" << &c_g_a << endl;
        cout << "全局常量c_g_b的地址：" << &c_g_b << endl;
        return 0;
}

全局变量g_a的地址：00007FF60507E048
全局变量g_b的地址：00007FF60507E04C
局部变量 c 的地址：000000958E9CFB24
局部变量 d 的地址：000000958E9CFB44
静态变量 e 的地址：00007FF60507E050
静态变量 f 的地址：00007FF60507E054
字符串常量的地址： 00007FF60507AC64
局部常量 g 的地址：000000958E9CFB64
局部常量 h 的地址：000000958E9CFB84
全局常量c_g_a的地址：00007FF60507ABDC
全局常量c_g_b的地址：00007FF60507ABE0

#include <iostream>
using namespace std;

char* func() {
        char c[20] = "英雄哪里出来";
        return c;
}

void test(int a, int b) {
        int c, d;
        cout << "形式参数a的地址：" << &a << endl;
        cout << "形式参数b的地址：" << &b << endl;
        cout << "局部变量c的地址：" << &c << endl;
        cout << "局部变量d的地址：" << &d << endl;
}
int main() {
        cout << func() << endl;
        test(5, 6);
        return 0;
}

烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫
形式参数a的地址：0000008ADCEFFC60
形式参数b的地址：0000008ADCEFFC68
局部变量c的地址：0000008ADCEFFB44
局部变量d的地址：0000008ADCEFFB64

#include <iostream>
using namespace std;

// C malloc free
// C++ new delete

int* getV(int v) {
        int* a = new int(v); // int* a 是栈上变量；
        cout << a << endl;   // *a 也就是a解引用得到的值，是存储在堆中的
        return a;            // 函数返回的时候，虽然栈上的变量a被操作系统释放了，但是a指向的内存，还是存在的
}
int main() {
        int* p = getV(1314);
        cout << *p << endl; // 所以，这里还是可以解引用，得到堆上的数据的
        cout << p << endl;
        return 0;
}

#include <iostream>
using namespace std;

// 指针：所以爱会消失，对嘛？
// 引用：给变量取一个别名
// 符号 &
// 数据类型& 变量名 = 变量;

void test() {
        int a_very_very_very_very_very_very_very[8] = { 1, 1 };
        for (int i = 2; i < 8; ++i) {
                // 等于 前一个数的平方 + 前两个数的平方
                a_very_very_very_very_very_very_very[i] = a_very_very_very_very_very_very_very[i - 1] * a_very_very_very_very_very_very_very[i - 1] + a_very_very_very_very_very_very_very[i - 2] * a_very_very_very_very_very_very_very[i - 2];
        }
        for (int i = 0; i < 8; ++i) {
                cout << a_very_very_very_very_very_very_very[i] << " ";
        }
        cout << endl;
        for (int i = 2; i < 8; ++i) {
                a_very_very_very_very_very_very_very[i] = 0;
        }

        // 代码缩短
        // 将 a_very_very_very_very_very_very_very 缓存起来
        for (int i = 2; i < 8; ++i) {
                int& pre1 = a_very_very_very_very_very_very_very[i - 1];
                int& pre2 = a_very_very_very_very_very_very_very[i - 2];
                int& now = a_very_very_very_very_very_very_very[i];
                now = pre1 * pre1 + pre2 * pre2;
        }
        for (int i = 0; i < 8; ++i) {
                cout << a_very_very_very_very_very_very_very[i] << " ";
        }
        cout << endl;
}
int main() {
        /* 指针方式 多写3个星号
        int a = 1314;
        int* b = &a; // a和b是同一个值
        *b = 520;
        cout << "a = " << a << endl;
        cout << "b = " << *b << endl;
        */

        int a = 1314;
        int& b = a; // a和b是同一个值
        b = 520;
        cout << "a = " << a << endl;
        cout << "b = " << b << endl;

        test();
        return 0;
}

a = 520
b = 520
1 1 2 5 29 866 750797 1056169389
1 1 2 5 29 866 750797 1056169389

#include <iostream>
using namespace std;

// 1、必须初始
// 2、初始化以后无法修改

int main() {
    // int& a; 错误写法
    int a = 3, c = 6;
    int& b = a;
    b = c; // 实际上是 b = 6; 不代表把 b 变成 c 的引用，而只是把变量 c 的值赋值给了 b
    cout << a << b << c << endl;

    return 0;
}

#include <iostream>
using namespace std;

// 引用 解引用(把引用中的值解出来)
int main() {
    int a = 520;
    //int& b = a;       // 00007FF6791F1FD5  lea         rax,[a]  
                        // 00007FF6791F1FD9  mov         qword ptr[b], rax

    //b = 1314;         // 00007FF6791F1FDD  mov         rax,qword ptr [b]  
                        // 00007FF6791F1FE1  mov         dword ptr[rax], 522h

    int* const b = &a;  // 00007FF6791F1FD5  lea         rax,[a]  
                        // 00007FF6791F1FD9  mov         qword ptr[b], rax
    *b = 1314;          // 00007FF6791F1FDD  mov         rax, qword ptr[b]
                        // 00007FF6791F1FE1  mov         dword ptr[rax], 522h

    return 0;
}

#include <iostream>
using namespace std;

// 统计数组中，有多少个值为2的元素，并且返回它的和
int countAndSum(int arr[], int size, int target, int& count) {
    int sum = 0;
    cout << &count << endl;
    for (int i = 0; i < size; ++i) {
        if (arr[i] == target) {
            count++;
            sum += arr[i];
        }
    }
    return sum;
}

struct S {
    int a, b, c,d,e,f,g;

};
/*
void printS(S s) {
    cout << &s << endl;
    cout << s.a << s.b << s.c << s.d << s.e << s.f << s.g << endl;
}
*/
void printS(S& s) { // 结构体作为参数时，是拷贝了一份新数据出来。加上引用就可以避免这次拷贝
    cout << &s << endl;
    cout << s.a << s.b << s.c << s.d << s.e << s.f << s.g << endl;
}

int main() {
    int arr[] = { 1, 2, 3, 2, 4, 5, 6, 4, 3, 2  }; // 10
    int c = 0;
    cout << &c << endl;
    int sum = countAndSum(arr, 10, 2, c);
    cout << sum << ' '<< c << endl;

    S s = { 1, 2, 3, 4, 5, 6, 7 };
    cout << &s << endl;
    printS(s); 

    return 0;
}

#include <iostream>
using namespace std;

int& getArrayValue(int arr[], int index) {
    return arr[index]; // 不加引用返回的是值。加了引用，返回的是arr[index]的一个别名
}

int main() {
    int a[] = { 8, 7, 6, 5, 4, 3 };
    cout << getArrayValue(a, 3) << endl;

    // 把3的值改变，又不想访问数组
    getArrayValue(a, 3) = 999; // a[3] = 999;
    cout << getArrayValue(a, 3) << endl;

    return 0;
}

5
999

#include <iostream>
#include <vector>
using namespace std;

struct S {
    int a, b, c, d, e, f;
};

void printS(const S& s) { // 引用不需要再拷贝一份数据进来，为避免修改加一个const修饰
    // s.b = 520;
    cout << s.a << s.b << s.c << s.d << s.e << s.f << endl;
}

int main() {
    int a;
    const int& b = a;
    // 引用 = 指针常量
    // 常量引用 = 常量指针常量
    S s = { 1, 2, 3, 4, 5, 6 };
    printS(s);

    //vector<int> a;
    return 0;
}

#include <iostream>
using namespace std;

// *&

void allocMemory1(char* ptr, int bytes) { // 这个ptr是局部变量
    ptr = new char[bytes];
    cout << "ptr的地址：" << &ptr << endl;
}

void test1() {
    char* p = NULL;
    allocMemory1(p, 5);
    cout << (void*)p << endl;
    cout << "p的地址：" << &p << endl;
}

void allocMemory2(char*& ptr, int bytes) { // 加上引用后ptr就变成p的别名了。指针引用还是个引用
    ptr = new char[bytes];
    cout << "ptr的地址：" << &ptr << endl;
}

void test2() {
    char* p = NULL;
    allocMemory2(p, 5);
    cout << (void*)p << endl;
    cout << "p的地址：" << &p << endl;
}

int main() {
    //test1();
    test2();

    return 0;
}

#include <iostream>
using namespace std;

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

#include <iostream>
using namespace std;

#define H 28
#define W 60

void drawMap() {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            cout << " ";
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
int main() {
    drawMap();
    while (1) {

    }

    return 0;
}

#include <iostream>
#include <Windows.h>
using namespace std;

#define H 28
#define W 60

void hideCursor() {
    HANDLE hOutpt = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO curInfo = { 1, FALSE };
    SetConsoleCursorInfo(hOutpt, &curInfo);
}

void drawMap() {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            cout << " ";
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
int main() {
    hideCursor();
    drawMap();
    while (1) {

    }

    return 0;
}

#include <iostream>
#include <Windows.h>
using namespace std;

#define H 28
#define W 60

enum BlockType {
    EMPTY = 0,
    FOOD = 1,
};

struct Map {
    BlockType data[H][W];
    bool hasFood;
};

void hideCursor() {
    HANDLE hOutpt = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO curInfo = { 1, FALSE };
    SetConsoleCursorInfo(hOutpt, &curInfo);
}

void initMap(Map* map) {
    for (int y = 0; y < H; ++y) {
        for (int x = 0; x < W; ++x) {
            map->data[y][x] = BlockType::EMPTY;
        }
    }
    map->hasFood = false;
}

void drawMap(Map* map) {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            if (map->data[y][x] == BlockType::EMPTY) {
                cout << " ";
            }
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
int main() {
    Map map;
    hideCursor();
    initMap(&map);
    drawMap(&map);
    while (1) {
    }
    return 0;
}

#include <iostream>
#include <Windows.h>
using namespace std;

#define H 28
#define W 60

enum BlockType {
    EMPTY = 0,
    FOOD = 1,
};
struct Map {
    BlockType data[H][W];
    bool hasFood;
};
struct Pos {
    int x;
    int y;
};
struct Snake {
    Pos snake[H * W];
    int snakeDir;
    int snakeLength;
};
void hideCursor() {
    HANDLE hOutpt = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO curInfo = { 1, FALSE };
    SetConsoleCursorInfo(hOutpt, &curInfo);
}

void initMap(Map* map) {
    for (int y = 0; y < H; ++y) {
        for (int x = 0; x < W; ++x) {
            map->data[y][x] = BlockType::EMPTY;
        }
    }
    map->hasFood = false;
}
void initSnake(Snake* snk) {
    snk->snakeLength = 1;
    snk->snakeDir = 1;
    snk->snake[0] = { W / 2, H / 2 };
}

void drawMap(Map* map) {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            if (map->data[y][x] == BlockType::EMPTY) {
                cout << " ";
            }
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
int main() {
    Map map;
    Snake snk;
    hideCursor();
    initMap(&map);
    initSnake(&snk);
    drawMap(&map);

    while (1) {
    }
    return 0;
}

#include <iostream>
#include <Windows.h>
using namespace std;

#define H 28
#define W 60

enum BlockType {
    EMPTY = 0,
    FOOD = 1,
};
struct Map {
    BlockType data[H][W];
    bool hasFood;
};
struct Pos {
    int x;
    int y;
};
struct Snake {
    Pos snake[H * W];
    int snakeDir;
    int snakeLength;
};
void hideCursor() {
    HANDLE hOutpt = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO curInfo = { 1, FALSE };
    SetConsoleCursorInfo(hOutpt, &curInfo);
}

void initMap(Map* map) {
    for (int y = 0; y < H; ++y) {
        for (int x = 0; x < W; ++x) {
            map->data[y][x] = BlockType::EMPTY;
        }
    }
    map->hasFood = false;
}
void initSnake(Snake* snk) {
    snk->snakeLength = 1;
    snk->snakeDir = 1;
    snk->snake[0] = { W / 2, H / 2 };
}
void drawUnit(Pos p, const char unit[]) {
    COORD coord;
    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    coord.X = p.x + 1;
    coord.Y = p.y + 1;
    SetConsoleCursorPosition(hOutput, coord);
    cout << unit;
}

void drawMap(Map* map) {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            if (map->data[y][x] == BlockType::EMPTY) {
                cout << " ";
            }
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
void drawSnake(Snake* snk) {
    for (int i = 0; i < snk->snakeLength; ++i) {
        drawUnit(snk->snake[i], "■");
    }
}
int main() {
    Map map;
    Snake snk;
    hideCursor();
    initMap(&map);
    initSnake(&snk);
    drawMap(&map);
    drawSnake(&snk);

    while (1) {
    }
    return 0;
}

void initSnake(Snake* snk) {
    snk->snakeLength = 3;
    snk->snakeDir = 1;
    snk->snake[0] = { W / 2, H / 2 };
    snk->snake[1] = { W / 2 - 1, H / 2 };
    snk->snake[2] = { W / 2 - 2, H / 2 };
}

const int dir[4][2] = {
    {-1, 0},   // 上 
    {0, 1},    // 右
    {1, 0},    // 下
    {0, -1}    // 左
};

void moveSnake(Snake* snk) {
    for (int i = snk->snakeLength - 1; i >= 1; --i) {
        snk->snake[i] = snk->snake[i - 1];
    }
    snk->snake[0].y += dir[snk->snakeDir][0];
    snk->snake[0].x += dir[snk->snakeDir][1];
}

bool doMove(Snake* snk, Map* map) {
    Pos tail = snk->snake[snk->snakeLength - 1];
    drawUnit(snk->snake[snk->snakeLength - 1], " ");
    moveSnake(snk);
    drawUnit(snk->snake[0], "■");
    return true;
}

bool checkSnakeMove(Snake* snk, Map* map) {
    doMove(snk, map);
    return true;
}

int main() {
    Map map;
    Snake snk;
    hideCursor();
    initMap(&map);
    initSnake(&snk);
    drawMap(&map);
    drawSnake(&snk);

    while (1) {
        if( false == checkSnakeMove(&snk, &map) ) {
            break;
        }
    }
    return 0;
}

struct Snake {
    Pos snake[H * W];
    int snakeDir;
    int snakeLength;
    int lastMoveTime;
    int moveFreqency;
};

void initSnake(Snake* snk) {
    snk->snakeLength = 3;
    snk->snakeDir = 1;
    snk->snake[0] = { W / 2, H / 2 };
    snk->snake[1] = { W / 2 - 1, H / 2 };
    snk->snake[2] = { W / 2 - 2, H / 2 };
    snk->lastMoveTime = 0;
    snk->moveFreqency = 200;
}

bool checkSnakeMove(Snake* snk, Map* map) {
    int curTime = GetTickCount();
    if (curTime - snk->lastMoveTime > snk->moveFreqency) {
        if (false == doMove(snk, map))
            return false;
        snk->lastMoveTime = curTime;
    }
    return true;
}

bool checkOutOfBound(Pos p) {
    if (p.x == 0 || p.x == W + 1) {
        return true;
    }
    if (p.y == 0 || p.y == H + 1) {
        return true;
    }
    return false;
}

bool doMove(Snake* snk, Map* map) {
    Pos tail = snk->snake[snk->snakeLength - 1];
    drawUnit(snk->snake[snk->snakeLength - 1], " ");
    moveSnake(snk);
    if (checkOutOfBound(snk->snake[0])) {
        return false;
    }
    drawUnit(snk->snake[0], "■");
    return true;
}

...
    while (1) {
        if (false == checkSnakeMove(&snk, &map))
            break;
    }
    drawUnit({ W / 2 - 4, H / 2 }, "Game Over");
    while (1) {}
    return 0;
}

#include <conio.h>

void checkChangeDir(Snake* snk) {
    if (_kbhit()) {
        switch (_getch()) {
            case 'w':
                if(snk->snakeDir != 2)
                    snk->snakeDir = 0;
                break;
            case 'd':
                if (snk->snakeDir != 3)
                    snk->snakeDir = 1;
                break;
            case 's':
                if (snk->snakeDir != 0)
                    snk->snakeDir = 2;
                break;
            case 'a':
                if (snk->snakeDir != 1)
                    snk->snakeDir = 3;
                break;
            default:
                break;
        }
    }
}

...
    while (1) {
        checkChangeDir(&snk);
        if (false == checkSnakeMove(&snk, &map))
            break;
        checkFoodGenerate(&snk, &map);
    }
    drawUnit({ W/2-4, H/2 }, "Game Over");
    while (1) {}
    return 0;
}

void checkFoodGenerate(Snake* snk, Map* map) {
    if (false == map->hasFood) {
        while (1) {
            int x = rand() % W;
            int y = rand() % H;
            int i = 0;
            while (i < snk->snakeLength) {
                if (snk->snake[i].x == x && snk->snake[i].y == y) {
                    break;
                }
                ++i;
            }
            if (i == snk->snakeLength) {
                map->data[y][x] = BlockType::FOOD;
                map->hasFood = true;
                drawUnit({ x,y }, "●");
                return;
            }
        }
    }
}

 ...
    while (1) {
        checkChangeDir(&snk);
        if (false == checkSnakeMove(&snk, &map))
            break;
        checkFoodGenerate(&snk, &map);
    }
    drawUnit({ W / 2 - 4, H / 2 }, "Game Over");
    while (1) {}
    return 0;
}

void checkEatFood(Snake* snk, Pos tail, Map* map) {
    Pos head = snk->snake[0];
    if (map->data[head.y][head.x] == BlockType::FOOD) {
        snk->snake[snk->snakeLength++] = tail;
        map->data[head.y][head.x] = BlockType::EMPTY;
        map->hasFood = false;
        drawUnit(tail, "■");
    }
}

bool doMove(Snake* snk, Map* map) {
    Pos tail = snk->snake[snk->snakeLength - 1];
    drawUnit(snk->snake[snk->snakeLength - 1], " ");
    moveSnake(snk);
    if (checkOutOfBound(snk->snake[0])) {
        return false;
    }
    checkEatFood(snk, tail, map);
    drawUnit(snk->snake[0], "■");
    return true;
}

#include <iostream>
#include <Windows.h>
#include <conio.h>
using namespace std;

#define H 28
#define W 60
const int dir[4][2] = {
    {-1, 0},   // 上 
    {0, 1},    // 右
    {1, 0},    // 下
    {0, -1}    // 左
};
enum BlockType {
    EMPTY = 0,
    FOOD = 1,
};
struct Map {
    BlockType data[H][W];
    bool hasFood;
};
struct Pos {
    int x;
    int y;
};
struct Snake {
    Pos snake[H * W];
    int snakeDir;
    int snakeLength;
    int lastMoveTime;
    int moveFreqency;
};
void hideCursor() {
    HANDLE hOutpt = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO curInfo = { 1, FALSE };
    SetConsoleCursorInfo(hOutpt, &curInfo);
}

void initMap(Map* map) {
    for (int y = 0; y < H; ++y) {
        for (int x = 0; x < W; ++x) {
            map->data[y][x] = BlockType::EMPTY;
        }
    }
    map->hasFood = false;
}
void initSnake(Snake* snk) {
    snk->snakeLength = 3;
    snk->snakeDir = 1;
    snk->snake[0] = { W / 2, H / 2 };
    snk->snake[1] = { W / 2 - 1, H / 2 };
    snk->snake[2] = { W / 2 - 2, H / 2 };
    snk->lastMoveTime = 0;
    snk->moveFreqency = 200;
}
void drawUnit(Pos p, const char unit[]) {
    COORD coord;
    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    coord.X = p.x + 1;
    coord.Y = p.y + 1;
    SetConsoleCursorPosition(hOutput, coord);
    cout << unit;
}

void drawMap(Map* map) {
    system("cls");
    cout << "┏";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┓" << endl;

    for (int y = 0; y < H; ++y) {
        cout << "┃";
        for (int x = 0; x < W; ++x) {
            if (map->data[y][x] == BlockType::EMPTY) {
                cout << " ";
            }
        }
        cout << "┃" << endl;
    }
    cout << "┗";
    for (int x = 0; x < W; ++x) {
        cout << "━";
    }
    cout << "┛";
}
void drawSnake(Snake* snk) {
    for (int i = 0; i < snk->snakeLength; ++i) {
        drawUnit(snk->snake[i], "■");
    }
}
void checkChangeDir(Snake* snk) {
    if (_kbhit()) {
        switch (_getch()) {
        case 'w':
            if (snk->snakeDir != 2)
                snk->snakeDir = 0;
            break;
        case 'd':
            if (snk->snakeDir != 3)
                snk->snakeDir = 1;
            break;
        case 's':
            if (snk->snakeDir != 0)
                snk->snakeDir = 2;
            break;
        case 'a':
            if (snk->snakeDir != 1)
                snk->snakeDir = 3;
            break;
        default:
            break;
        }
    }
}
bool checkOutOfBound(Pos p) {
    if (p.x == 0 || p.x == W + 1) {
        return true;
    }
    if (p.y == 0 || p.y == H + 1) {
        return true;
    }
    return false;
}

void moveSnake(Snake* snk) {
    for (int i = snk->snakeLength - 1; i >= 1; --i) {
        snk->snake[i] = snk->snake[i - 1];
    }
    snk->snake[0].y += dir[snk->snakeDir][0];
    snk->snake[0].x += dir[snk->snakeDir][1];
}
void checkEatFood(Snake* snk, Pos tail, Map* map) {
    Pos head = snk->snake[0];
    if (map->data[head.y][head.x] == BlockType::FOOD) {
        snk->snake[snk->snakeLength++] = tail;
        map->data[head.y][head.x] = BlockType::EMPTY;
        map->hasFood = false;
        drawUnit(tail, "■");
    }
}

bool doMove(Snake* snk, Map* map) {
    Pos tail = snk->snake[snk->snakeLength - 1];
    drawUnit(snk->snake[snk->snakeLength - 1], " ");
    moveSnake(snk);
    if (checkOutOfBound(snk->snake[0])) {
        return false;
    }
    checkEatFood(snk, tail, map);
    drawUnit(snk->snake[0], "■");
    return true;
}

bool checkSnakeMove(Snake* snk, Map* map) {
    int curTime = GetTickCount();
    if (curTime - snk->lastMoveTime > snk->moveFreqency) {
        if (false == doMove(snk, map))
            return false;
        snk->lastMoveTime = curTime;
    }
    return true;
}

void checkFoodGenerate(Snake* snk, Map* map) {
    if (false == map->hasFood) {
        while (1) {
            int x = rand() % W;
            int y = rand() % H;
            int i = 0;
            while (i < snk->snakeLength) {
                if (snk->snake[i].x == x && snk->snake[i].y == y) {
                    break;
                }
                ++i;
            }
            if (i == snk->snakeLength) {
                map->data[y][x] = BlockType::FOOD;
                map->hasFood = true;
                drawUnit({ x, y }, "●");
                return;
            }
        }
    }
}
int main() {
    Map map;
    Snake snk;

    hideCursor();
    initMap(&map);
    initSnake(&snk);
    drawMap(&map);
    drawSnake(&snk);

    while (1) {
        checkChangeDir(&snk);
        if (false == checkSnakeMove(&snk, &map))
            break;
        checkFoodGenerate(&snk, &map);
    }
    drawUnit({ W / 2 - 4, H / 2 }, "Game Over");
    while (1) {}
    return 0;
}