int main(int argc,char* argv[])
{
    int a = 10;
    float b = 12.5;
    // 打印结果；a+b=22.500000 （float 类型）
    printf("a+b=%f\n",a+b);
    // 打印结果；... , a*b=125.000000 （float 类型）
    printf("a+b=%f\n,a*b=%f\n",a+b,a*b);
    char c = 'a';
    // 打印结果；c=f（c 为字符 a，c 加数字可以变为另一个字符，c+1=b，c+2=c，...）
    printf("c=%c\n",c+5);
    // 打印结果；c=102（f 的实际编码的值就是 102）
    printf("c=%d\n",c+5);
    int d = 10;
    int e = d % 6; // 取余
 
    int f = d / 6; // 取商
    // 打印结果；e=4,f=1
    printf("e=%d\n,f=%d\n",e,f);
    return 0;  // 代表执行成功。
}

int main(int argc,char* argv[])
{
//    int arr[10];
//    arr[0] = 1;
//    arr[1] = 2;
//    printf("%d,%d\n",arr[0],arr[1]);
 
    int arr[10] = {1,2,3,};
    // 打印结果；1，2，3，0（默认情况下，不赋值的情况下，数组会初始化为 0。）
    printf("%d,%d,%d,%d\n",arr[0],arr[1],arr[2],arr[3]);
    float f[2] = {1,2};
    // 打印结果；1.000000,2.000000
    printf("%f,%f\n",f[0],f[1]);
    return 0;
}

// 它是没有保护的概念的(如 private 等)
 
struct st {
    int a; // 成员 a
 
    int b; // 成员 b
};

// 结构体可以理解为它是一个类
 
struct st{
    int a;
    float f;
};
int main(int argc,char* argv[]){
    struct st ss;
    ss.a = 12;
    ss.f = 10.2;
    // 打印结果；struct:12, 10.200000
    printf("struct:%d, %f\n",ss.a,ss.f);
    return 0;  // 代表执行成功。
}

enum em {
    red_color = 0,  // 值为 0，如果值为 1
    green_color,    // 值为 1，则值为 2
    black_color    // 值为 2，则值为 3
};

enum em {
    red_color = 5,
    green_color,
    black_color = 10,
    yellow_color
};
int main(int argc,char* argv[]){
    enum em ee;
 
    ee = green_color;
    // 打印结果；enum:6
    printf("enum:%d\n",ee);
    ee = yellow_color;
    // 打印结果；enum:11
    printf("enum:%d\n",ee);
    return 0;  // 代表执行成功。
}

#include <stdio.h>
#include <stdlib.h> // malloc() 需要的头文件
 
int main(int argc,char* argv[]){
    // malloc() 一般返回的是 void* 类型。
    // malloc() 在 <stdlib.h> 头文件中。
 
    char* p = (char*)malloc(10); // 分配十个字符的空间
 
    *p = 'a';      // 第一个字符的位置
 
    *(p+1) = 'b';  // 第二个字符的位置
    // 将内存分配的地址告诉 printf，
    // printf 将 p 地址所指向的空间的内容以字符串的形式打印出来。
    printf("%s\n",p); // 打印结果；ab
    // 将 p 所指向的空间释放掉
    // 系统管理层将内存又还给了堆空间
 
    free(p);
    *p = 'd';
    // 即使把空间释放掉，但因为仍然掌握此空间的位置，知道 p 的指向。
    // 所以即使被释放掉了，还是可以对其操作。
    printf("%s\n",p); // 打印结果；db
    // 所以为了不让再访问这个地址，要将其指向 NULL，设置为无效地址。
    p = NULL;
//    *p = 'e';  // crash
 
    return 0;
}

int func(int x); // 声明一个函数
 
int (*f)(int x);  // 声明一个函数指针。返回类型和形参必须与指定的函数一致。
f = func;  // 将 func 函数的首地址赋值给指针 f。然后调用 f 即可。
————————
#include <stdio.h>
 
int func(int a){
    printf("a=%d\n",a);
    return 0;
}
int func1(int b){
    printf("b=%d\n",b+5);
    return 0;
}
int main(int argc,char* argv[]){
    int (*f)(int);
    // 在 C++ 中这就是多态。
    // 对上层来讲，调用的都是 f 这个函数指针，但在底层返回的是不同的结果。
    f=func;
    f(2);
    f=func1;
    f(3);
    // 打印结果；a=2 b=8
 
    return 0;
}

#include <stdio.h>
 
void createfile(char* filename){
    // open/create file
    FILE* file = fopen(filename,"w");
    if (!file) {
        printf("Failed to create file (%s)\n",filename);
        return;
    }
    // 向创建好的文件内写入内容。
    // 参数一指写入的字符串，参数二指字符串中的每一项多大，参数三指一共有几项，参数四指写到哪个文件
    size_t len = fwrite("aaaaa", 1, 5, file);
    if (len !=5) {
        // size_t 使用的打印为 %zu。
        printf("Failed to write file,(%zu)",len);
        fclose(file);
        return;
    }
    printf("Successed to write file\n");
    fclose(file);
    printf("Successed to create file\n");
}
void read_data(char* filename){
    FILE* file = fopen(filename,"r");
    if (!file) {
        printf("Failed to create file (%s)\n",filename);
        return;
    }
    // 定义为 1k 大小，并初始化为 0。
 
    char buffer[1024] = {0,};
    // 参数：读出的数据存放位置，长度，读多少，从哪读。
    size_t len = fread(buffer, 1, 10, file);
    if (len <= 0) {
        printf("Failed to read file!\n");
        fclose(file);
        return;
    }
    printf("read_data:%s\n",buffer);
    fclose(file);
    return;
}
int main(int argc,char* argv[]){
    // create file
//    createfile("/Users/jianghouren/Downloads/1.txt");
    // read file
    read_data("/Users/jianghouren/Downloads/1.txt");
    return 0;
}