#include <stdlib.h>
int system(const char *command);
功能：在已经运行的程序中执行另外一个外部程序
参数：外部可执行程序名字
返回值：
成功：不同系统返回值不一样
失败：通常是 - 1

#include <stdio.h>
#include <stdlib.h>
int main()
{
       //system("calc"); //windows平台
       system("ls"); //Linux平台, 需要头文件#include <stdlib.h>
       return 0;
}

void Widget::on_pushButton_clicked()
{
    //system("calc"); //需要头文件：#include <stdlib.h>
    WinExec("calc", SW_NORMAL); //需要头文件：#include <windows.h>
}
 
void Widget::on_pushButton_2_clicked()
{
    system("notepad");
}
 
void Widget::on_pushButton_3_clicked()
{
    system("mmc");
}

void CvssystemDlg::OnBnClickedButton1()
{
       // TODO:  在此添加控件通知处理程序代码

       //WinExec("calc", SW_NORMAL); 需要头文件：#include <windows.h>
     system("calc"); //需要头文件：#include <stdlib.h>

}
void CvssystemDlg::OnBnClickedButton2()
{
       // TODO:  在此添加控件通知处理程序代码

       //WinExec("notepad", SW_NORMAL);

       system("notepad");
}

预处理：gcc -E   hello.c -o hello.i
编  译：gcc -S  hello.i -o hello.s
汇  编：gcc -c  hello.s -o hello.o
链  接：gcc     hello.o -o hello_elf

#include <stdio.h>
int main()
{
      //定义整型变量a, b, c
       int a;
       int b;
       int c;
       __asm
       {
              mov a, 3 //3的值放在a对应内存的位置
              mov b, 4       //4的值放在a对应内存的位置
              mov eax, a    //把a内存的值放在eax寄存器
              add eax, b     //eax和b相加，结果放在eax
              mov c, eax    //eax的值放在c中
       }  
       printf("%d\n",  c);//把c的值输出
       return 0;//成功完成
}

#include <stdio.h>
int main(void)
{
       //定义整型变量a, b, c
       int a;
       int b;
       int c;
       a = 3;
       b = 4;
       c = a + b;
       printf("%d\n",  c);//把c的值输出
       return 0;//成功完成
}

#define _CRT_SECURE_NO_WARNINGS     //这个宏定义最好要放到.c文件的第一行
#pragma warning(disable:4996)     //或者使用这个

#include <stdio.h>
#define MAX 10 //声明了一个常量，名字叫MAX，值是10，常量的值一旦初始化不可改
int main(void)
{
       int a;      //定义了一个变量，其类型为int，名字叫a
       const int b = 10; //定义一个const常量，名为叫b，值为10
       //b = 11; //err,常量的值不能改变
       //MAX = 100;     //err,常量的值不能改变
       a = MAX;//将abc的值设置为MAX的值
       a = 123;
       printf("%d\n", a); //打印变量a的值
       return 0;
}

#include <stdio.h>
int main(void)
{
       int a = 123;          //十进制方式赋值
       int b = 0123;        //八进制方式赋值， 以数字0开头
       int c = 0xABC;   //十六进制方式赋值
       //如果在printf中输出一个十进制数那么用%d，八进制用%o，十六进制是%x
       printf("十进制：%d\n",a );
       printf("八进制：%o\n", b);     //%o,为字母o,不是数字
       printf("十六进制：%x\n", c);
       return 0;
}

#include <stdio.h>
int main(void)
{
       int  a = -15;
       printf("%x\n", a);
       //结果为 fffffff1
       //fffffff1对应的二进制：1111 1111 1111 1111 1111 1111 1111 0001
       //符号位不变，其它取反：1000 0000 0000 0000 0000 0000 0000 1110
       //上面加1：1000 0000 0000 0000 0000 0000 0000 1111  最高位1代表负数，就是-15
       return 0;
}

#include <stdio.h>
int main()
{
       int a = 123;   //定义变量a，以10进制方式赋值为123
       int b = 0567; //定义变量b，以8进制方式赋值为0567
       int c = 0xabc;      //定义变量c，以16进制方式赋值为0xabc
       printf("a = %d\n", a);
       printf("8进制：b = %o\n", b);
       printf("10进制：b = %d\n", b);
       printf("16进制：c = %x\n", c);
       printf("16进制：c = %X\n", c);
       printf("10进制：c = %d\n", c);
       unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
       printf("有符号方式打印：d = %d\n", d);
       printf("无符号方式打印：d = %u\n", d);
       return 0;
}

#include <stdio.h>
int main()
{
       int a;
       printf("请输入a的值：");
       //不要加“\n”
       scanf("%d", &a);
       printf("a = %d\n", a); //打印a的值
       return 0;
}

#include <stdio.h>
 int main()
{
       signed int a = -1089474374; //定义有符号整型变量a
       printf("%X\n", a); //结果为 BF0FF0BA
       //B       F      0        F       F     0        B           A
       //1011 1111 0000 1111 1111 0000 1011 1010
       return 0;
} 

#include <stdio.h>
int main()
{
       unsigned int a = 3236958022; //定义无符号整型变量a
       printf("%X\n", a); //结果为 C0F00F46
       return 0;
}

#include <stdio.h>
int main()
{
       char ch = ‘a‘;

       printf("sizeof(ch) = %u\n", sizeof(ch));
       printf("ch[%%c] = %c\n", ch); //打印字符
       printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值

       char A = ‘A‘;
       char a = ‘a‘;
       printf("a = %d\n", a);        //97
       printf("A = %d\n", A);      //65
       printf("A = %c\n", ‘a‘ - 32); //小写a转大写A
       printf("a = %c\n", ‘A‘ + 32); //大写A转小写a

       ch = ‘ ‘;
       printf("空字符：%d\n", ch); //空字符ASCII的值为32
       printf("A = %c\n", ‘a‘ - ‘ ‘); //小写a转大写A
       printf("a = %c\n", ‘A‘ + ‘ ‘); //大写A转小写a
       return 0;
}

#include <stdio.h>
int main()
{
       char ch;
       printf("请输入ch的值：");
       //不要加“\n”
       scanf("%c", &ch);
       printf("ch = %c\n", ch); //打印ch的字符
       return 0;
}

#include <stdio.h>
int main()
{
       //传统方式赋值
       float a = 3.14f; //或3.14F
       double b = 3.14;
       printf("a = %f\n", a);
       printf("b = %lf\n", b);
       //科学法赋值
       a = 3.2e3f; //3.2*1000 = 32000，e可以写E
       printf("a1 = %f\n", a);
       a = 100e-3f; //100*0.001 = 0.1
       printf("a2 = %f\n", a);

       a = 3.1415926f;
       printf("a3 = %f\n", a); //结果为3.141593
       return 0;
}

#include <stdio.h>
int main()
{
       int num = 5;

       printf("s1=%d\n", num / 2);
       printf("s2=%lf\n", num / 2.0);
       return 0;
}

#include <stdio.h> 
int main()
{
       int a = 10;
       int b = 20;
       int c;
       if (a > b)
       {
              c = a;
       }
       else
       {
              c = b;
       }
       printf("c1 = %d\n", c);
       a = 1;
       b = 2;
       c = ( a > b ? a : b );
       printf("c2 = %d\n", c);

       return 0;
}

#include <stdio.h>
int main()
{
       char c;
       c = getchar();
       switch (c) //参数只能是整型变量
       {
       case ‘1‘:
              printf("OK\n");
              break;//switch遇到break就中断了
       case ‘2‘:
              printf("not OK\n");
              break;
       default://如果上面的条件都不满足，那么执行default
              printf("are u ok?\n");
       }
       return 0;
}

#include <stdio.h>
int main()
{
       int a = 1;
       do
       {
              a++;
              printf("a = %d\n", a);
       } while (a < 10);

       return 0;
}

#include <stdio.h>
int main()
{
       int i;
       int sum = 0;
       for (i = 0; i <= 100; i++)
       {
              sum += i;
       }
       printf("sum = %d\n", sum);
       return 0;
}

#include <stdio.h>
int main(void)
{
       int num = 0;
       int i, j, k;
       for (i = 0; i < 10; i++)
       {
              for (j = 0; j < 10; j++)
              {
                     for (k = 0; k < 10; k++)
                    {
                            printf("hello world\n");
                            num++;
                     }
              }
       }
       printf("num = %d\n", num);
       return 0;
}

#include<stdio.h>
int main()
{
       int sum = 0;           //定义变量sum
       for (int i = 1; i <= 100; i++)
       {
              if (i % 2 == 0)   //如果i是一个偶数，执行if语句中的代码
              {
                     continue;      //结束本次循环
              }
              sum += i;          //实现sum和i的累加
       }
       printf("sum = %d\n", sum);
       return 0;
}

#include <stdio.h>
int main()
{
       goto End; //无条件跳转到End的标识
       printf("aaaaaaaaa\n");
End:
       printf("bbbbbbbb\n");
       return 0;
}

#include <stdio.h>
int main(void)
{
       int a[10];//定义了一个数组，名字叫a，有10个成员，每个成员都是int类型
       //a[0]…… a[9]，没有a[10]
       //没有a这个变量，a是数组的名字，但不是变量名，它是常量
       a[0] = 0;
       //……
       a[9] = 9;
       int i = 0;
       for (i = 0; i < 10; i++)
       {
              a[i] = i; //给数组赋值
       }
       //遍历数组，并输出每个成员的值
       for (i = 0; i < 10; i++)
       {
              printf("%d ", a[i]);
       }
       printf("\n");
       return 0;
}

#include <stdio.h>
int main()
{
       int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };//定义一个数组，同时初始化所有成员变量
       printf("a = %p\n", a);
       printf("&a[0] = %p\n", &a[0]);
       int n = sizeof(a); //数组占用内存的大小，10个int类型，10 * 4  = 40
       int n0 = sizeof(a[0]);//数组第0个元素占用内存大小，第0个元素为int，4
       int i = 0;
       for (i = 0; i < sizeof(a) / sizeof(a[0]); i++)
       {
              printf("%d ", a[i]);
       }
       printf("\n");
       return 0;
}

//分段赋值    int a[3][4] = {{ 1, 2, 3, 4 },{ 5, 6, 7, 8, },{ 9, 10, 11, 12 }};
       int a[3][4] =
       {
              { 1, 2, 3, 4 },
              { 5, 6, 7, 8, },
              { 9, 10, 11, 12 }
       };

       //连续赋值
       int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };
       //可以只给部分元素赋初值，未初始化则为0
       int a[3][4] = { 1, 2, 3, 4  };

       //所有的成员都设置为0
       int a[3][4] = {0};

       //[]中不定义元素个数，定义时必须初始化

       int a[][4] = { 1, 2, 3, 4, 5, 6, 7, 8};

#include <stdio.h>
int main()
{
       //定义了一个二维数组，名字叫a
       //二维数组是本质上还是一维数组，此一维数组有3个元素
//每个元素又是一个一维数组int[4]
       int a[3][4] = { 1, 2, 3, 4 , 5, 6, 7, 8, 9, 10, 11, 12  };

       //数组名为数组首元素地址，二维数组的第0个元素为一维数组
       //第0个一维数组的数组名为a[0]
       printf("a = %p\n", a);
       printf("a[0] = %p\n", a[0]); 

       //测二维数组所占内存空间，有3个一维数组，每个一维数组的空间为4*4
       //sizeof(a) = 3 * 4 * 4 = 48
       printf("sizeof(a) = %d\n", sizeof(a));

       //测第0个元素所占内存空间，a[0]为第0个一维数组int[4]的数组名，4*4=16
       printf("sizeof(a[0]) = %d\n", sizeof(a[0]) );

       //测第0行0列元素所占内存空间，第0行0列元素为一个int类型，4字节
       printf("sizeof(a[0][0]) = %d\n", sizeof(a[0][0]));

       //求二维数组行数
       printf("i = %d\n", sizeof(a) / sizeof(a[0]));

       // 求二维数组列数
       printf("j = %d\n", sizeof(a[0]) / sizeof(a[0][0]));

       //求二维数组行*列总数
       printf("n = %d\n", sizeof(a) / sizeof(a[0][0]));
       return 0;
}

#include <stdio.h>
int main(void)
{
       //二维数组：  五行、三列
       //行代表人：  老大到老五
       //列代表科目：语、数、外
       float a[5][3] = { { 80, 75, 56 }, { 59, 65, 71 }, { 59, 63, 70 }, { 85, 45, 90 }, { 76, 77, 45 } };
       int i, j, person_low[3] = { 0 };
       float s = 0, lesson_aver[3] = { 0 };

       for (i = 0; i < 3; i++)
       {
              for (j = 0; j < 5; j++)
              {
                    s = s + a[j][i];
                     if (a[j][i] < 60)
                     {
                            person_low[i]++;
                     }
              } 
              lesson_aver[i] = s / 5;
              s = 0;
       }
       printf("各科的平均成绩:\n");
       for (i = 0; i < 3; i++)
       {
              printf("%.2f\n", lesson_aver[i]);
       }
       printf("各科不及格的人数:\n");
       for (i = 0; i < 3; i++)
       {
              printf("%d\n", person_low[i]);
       }
       return 0;
}

#include <stdio.h>
int main(void)
{
       //int a[3][4][5] ;//定义了一个三维数组，有3个二维数组int[4][5]
       int a[3][4][5] = { { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } }, { { 0 }, { 0 }, { 0 }, { 0 } } };
       int i, j, k;
       for (i = 0; i < 3; i++)
       {
              for (j = 0; j < 4; j++)
              {
                     for (k = 0; k < 5; k++)
                     {
                          //添加访问元素代码
                            printf("%d, ", a[i][j][k]);
                     }
                     printf("\n");
              }
       }
       return 0;
}

#include <stdio.h>
int main(void)
{
       char c1[] = { ‘c‘, ‘ ‘, ‘p‘, ‘r‘, ‘o‘, ‘g‘ }; //普通字符数组
       printf("c1 = %s\n", c1); //乱码，因为没有’\0’结束符

       //以‘\0’(‘\0’就是数字0)结尾的字符数组是字符串
       char c2[] = { ‘c‘, ‘ ‘, ‘p‘, ‘r‘, ‘o‘, ‘g‘, ‘\0‘};
       printf("c2 = %s\n", c2);

       //字符串处理以‘\0’(数字0)作为结束符，后面的‘h‘, ‘l‘, ‘l‘, ‘e‘, ‘o‘不会输出
       char c3[] = { ‘c‘, ‘ ‘, ‘p‘, ‘r‘, ‘o‘, ‘g‘, ‘\0‘, ‘h‘, ‘l‘, ‘l‘, ‘e‘, ‘o‘, ‘\0‘};
       printf("c3 = %s\n", c3);
       return 0;
}

#include <stdio.h>
// C语言没有字符串类型，通过字符数组模拟
// C语言字符串，以字符‘\0’, 数字0
int main(void)
{
       //不指定长度, 没有0结束符，有多少个元素就有多长
       char buf[] = { ‘a‘, ‘b‘, ‘c‘ };
       printf("buf = %s\n", buf); //乱码

       //指定长度，后面没有赋值的元素，自动补0
       char buf2[100] = { ‘a‘, ‘b‘, ‘c‘ };
       printf("buf2 = %s\n", buf2);

       //所有元素赋值为0
       char buf3[100] = { 0 };

       //char buf4[2] = { ‘1‘, ‘2‘, ‘3‘ };//数组越界
       char buf5[50] = { ‘1‘, ‘a‘, ‘b‘, ‘0‘, ‘7‘ };
       printf("buf5 = %s\n", buf5); 

       char buf6[50] = { ‘1‘, ‘a‘, ‘b‘, 0, ‘7‘ };
       printf("buf6 = %s\n", buf6);

       char buf7[50] = { ‘1‘, ‘a‘, ‘b‘, ‘\0‘, ‘7‘ };
       printf("buf7 = %s\n", buf7);

       //使用字符串初始化，编译器自动在后面补0，常用
       char buf8[] = "agjdslgjlsdjg";

       //‘\0‘后面最好不要连着数字，有可能几个数字连起来刚好是一个转义字符
       //‘\ddd‘八进制字义字符，‘\xdd‘十六进制转移字符
       // \012相当于\n

       char str[] = "\012abc";
       printf("str == %s\n", str);
       return 0;
}

#include <stdio.h> 
int main(void)
{
       char str[100];
       printf("input string1 : \n");
       scanf("%s", str);//scanf(“%s”,str)默认以空格分隔
       printf("output:%s\n", str);
       return 0;
}

#include <stdio.h>
int main(void)
{
       char str1[] = "abcdef";
       char str2[] = "123456";
       char dst[100];
       int i = 0;
       while (str1[i] != 0)
       {
              dst[i] = str1[i];
              i++;
       }
       int j = 0;
       while (str2[j] != 0)
       {
              dst[i + j] = str2[j];
              j++;
       }
       dst[i + j] = 0; //字符串结束符
       printf("dst = %s\n", dst);
       return 0;
}

#include <stdio.h>
int main()
{
       printf("hello world");
       puts("hello world");
       return 0;
}

// 函数的定义, 返回值为int类型

int test()

{

}

int main()
{
       // 函数的调用
       int a = test(); // right, a为int类型

       int b;
       b = test();      // right, 和上面等级

       char *p = test(); // 虽然调用成功没有意义, p为char *, 函数返回值为int, 类型不匹配
       // error, 必须定义一个匹配类型的变量来接收返回值

       // int只是类型，没有定义变量

       int = test();  

       // error, 必须定义一个匹配类型的变量来接收返回值
       // int只是类型，没有定义变量
       int test();  
       return 0;
}

#include <stdio.h>
int max(int x, int y); // 函数的声明，分号不能省略
// int max(int, int); // 另一种方式
int main()
{
       int a = 10, b = 25, num_max = 0;
       num_max = max(a, b); // 函数的调用
       printf("num_max = %d\n", num_max);
       return 0;
}

// 函数的定义
int max(int x, int y)
{
       return x > y ? x : y;
}

#include <stdio.h>
#include <stdlib.h>
void fun()
{
       printf("fun\n");
       //return;
       exit(0);
}
int main()
{
       fun();
       while (1);
       return 0;
}

#include <stdio.h>
int main()
{
       int a = 0;
       char b = 100;
       printf("%p, %p\n", &a, &b); //打印a, b的地址

       //int *代表是一种数据类型，int*指针类型，p才是变量名

      //定义了一个指针类型的变量，可以指向一个int类型变量的地址
       int *p;
       p = &a;//将a的地址赋值给变量p，p也是一个变量，值是一个内存地址编号

       printf("%d\n", *p);//p指向了a的地址，*p就是a的值
       char *p1 = &b;
       printf("%c\n", *p1);//*p1指向了b的地址，*p1就是b的值
       return 0;
}

int a = 0;

       int b = 11;

       int *p = &a;

       *p = 100;

       printf("a = %d, *p = %d\n", a, *p);

       p = &b;

       *p = 22;

       printf("b = %d, *p = %d\n", b, *p);

       void *p = NULL;
       int a = 10;
       p = (void *)&a; //指向变量时，最好转换为void *
       //使用指针变量指向的内存时，转换为int *
       *( (int *)p ) = 11;
       printf("a = %d\n", a);

       int a = 100;
       int b = 200;

//指向常量的指针
       //修饰*，指针指向内存区域不能修改，指针指向可以变
       const int *p1 = &a; //等价于int const *p1 = &a;
       //*p1 = 111; //err
       p1 = &b; //ok

//指针常量
       //修饰p1，指针指向不能变，指针指向的内存可以修改
       int * const p2 = &a;
       //p2 = &b; //err
       *p2 = 222; //ok

#include <stdio.h>
int  main()
{
       int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       int i = 0;
       int n = sizeof(a) / sizeof(a[0]);
       for (i = 0; i < n; i++)
       {
              //printf("%d, ", a[i]);
              printf("%d, ", *(a+i));
       }
       printf("\n");
       int *p = a; //定义一个指针变量保存a的地址
       for (i = 0; i < n; i++)
       {
              p[i] = 2 * i;
       }
       for (i = 0; i < n; i++)
       {
              printf("%d, ", *(p + i));
       }
       printf("\n");
       return 0;
}

#include <stdio.h>
int main()
{
      int a;
       int *p = &a;
       printf("%d\n", p);
       p += 2;//移动了2个int
       printf("%d\n", p);
       char b = 0;
       char *p1 = &b;
       printf("%d\n", p1);
       p1 += 2;//移动了2个char
       printf("%d\n", p1);
       return 0;
} 

#include <stdio.h>
int main()
{
       int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       int i = 0;
       int n = sizeof(a) / sizeof(a[0]);
       int *p = a;
       for (i = 0; i < n; i++)
       {
              printf("%d, ", *p);
              p++;
       }
       printf("\n");
       return 0;
}

#include <stdio.h>
int main()
{
       int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       int i = 0;
       int n = sizeof(a) / sizeof(a[0]);
       int *p = a+n-1;
       for (i = 0; i < n; i++)
       {
              printf("%d, ", *p);
              p--;
       }
       printf("\n");
       return 0;
}

#include <stdio.h>
int main()
{
       int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       int *p2 = &a[2]; //第2个元素地址
       int *p1 = &a[1]; //第1个元素地址
       printf("p1 = %p, p2 = %p\n", p1, p2);
       int n1 = p2 - p1; //n1 = 1
       int n2 = (int)p2 - (int)p1; //n2 = 4
       printf("n1 = %d, n2 = %d\n", n1, n2);
       return 0;
}

#include <stdio.h>
int main()
{

      //指针数组
       int *p[3];
       int a = 1;
       int b = 2;
       int c = 3;
       int i = 0;

       p[0] = &a;
       p[1] = &b;
       p[2] = &c;
      for (i = 0; i < sizeof(p) / sizeof(p[0]); i++ )
       {
              printf("%d, ", *(p[i]));
       }
       printf("\n"); 
       return 0;
}

#include <stdio.h>
void swap1(int x, int y)
{
       int tmp;
       tmp = x;
       x = y;
       y = tmp;
       printf("x = %d, y = %d\n", x, y);
}
void swap2(int *x, int *y)
{
       int tmp;
      tmp = *x;
       *x = *y;
      *y = tmp;
}
int main()
{
       int a = 3;
       int b = 5;
       swap1(a, b); //值传递
       printf("a = %d, b = %d\n", a, b);
       a = 3;
       b = 5;
       swap2(&a, &b); //地址传递
       printf("a2 = %d, b2 = %d\n", a, b);
       return 0;
}

#include <stdio.h>
//void printArrary(int a[10], int n)
//void printArrary(int a[], int n)

void printArrary(int *a, int n)
{
       int i = 0;
       for (i = 0; i < n; i++)
       {
              printf("%d, ", a[i]);
       }
       printf("\n");
}

int main()
{
       int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
       int n = sizeof(a) / sizeof(a[0]);
       //数组名做函数参数
       printArrary(a, n);
       return 0;
}

#include <stdio.h>
int a = 10
int *getA()
{
       return &a;
}

 int main()
{
       *( getA() ) = 111;
       printf("a = %d\n", a);
       return 0;
}

#include <stdio.h>
int main()
{
       char str[] = "hello world";
       char *p = str;
       *p = ‘m‘;
       p++;
       *p = ‘i‘;
       printf("%s\n", str);

       p = "mike jiang";
       printf("%s\n", p);

       char *q = "test";
       printf("%s\n", q);
       return 0;
}

#include <stdio.h>
void mystrcat(char *dest, const char *src)
{
       int len1 = 0;
       int len2 = 0;
       while (dest[len1])
       {
              len1++;
       }
       while (src[len2])
       {
              len2++;
       }
       int i;
       for (i = 0; i < len2; i++)
       {
             dest[len1 + i] = src[i];
       }
}
int main()
{
       char dst[100] = "hello mike";
       char src[] = "123456";
       mystrcat(dst, src);
       printf("dst = %s\n", dst);
       return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
       //const修饰一个变量为只读
       const int a = 10;
       //a = 100; //err

       //指针变量， 指针指向的内存， 2个不同概念
       char buf[] = "aklgjdlsgjlkds";

       //从左往右看，跳过类型，看修饰哪个字符
       //如果是*， 说明指针指向的内存不能改变
       //如果是指针变量，说明指针的指向不能改变，指针的值不能修改
       const char *p = buf;

       // 等价于上面 char const *p1 = buf;
       //p[1] = ‘2‘; //err
       p = "agdlsjaglkdsajgl"; //ok

       char * const p2 = buf;
       p2[1] = ‘3‘;
       //p2 = "salkjgldsjaglk"; //err

       //p3为只读，指向不能变，指向的内存也不能变
       const char * const p3 = buf;
       return 0;
}

#include <stdio.h>
//argc: 传参数的个数（包含可执行程序）
//argv：指针数组，指向输入的参数
int main(int argc, char *argv[])
{
       //指针数组，它是数组，每个元素都是指针
       char *a[] = { "aaaaaaa", "bbbbbbbbbb", "ccccccc" };
       int i = 0;
       printf("argc = %d\n", argc);
       for (i = 0; i < argc; i++)
       {
              printf("%s\n", argv[i]);
       }
       return 0;
}

#include <stdio.h>

#include <stdlib.h>
#include <string.h>
int main(void)
{
       char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
       int n = 0;
       while ((p = strstr(p, "abcd")) != NULL)
       {
              //能进来，肯定有匹配的子串
              //重新设置起点位置
              p = p + strlen("abcd");
              n++;
              if (*p == 0) //如果到结束符
              {
                    break;
              }
       }
       printf("n = %d\n", n);
       return 0;
}

#include <stdio.h>

#include <stdlib.h>
#include <string.h>
int main(void)
{
       char *p = "11abcd111122abcd333abcd3322abcd3333322qqq";
       int n = 0;
       do
       {
              p = strstr(p, "abcd");
              if (p != NULL)
              {
                     n++; //累计个数
                     //重新设置查找的起点
                     p = p + strlen("abcd");
              }
              else //如果没有匹配的字符串，跳出循环
              {
                     break;
              }
       } while (*p != 0); //如果没有到结尾
       printf("n = %d\n", n);
       return 0;
}

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

int fun(char *p, int *n)
{
      if (p == NULL || n == NULL)
       {
              return -1;
       }
       int begin = 0;
       int end = strlen(p) - 1;

       //从左边开始
       //如果当前字符为空，而且没有结束
       while (p[begin] == ‘ ‘ && p[begin] != 0)
       {
              begin++; //位置从右移动一位
       }
       //从右往左移动
       while (p[end] == ‘ ‘ && end > 0)
       {
              end--; //往左移动
       }
       if (end == 0)
       {
              return -2;
       }
       //非空元素个数
       *n = end - begin + 1;
       return 0;
}

int main(void)
{
       char *p = "      abcddsgadsgefg      ";
       int ret = 0;
       int n = 0;

       ret = fun(p, &n);
       if (ret != 0)
       {
              return ret;
       }
       printf("非空字符串元素个数：%d\n", n);
       return 0;
}

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

int inverse(char *p)
{
       if (p == NULL)
       {
              return -1;
       }
       char *str = p;
       int begin = 0;
       int end = strlen(str) - 1;
       char tmp;

       while (begin < end)
       {
             //交换元素
              tmp = str[begin];
              str[begin] = str[end];
              str[end] = tmp;
              begin++;  //往右移动位置
              end--;         //往左移动位置
       }
       return 0;
}

int main(void)
{
       //char *str = "abcdefg"; //文件常量区，内容不允许修改
       char str[] = "abcdef";
       int ret = inverse(str);
       if (ret != 0)
       {
              return ret;
       }
       printf("str ========== %s\n", str);
       return 0;
}

#include <stdio.h>
void test()
{
       //auto写不写是一样的
      //auto只能出现在{}内部
       auto int b = 10;
}

int main(void)
{
       //b = 100; //err， 在main作用域中没有b
       if (1)
       {
              //在复合语句中定义，只在复合语句中有效
              int a = 10;
              printf("a = %d\n", a);
       }
       //a = 10; //err离开if()的复合语句，a已经不存在
       return 0;
}

#include <stdio.h>
void fun1()
{
       int i = 0;
       i++;
      printf("i = %d\n", i);
}
void fun2()
{
       //静态局部变量，没有赋值，系统赋值为0，而且只会初始化一次
       static int a;
       a++;
       printf("a = %d\n", a);
}
int main(void)
{
       fun1();
       fun1();
       fun2();
       fun2();
       return 0;
}

#include <string.h>
void *memset(void *s, intc, size_tn);
功能：将s的内存区域的前n个字节以参数c填入
参数：
       s：需要操作内存s的首地址
       c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255
       n：指定需要设置的大小
返回值：s的首地址
       int a[10];
       memset(a, 0, sizeof(a));
       memset(a, 97, sizeof(a));
       int i = 0;
       for (i = 0; i < 10; i++)
       {
              printf("%c\n", a[i]);
       }

#include <string.h>
void *memcpy(void *dest, constvoid *src, size_tn);
功能：拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。
参数：
       dest：目的内存首地址
       src：源内存首地址，注意：dest和src所指的内存空间不可重叠
       n：需要拷贝的字节数
返回值：dest的首地址
       int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
       int b[10];
       memcpy(b, a, sizeof(a));
       int i = 0;
       for (i = 0; i < 10; i++)
       {
              printf("%d, ", b[i]);
       }
       printf("\n");
       //memcpy(&a[3], a, 5 * sizeof(int)); //err, 内存重叠

#include <string.h>
intmemcmp(constvoid *s1, constvoid *s2, size_tn);
功能：比较s1和s2所指向内存区域的前n个字节
参数：
       s1：内存首地址1
       s2：内存首地址2
      n：需比较的前n个字节

返回值：
       相等：=0
       大于：>0
       小于：<0
       int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
       int b[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
       int flag = memcmp(a, b, sizeof(a));
       printf("flag = %d\n", flag);

#include <stdlib.h>
void *malloc(size_tsize);
功能：在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间内容不确定，一般使用memset初始化。
参数：
       size：需要分配内存大小(单位：字节)
返回值：
成功：分配空间的起始地址
失败：NULL

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
       int count, *array, n;
       printf("请输入要申请数组的个数:\n");
       scanf("%d", &n);
      array = (int *)malloc(n * sizeof (int));
       if (array == NULL)
       {
              printf("申请空间失败!\n");
              return -1;
       }
       //将申请到空间清0
       memset(array, 0, sizeof(int)*n);
       for (count = 0; count < n; count++) /*给数组赋值*/

              array[count] = count;
       for (count = 0; count < n; count++) /*打印数组元素*/
              printf("%2d", array[count]);
       free(array);
       return 0;
}

#include <stdlib.h>

voidfree(void *ptr);

功能：释放ptr所指向的一块内存空间，ptr是一个任意类型的指针变量，指向被释放区域的首地址。对同一内存空间多次释放会出错。

参数：

ptr：需要释放空间的首地址，被释放区应是由malloc函数所分配的区域。

返回值：无

#include <stdio.h>
int a = 10;
int *fun()
{
       return &a;//函数调用完毕，a释放
}
int main(int argc, char *argv[])
{
       int *p = NULL;
       p = fun();
       *p = 100; //操作野指针指向的内存,err
       return 0;
}

#include <stdio.h>
int *fun()
{
       static int a = 10;
       return &a; //函数调用完毕，a不释放
}
int main(int argc, char *argv[])
{
       int *p = NULL;
       p = fun();
       *p = 100; //ok
       printf("*p = %d\n", *p);
       return 0;
}

#include <stdio.h>
#include <stdlib.h>
void fun(int *tmp)
{
       tmp = (int *)malloc(sizeof(int));
       *tmp = 100;
}
int main(int argc, char *argv[])
{
       int *p = NULL;
       fun(p); //值传递，形参修改不会影响实参
       printf("*p = %d\n", *p);//err，操作空指针指向的内存
       return 0;
}

#include <stdio.h>
#include <stdlib.h>
void fun(int *tmp)
{
       *tmp = 100;
}
int main(int argc, char *argv[])
{
       int *p = NULL;
       p = (int *)malloc(sizeof(int));
       fun(p); //值传递
       printf("*p = %d\n", *p); //ok，*p为100
      return 0;
}

#include <stdio.h>
#include <stdlib.h>
int *fun()
{
       int *tmp = NULL;
       tmp = (int *)malloc(sizeof(int));
       *tmp = 100;
       return tmp;//返回堆区地址，函数调用完毕，不释放
}
int main(int argc, char *argv[])
{
       int *p = NULL;
       p = fun();
       printf("*p = %d\n", *p);//ok
       //堆区空间，使用完毕，手动释放
       if (p != NULL)
       {
              free(p);
              p = NULL;
       }
       return 0;
}

//结构体类型的定义
struct stu
{
      char name[50];
       int age;
};

//先定义类型，再定义变量（常用）
struct stu s1 = { "mike", 18 };



//定义类型同时定义变量
struct stu2
{
       char name[50];
       int age;
}s2 = { "lily", 22 };

struct
{
       char name[50];
       int age;
}s3 = { "yuri", 25 };

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

//结构体类型的定义
struct stu
{
      char name[50];
       int age;
};
int main()
{
       struct stu s1;
       //如果是普通变量，通过点运算符操作结构体成员
       strcpy(s1.name, "abc");
       s1.age = 18;
       printf("s1.name = %s, s1.age = %d\n", s1.name, s1.age);

       //如果是指针变量，通过->操作结构体成员
       strcpy((&s1)->name, "test");
       (&s1)->age = 22;
       printf("(&s1)->name = %s, (&s1)->age = %d\n", (&s1)->name, (&s1)->age);
       return 0;
}

#include <stdio.h>
//统计学生成绩
struct stu
{
       int num;
       char name[20];
       char sex;
       float score;
};

int main()
{
       //定义一个含有5个元素的结构体数组并将其初始化
       struct stu boy[5] = {
              { 101, "Li ping", ‘M‘, 45 },                   
              { 102, "Zhang ping", ‘M‘, 62.5 },
              { 103, "He fang", ‘F‘, 92.5 },
              { 104, "Cheng ling", ‘F‘, 87 },
              { 105, "Wang ming", ‘M‘, 58 }};

       int i = 0;
       int c = 0;
       float ave, s = 0;
       for (i = 0; i < 5; i++)
       {
              s += boy[i].score;       //计算总分
              if (boy[i].score < 60)
              {
                     c += 1;          //统计不及格人的分数
              }
       }
       printf("s=%f\n", s);//打印总分数
       ave = s / 5;                                //计算平均分数
       printf("average=%f\ncount=%d\n\n", ave, c); //打印平均分与不及格人数
       for (i = 0; i < 5; i++)
       {
              printf(" name=%s,  score=%f\n", boy[i].name, boy[i].score);
           // printf(" name=%s,  score=%f\n", (boy+i)->name, (boy+i)->score);
       }
       return 0;
}

#include <stdio.h>
struct person
{
      char name[20];
       char sex;
};
struct stu
{
       int id;
       struct person info;
};
int main()
{
       struct stu s[2] = { 1, "lily", ‘F‘, 2, "yuri", ‘M‘ };
       int i = 0;
       for (i = 0; i < 2; i++)
       {
              printf("id = %d\tinfo.name=%s\tinfo.sex=%c\n", s[i].id, s[i].info.name, s[i].info.sex);
       }
       return 0;
}

#include<stdio.h>
#include<string.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};
int main()
{
       struct stu s1;
       //如果是普通变量，通过点运算符操作结构体成员
       strcpy(s1.name, "abc");
       s1.age = 18;
       printf("s1.name = %s, s1.age = %d\n", s1.name, s1.age);
       //相同类型的两个结构体变量，可以相互赋值
       //把s1成员变量的值拷贝给s2成员变量的内存
       //s1和s2只是成员变量的值一样而已，它们还是没有关系的两个变量
       struct stu s2 = s1;
//memcpy(&s2, &s1, sizeof(s1));
       printf("s2.name = %s, s2.age = %d\n", s2.name, s2.age);
       return 0;
}

#include<stdio.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};
int main()
{
       struct stu s1 = { "lily", 18 };
       //如果是指针变量，通过->操作结构体成员
       struct stu *p = &s1;
       printf("p->name = %s, p->age=%d\n", p->name, p->age);
       printf("(*p).name = %s, (*p).age=%d\n",  (*p).name,  (*p).age);
       return 0;
}

#include<stdio.h>
#include <string.h>
#include <stdlib.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};

int main()
{
       struct stu *p = NULL;
       p = (struct stu *)malloc(sizeof(struct  stu));

       //如果是指针变量，通过->操作结构体成员
       strcpy(p->name, "test");
       p->age = 22;
       printf("p->name = %s, p->age=%d\n", p->name, p->age);
       printf("(*p).name = %s, (*p).age=%d\n", (*p).name,  (*p).age);
       free(p);
       p = NULL;
       return 0;
}

#include<stdio.h>
#include <string.h>
#include <stdlib.h>
//结构体类型的定义
struct stu
{
       char *name; //一级指针
       int age;
};
int main()
{
       struct stu *p = NULL;
       p = (struct stu *)malloc(sizeof(struct  stu));
       p->name = malloc(strlen("test") + 1);
       strcpy(p->name, "test");
       p->age = 22;
       printf("p->name = %s, p->age=%d\n", p->name, p->age);
       printf("(*p).name = %s, (*p).age=%d\n", (*p).name, (*p).age);
       if (p->name != NULL)
       {
              free(p->name);
              p->name = NULL;
       }
       if (p != NULL)
       {
              free(p);
              p = NULL;
       }
       return 0;
}

#include<stdio.h>
#include <string.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};
//函数参数为结构体普通变量
void set_stu(struct stu tmp)
{
       strcpy(tmp.name, "mike");
       tmp.age = 18;
       printf("tmp.name = %s, tmp.age = %d\n", tmp.name, tmp.age);
}
int main()
{
       struct stu s = { 0 };
       set_stu(s); //值传递
       printf("s.name = %s, s.age = %d\n", s.name, s.age);
       return 0;
}

#include<stdio.h>
#include <string.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};

//函数参数为结构体指针变量
void set_stu_pro(struct stu *tmp)
{
       strcpy(tmp->name, "mike");
       tmp->age = 18;
}
int main()
{
       struct stu s = { 0 };
       set_stu_pro(&s); //地址传递
       printf("s.name = %s, s.age = %d\n", s.name, s.age);
       return 0;
}

#include<stdio.h>
//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};
//void set_stu_pro(struct stu tmp[100], int n)
//void set_stu_pro(struct stu tmp[], int n)
void set_stu_pro(struct stu *tmp, int n)
{
       int i = 0;
       for (i = 0; i < n; i++)
       {
              sprintf(tmp->name, "name%d%d%d", i, i, i);
              tmp->age = 20 + i;
             tmp++;
       }
}
int main()
{
       struct stu s[3] = { 0 };
       int i = 0;
       int n = sizeof(s) / sizeof(s[0]);
       set_stu_pro(s, n); //数组名传递
       for (i = 0; i < n; i++)
       {
              printf("%s, %d\n", s[i].name, s[i].age);
       }
       return 0;
}

//结构体类型的定义
struct stu
{
       char name[50];
       int age;
};
void fun1(struct stu * const p)
{
       //p = NULL; //err
       p->age = 10; //ok
}
//void fun2(struct stu const*  p)
void fun2(const struct stu *  p)
{
       p = NULL; //ok
       //p->age = 10; //err
}
void fun3(const struct stu * const p)
{
       //p = NULL; //err
       //p->age = 10; //err
}

#include <stdio.h>
//共用体也叫联合体
union Test
{
       unsigned char a;
       unsigned int b;
       unsigned short c;
};
int main()
{
       //定义共用体变量
       union Test tmp;
       //1、所有成员的首地址是一样的
       printf("%p, %p, %p\n", &(tmp.a), &(tmp.b), &(tmp.c));
       //2、共用体大小为最大成员类型的大小
       printf("%lu\n", sizeof(union Test));

       //3、一个成员赋值，会影响另外的成员
       //左边是高位，右边是低位
       //低位放低地址，高位放高地址
       tmp.b = 0x44332211;
       printf("%x\n", tmp.a); //11
       printf("%x\n", tmp.c); //2211

       tmp.a = 0x00;
       printf("short: %x\n", tmp.c); //2200
       printf("int: %x\n", tmp.b); //44332200
       return 0;
}

#include <stdio.h>
enum weekday
{
       sun = 2, mon, tue, wed, thu, fri, sat
} ; 
enum bool
{
       flase, true
};
int main()
{
       enum weekday a, b, c;
       a = sun;
       b = mon;
       c = tue;
       printf("%d,%d,%d\n", a, b, c);
       enum bool flag;
       flag = true;
       if (flag == 1)
       {
              printf("flag为真\n");
       }
       return 0;
}

#include <stdio.h>

typedef int INT;

typedef char BYTE;

typedef BYTE T_BYTE;

typedef unsigned char UBYTE;

typedef struct type

{

       UBYTE a;

       INT b;

      T_BYTE c;

}TYPE, *PTYPE;
int main()
{
       TYPE t;
       t.a = 254;
       t.b = 10;
       t.c = ‘c‘;
       PTYPE p = &t;
       printf("%u, %d, %c\n", p->a, p->b, p->c);
       return 0;
}

typedef struct

{

       short           level;    //缓冲区"满"或者"空"的程度

       unsigned        flags;   //文件状态标志

       char            fd;             //文件描述符

       unsigned char   hold;      //如无缓冲区不读取字符

       short           bsize;   //缓冲区的大小

       unsigned char   *buffer;//数据缓冲区的位置

       unsigned        ar; //指针，当前的指向

       unsigned        istemp;       //临时文件，指示器

       short           token;  //用于有效性的检查

}FILE;

#include <stdio.h>

FILE * fopen(constchar * filename, constchar * mode);

功能：打开文件

参数：

       filename：需要打开的文件名，根据需要加上路径

       mode：打开文件的模式设置

返回值：

       成功：文件指针

       失败：NULL

第一个参数的几种形式:

       FILE *fp_passwd = NULL;
       //相对路径：

       //打开当前目录passdw文件：源文件(源程序)所在目录

       FILE *fp_passwd = fopen("passwd.txt", "r");
       //打开当前目录(test)下passwd.txt文件
       fp_passwd = fopen(". / test / passwd.txt", "r");
       //打开当前目录上一级目录（相对当前目录）passwd.txt文件

       fp_passwd = fopen(".. / passwd.txt", "r");
        
       //绝对路径：

       //打开C盘test目录下一个叫passwd.txt文件

       fp_passwd = fopen("c://test//passwd.txt","r");

int main(void)
{
      FILE *fp = NULL;
       // "\\"这样的路径形式，只能在windows使用
       // "/"这样的路径形式，windows和linux平台下都可用，建议使用这种
      // 路径可以是相对路径，也可是绝对路径
       fp = fopen("../test", "w");
       //fp = fopen("..\\test", "w");
       if (fp == NULL) //返回空，说明打开失败
       {
              //perror()是标准出错打印函数，能打印调用库函数出错原因
              perror("open");
              return -1;
       }
       return 0;
}

#include <stdio.h>
int fclose(FILE * stream);
功能：关闭先前fopen()打开的文件。此动作让缓冲区的数据写入文件中，并释放系统所提供的文件资源。
参数：
       stream：文件指针
返回值：
       成功：0
       失败：-1 
       FILE * fp = NULL;
       fp = fopen("abc.txt", "r");
       fclose(fp); 

#include <stdio.h>
int fputc(int ch, FILE * stream);
功能：将ch转换为unsigned char后写入stream指定的文件中
参数：
       ch：需要写入文件的字符
       stream：文件指针
返回值：
       成功：成功写入文件的字符
       失败：返回-1
char buf[] = "this is a test for fputc";
int i = 0;
int n = strlen(buf);
for (i = 0; i < n; i++)
{
       //往文件fp写入字符buf[i]
       int ch = fputc(buf[i], fp);
       printf("ch = %c\n", ch);
}

#include <stdio.h>
int feof(FILE * stream);
功能：检测是否读取到了文件结尾。判断的是最后一次“读操作的内容”，不是当前位置内容(上一个内容)。
参数：
       stream：文件指针
返回值：
       非0值：已经到文件结尾
       0：没有到文件结尾

#include <stdio.h>

int fgetc(FILE * stream);

功能：从stream指定的文件中读取一个字符

参数：

       stream：文件指针

返回值：

       成功：返回读取到的字符

       失败：-1

 

char ch;

#if 0

while ((ch = fgetc(fp)) != EOF)

{

       printf("%c", ch);

}

printf("\n");

#endif

 

while (!feof(fp)) //文件没有结束，则执行循环
{
       ch = fgetc(fp);
      printf("%c", ch);

}
printf("\n");

#include <stdio.h>
int fputs(constchar * str, FILE * stream);
功能：将str所指定的字符串写入到stream指定的文件中，字符串结束符 ‘\0‘  不写入文件。
参数：
       str：字符串
       stream：文件指针
返回值：
       成功：0
       失败：-1

char *buf[] = { "123456\n", "bbbbbbbbbb\n", "ccccccccccc\n" };
int i = 0;
int n = 3;
for (i = 0; i < n; i++)
{
       int len = fputs(buf[i], fp);
       printf("len = %d\n", len);
}

#include <stdio.h>
char * fgets(char * str, int size, FILE * stream);
功能：从stream指定的文件内读入字符，保存到str所指定的内存空间，直到出现换行字符、读到文件结尾或是已读了size - 1个字符为止，最后会自动加上字符 ‘\0‘ 作为字符串结束。
参数：
       str：字符串
       size：指定最大读取字符串的长度（size - 1）
       stream：文件指针
返回值：
       成功：成功读取的字符串
       读到文件尾或出错： NULL
char buf[100] = 0;
while (!feof(fp)) //文件没有结束
{
       memset(buf, 0, sizeof(buf));
       char *p = fgets(buf, sizeof(buf), fp);
       if (p != NULL)
       {
              printf("buf = %s", buf);
       }
}

#include <stdio.h>
int fprintf(FILE * stream, constchar * format, ...);
功能：根据参数format字符串来转换并格式化数据，然后将结果输出到stream指定的文件中，指定出现字符串结束符 ‘\0‘  为止。
参数：
       stream：已经打开的文件
       format：字符串格式，用法和printf()一样
返回值：
       成功：实际写入文件的字符个数
       失败：-1
fprintf(fp, "%d %d %d\n", 1, 2, 3);

#include <stdio.h>
int fscanf(FILE * stream, constchar * format, ...);
功能：从stream指定的文件读取字符串，并根据参数format字符串来转换并格式化数据。
参数：
       stream：已经打开的文件
       format：字符串格式，用法和scanf()一样
返回值：
       成功：参数数目，成功转换的值的个数
       失败： - 1
int a = 0;
int b = 0;
int c = 0;
fscanf(fp, "%d %d %d\n", &a, &b, &c);
printf("a = %d, b = %d, c = %d\n", a, b, c);

#include <stdio.h>
size_t fwrite(constvoid *ptr, size_t size, size_t nmemb, FILE *stream);
功能：以数据块的方式给文件写入内容
参数：
       ptr：准备写入文件数据的地址
       size： size_t 为 unsigned int类型，此参数指定写入文件内容的块数据大小
       nmemb：写入文件的块数，写入文件数据总大小为：size * nmemb
       stream：已经打开的文件指针
返回值：
       成功：实际成功写入文件数据的块数目，此值和nmemb相等
       失败：0

typedef struct Stu
{
       char name[50];
       int id;
}Stu;

Stu s[3];
int i = 0;
for (i = 0; i < 3; i++)
{
       sprintf(s[i].name, "stu%d%d%d", i, i, i);
       s[i].id = i + 1;
}

int ret = fwrite(s, sizeof(Stu), 3, fp);

printf("ret = %d\n", ret);

#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
功能：以数据块的方式从文件中读取内容
参数：
       ptr：存放读取出来数据的内存空间
       size： size_t 为 unsigned int类型，此参数指定读取文件内容的块数据大小
       nmemb：读取文件的块数，读取文件数据总大小为：size * nmemb
       stream：已经打开的文件指针

返回值：

       成功：实际成功读取到内容的块数，如果此值比nmemb小，但大于0，说明读到文件的结尾。
       失败：0

typedef struct Stu
{
       char name[50];
       int id;
}Stu;
Stu s[3];
int ret = fread(s, sizeof(Stu), 3, fp);
printf("ret = %d\n", ret);
int i = 0;
for (i = 0; i < 3; i++)
{
       printf("s = %s, %d\n", s[i].name, s[i].id);
}

#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
功能：移动文件流（文件光标）的读写位置。
参数：
      stream：已经打开的文件指针
offset：根据whence来移动的位移数（偏移量），可以是正数，也可以负数，如果正数，则相对于whence往右移动，如果是负数，则相对于whence往左移动。如果向前移动的字节数超过了文件开头则出错返回，如果向后移动的字节数超过了文件末尾，再次写入时将增大文件尺寸。
       whence：其取值如下：
              SEEK_SET：从文件开头移动offset个字节
              SEEK_CUR：从当前位置移动offset个字节
              SEEK_END：从文件末尾移动offset个字节
返回值：
       成功：0
       失败：-1
#include <stdio.h>
long ftell(FILE *stream);
功能：获取文件流（文件光标）的读写位置。
参数：
       stream：已经打开的文件指针
返回值：
       成功：当前文件流（文件光标）的读写位置
       失败：-1
#include <stdio.h>
void rewind(FILE *stream);
功能：把文件流（文件光标）的读写位置移动到文件开头。
参数：
       stream：已经打开的文件指针
返回值：
       无返回值
typedef struct Stu
{
       char name[50];
       int id;
}Stu;
//假如已经往文件写入3个结构体
//fwrite(s, sizeof(Stu), 3, fp);
Stu s[3];
Stu tmp;
int ret = 0;

//文件光标读写位置从开头往右移动2个结构体的位置
fseek(fp, 2 * sizeof(Stu), SEEK_SET);

//读第3个结构体
ret = fread(&tmp, sizeof(Stu), 1, fp);
if (ret == 1)
{
       printf("[tmp]%s, %d\n", tmp.name, tmp.id);
}

//把文件光标移动到文件开头
//fseek(fp, 0, SEEK_SET);
rewind(fp);
ret = fread(s, sizeof(Stu), 3, fp);
printf("ret = %d\n", ret);
int i = 0;
for (i = 0; i < 3; i++)
{
       printf("s === %s, %d\n", s[i].name, s[i].id);
}

#include<stdio.h>
int main(int argc, char **args)
{
       if (argc < 2)
              return 0;

       FILE *p = fopen(args[1], "rb");
       if (!p)
              return 0;
       char a[1024] = { 0 };
       fgets(a, sizeof(a), p);
       int len = 0;
       while (a[len])
       {
              if (a[len] == ‘\n‘)
              {
                     if (a[len - 1] == ‘\r‘)
                     {
                            printf("windows file\n");
                     }
                     else
                     {
                            printf("linux file\n");
                     }
              }
              len++;
       }
       fclose(p);
       return 0;
}

#include <sys/types.h>
#include <sys/stat.h>
intstat(constchar *path, structstat *buf);
功能：获取文件状态信息
参数：
path：文件名
buf：保存文件信息的结构体
返回值：
成功：0
失败-1
struct stat {
       dev_t         st_dev;         //文件的设备编号
       ino_t         st_ino;          //节点
       mode_t        st_mode;   //文件的类型和存取的权限
       nlink_t       st_nlink;     //连到该文件的硬连接数目，刚建立的文件值为1
       uid_t         st_uid;         //用户ID

       gid_t         st_gid;         //组ID
       dev_t         st_rdev;      //(设备类型)若此文件为设备文件，则为其设备编号
       off_t         st_size;        //文件字节数(文件大小)
       unsigned long st_blksize;   //块大小(文件系统的I/O 缓冲区大小)
       unsigned long st_blocks;    //块数
       time_t        st_atime;     //最后一次访问时间
       time_t        st_mtime;    //最后一次修改时间
       time_t        st_ctime;     //最后一次改变时间(指属性)
};


#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
int main(int argc, char **args)
{
       if (argc < 2)
              return 0;
       struct stat st = { 0 };
       stat(args[1], &st);
       int size = st.st_size;//得到结构体中的成员变量
       printf("%d\n", size);
       return 0;

}

#include <stdio.h>
intremove(constchar *pathname);
功能：删除文件
参数：
       pathname：文件名
返回值：
       成功：0
       失败：-1
#include <stdio.h>
intrename(constchar *oldpath, constchar *newpath);
功能：把oldpath的文件名改为newpath
参数：
oldpath：旧文件名
newpath：新文件名
返回值：
成功：0
失败： - 1

#include <stdio.h>
intfflush(FILE *stream);
功能：更新缓冲区，让缓冲区的数据立马写到文件中。
参数：
stream：文件指针
返回值：
成功：0
失败：-1