#include <stdio.h> // 表示文件在系统目录下
#include "a.h" // 表示文件在当前目录下

#include <stdio.h>
#include <float.h>

int main() {
  printf("int 存储大小 : %lu \n", sizeof(int));
  printf("a 存储大小 : %lu \n", sizeof(a));
  printf("float 存储最节数 : %lu \n", sizeof(float));
  printf("float 最小值: %E\n", FLT_MIN);
  printf("float 最大值: %E\n", FLT_MAX);
  printf("精度值: %d\n", FLT_DIG);

    return 0;
}

int a;
// 以 n 进制赋值
a = 10; // 默认十进制
a = 010; //0开头为8进制
a = 0b101; // 0b 开头为 2 进制
a = 0x2f;//    0x开头为16进制

// 以 n 进制显示
printf("十进制 = %d，八进制 = %o, "
       "十六进制小写 = %x , 16进制大写 = %X, "
       "十进制无符号 %u", a, a, a, a, a);


char c = 0x41;
printf("size = %lu, value= %c", sizeof(c), c);

float f = 123.4f;
double d1 = 100.1; // C语言默认都是 double


char ch = 'A';
printf("字符：%c，对应的ascii：%d\n", ch, ch);

int x = 1;
double y;
y = (double) x;

// char 的 \b 是退格符号，例如：
printf("hello word");
char b='\b';
printf("%c%c",b,b);
// 输出 hello wo


// 字符串 s/S char/wchar
printf("%s\n", "hello");


// p 16进制指针
int a = 1;
printf("%p\n", &a);

// 输出一个百分号
printf("%%", );

// printf 还有对其之类的操作，就不多写了

// 宏常量，规范：用大写
#define MAX 100;

// const 常量
const int a = 0;
// c用宏常量多，C++用const多

"字符串常量"
20 // 整数常量

int a =1;
a = a+1;
a = a+2;
// 以上代码会被编译器自动优化为： a = a+3

volatile int a = 1
// 编译器不会再自动做优化，

register int a = 0; // 这个变量直接放在寄存器中，而不是内存中
a = a + 1;
// 对应汇编
move eax, 0
add eax, 1

// 普通的：
int a = 0;
a = a + 1;
// 对应汇编
move b, 0
move eax, b
add eax, 1
move b, eax

#include <stdio.h>

enum month {
    JAN = 1, FEB = 2, MAR = 3, APR = 4, MAY = 5, JUN = 6,
    JUL = 7, AUG = 8, SEP = 9, OCT = 10, NOV = 11, DEC = 12
};

int main() {
    enum month lastmonth, thismonth, nextmonth;
    lastmonth = APR;
    thismonth = MAY;
    nextmonth = JUN;
    printf("%d %d %d \n", lastmonth, thismonth, nextmonth);
    return 0;
}

// 比较运算符，返回0或1
==，!=，<，>，<=，>=

// 与或非
&&，||，!

// 三目运算符
max = x > y ? x : y;

int a[10] // 定义了一个数组，其长度为10
// 1. 数组的元素类型必须都一样
// 2. 数组名本身是数组第一个元素的地址对应的常量
printf("%p == %p", a, &a[0]); // 两个都是在内存中的开头位置


// 初始化
int a[3] = {1, 2, 3};
int a[3] = {1, 2}; // 没定义的，默认为0
int a[] = {1, 2, 3}; // 如果不指定长度，自动计算和指定长度

// 3. 语法上，index 可以溢出，例如
a[100] = 999;
a[101];

// 4. 如何得到数组的长度？ sizeof(a)/sizeof(a[0])
// 所以这样遍历数组
for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++) {
    printf("%d\n", a[i]);
}

int a[2][5]; // 定义了一个二维数组，a[0],a[1] 是两个1维数组名
printf("%p = %p = %p", a, a[0], &a[0][0]); // 同一维数组，存放的也是内存地址

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

// 省略的自动补0
int a[2][5] = { {1, 2, 3, 4, 5},
              {3} };

// 可以省略第一个大小
int a[][5] = { {1, 2, 3, 4, 5},
               {3} };

int a[2][3][5]; // 定义了一个三维数组，其 a[0], a[1] 分别代表2个二维数组

char a[2];
a[0] = 'a';
a[1] = '\0'; // 它的 ascii 码就是 0，所以也可以 a[1] = 0;

char a1[10] = "abc"; // 这其实是初始化一个字符数组。不能用赋值 a="abc" 是错的
char a2[] = "abc"; // 会多一位 \0，这个例子实际上长度为 4

char a[100] = "hello world";
char *s = "hello world"; // 这个是先定义一个 字符串常量，然后用指针指向它的首地址。所以是只读。

char a[100] = {0};
char b[100] = {0};
char c[200] = {0};

scanf("%s", a); // 这里不是 &a
scanf("%s", b); // 如果用户的输出超过100个，会有溢出

int idx1, idx2;
idx1 = idx2 = 0;
while (a[idx1]) {
    c[idx1] = a[idx1];
    idx1++;
}
while (b[idx2]) {
    c[idx1] = b[idx2];
    idx1++;
    idx2++;
}

printf("%s", c);

putchar('a') \\ 一次输出一个字符
printf("hello") \\ 不多说

getchar() \\ 返回 int，是你输入的字符对应的 ascii 码

// scanf：
int a;
scanf("%d", &a); // 第二个变量是变量的地址
printf("%d\n",a);

char a[10];
gets(a);
// 1. 用户输出超长后会报错
// 2. 空格不代表结束，回车代表结束
// 3. 仍然有溢出危险

fgets(a, sizeof(a), stdin);
// 1. 用户超长后不报错，而是截断
// 2. 回车和空格都会放进去
// 3. 没有溢出危险



puts(a); // 跟 printf 功能差不多，自动加一个 \n，所以和 gets 连用会出现两次 \n
fputs(a, stdout);
// 1. 不会自作主张加 \n

// 字符串格式化：sprintf
char a[100];
sprintf(a, "%d: Hello, %s, welcome.", 1, "Tom");
// 把格式化后的字符串，放入a
// 可以这么理解：printf 是输出到标准输出设备，sprintf 是输出到字符数组
// 额外一个小应用：int 转 char[]

// 从指定格式中的字符中提取：sscanf
char a[] = "12+21";
int i, j;
sscanf(a, "%d+%d", &i, &j);
// 额外一个小应用：char[] 转 int（其实也能转 double）
// 也可以 char c;sscanf(a, "%d%c%d", &i, &c, &j);

// 字符串中提取数字
char a[100] = "105hellohello";
char *stopstring;
long int i = strtol(a, &stopstring, 6);
// 1. 以 6 进制提取
// 2. stopstring 是提取后的剩余部分
// 3. 类似的有这些：strtof, strtol, strtold, strtold, strtoll 等
// 4. 类似的还有 atoi, atof 等
// 5. 没有反过来转化的内置函数，可以用 sprintf 实现

unsigned long len = strlen(a);
// 1. 这个长度不包括末尾的 0
// 2. 1个汉字算3个
// 3. 到第一个0为止，既是数组后面还有内容

strcat(a, b); // 把 a 和 b 合并，并且放到 a
// a 必须有足够的空间，否则报错
strncat(a, b, 3); // 最多追加 b 的前 3 个字符

strcpy(a, b); // 把 b copy 到 a 中
// 如果超过 a 的大小，不会报错，而是会继续写入后续的内存（或许会导致错误）
strncpy(a, b, sizeof(a) - 1);
// 最多只复制 sizeof(a) - 1 个，可以防止溢出

int is_unequal = strcmp(a, b);
// 如果不同，返回非0。如果相同，返回0
int is_unequal = strncmp(a, b, 2);
// 比价前2个字符串
// a == b 是不对的，因为这个比较的是内存

char a[] = "hello world!";
char *s; //定一个一个 char类型指针变量
s = strchr(a, 'w');
// 1. s 也是一个 char[]
// 2. printf("%s", s); 输出 world!，也就是遇到 \0 才结束
// 3. 如果找不到，返回 null，用 s==NULL 做判断

s = strstr(a, "wor"); // 功能相似，入参可以是字符串

char a[100] = "abc_efg_123_666666";
char *s;

s = strtok(a, "_"); // 返回 abc
printf("%s\n", s);

s = strtok(NULL, "_");// 继续查找，返回 efg。如果查完了，返回null
printf("%s\n", s);

// 使用示例：
char a[100] = "abc_efg_123_666666";
char *s;

s = strtok(a, "_");
while (s) {
    printf("%s\n", s);
    s = strtok(NULL, "_");
}

// 小写转大写的技巧
char a = 'a';
if (a >= 'a' && a <= 'z') { // 1. char 可以当成 int 用
    a -= ' '; // 2. 减空格就代表着转大写（ascii设计不错）
}

// 同样原理，可以字符转数字
int a = '1';
if (a >= '0' && a <= '9') {
    a -= '0';
}

// my_utils.c:
int my_add(int a, int b) {
    return a + b;
}

// main.c:
#include<stdio.h>

int my_add(int a, int b);

int main() {
    int a = 1;
    int b = 2;
    int c = my_add(a, b);
    printf("%d\n", c);
    return 0;
}

// 编译：
// gcc -o my_package main.c my_utils.c
// 执行：
// ./my_package

// my_utils.h
int my_add(int a, int b) {
    return a + b;
}

// main.c
#include<stdio.h>
#include "my_utils.h"

int main() {
    int a = 1;
    int b = 2;
    int c = my_add(a, b);
    printf("%d\n", c);
    return 0;
}

// gcc -o my_package main.c
// ./my_package

#include<stdio.h>

#define TEST// 定义了一个宏

int main() {
#ifdef TEST // 如果定义了 TEST，就编译这里面的，否则不编译
    printf("dev");
#endif

#ifndef TEST
    printf("prod") // 如果没定义就不编译，定义了就编译
#endif

    return 0;
}

#ifndef _MY_UTILS
#define _MY_UTILS

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

#endif

#include <stdio.h>

int func1();

int main() {
    func1(); // 这里编译器不会提示错误，但会产生一个随机的值
    return 0;
}

int func1(int a){
    printf("%d",a);
    return 0;
}

int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
memset(a, 0, sizeof(a));
// 入参：置空的区域的首地址，0，这块内存大小（单位 Byte）

int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int b[10] = {0};
memcpy(b, a, sizeof(a));
// 入参：目标地址，源地址，拷贝的大小（单位 Byte）

#include<time.h>
#include<stdlib.h>

srand(100); // 指定种子
int a = rand(); // 如果不定义种子，不会随机定种子

// 如何得到真随机：
int t=(int) time(NULL);
srand(t);
int a = rand();

// 如何得到0-100的随机数？
rand() % 101;

#include <stdlib.h>

int main()
{
    system("ls -l"); // 运行成功返回0
    return 0;
}