void test(){
 
 //1. 格式化字符串
 char buf[1024] = { 0 };
 sprintf(buf, "你好,%s,欢迎加入我们!", "John");
 printf("buf:%s\n",buf);
 
 memset(buf, 0, 1024);
 sprintf(buf, "我今年%d岁了!", 20);
 printf("buf:%s\n", buf);
 
 //2. 拼接字符串
 memset(buf, 0, 1024);
 char str1[] = "hello";
 char str2[] = "world";
 int len = sprintf(buf,"%s %s",str1,str2);
 printf("buf:%s len:%d\n", buf,len);
 
 //3. 数字转字符串
 memset(buf, 0, 1024);
 int num = 100;
 sprintf(buf, "%d", num);
 printf("buf:%s\n", buf);
 //设置宽度 右对齐
 memset(buf, 0, 1024);
 sprintf(buf, "%8d", num);
 printf("buf:%s\n", buf);
 //设置宽度 左对齐
 memset(buf, 0, 1024);
 sprintf(buf, "%-8d", num);
 printf("buf:%s\n", buf);
 //转成16进制字符串 小写
 memset(buf, 0, 1024);
 sprintf(buf, "0x%x", num);
 printf("buf:%s\n", buf);
 
 //转成8进制字符串
 memset(buf, 0, 1024);
 sprintf(buf, "0%o", num);
 printf("buf:%s\n", buf);
}

//1. 跳过数据
void test01(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 //匹配第一个字符是否是数字，如果是，则跳过
 //如果不是则停止匹配
 sscanf("123456aaaa", "%*d%s", buf); 
 printf("buf:%s\n",buf);
}
 
//2. 读取指定宽度数据
void test02(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 sscanf("123456aaaa", "%7s", buf);
 printf("buf:%s\n", buf);
}
 
//3. 匹配a-z中任意字符
void test03(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 //先匹配第一个字符，判断字符是否是a-z中的字符，如果是匹配
 //如果不是停止匹配
 sscanf("abcdefg123456", "%[a-z]", buf);
 printf("buf:%s\n", buf);
}
 
//4. 匹配aBc中的任何一个
void test04(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 //先匹配第一个字符是否是aBc中的一个，如果是，则匹配，如果不是则停止匹配
 sscanf("abcdefg123456", "%[aBc]", buf);
 printf("buf:%s\n", buf);
}
 
//5. 匹配非a的任意字符
void test05(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 //先匹配第一个字符是否是aBc中的一个，如果是，则匹配，如果不是则停止匹配
 sscanf("bcdefag123456", "%[^a]", buf);
 printf("buf:%s\n", buf);
}
 
//6. 匹配非a-z中的任意字符
void test06(){
 char buf[1024] = { 0 };
 //跳过前面的数字
 //先匹配第一个字符是否是aBc中的一个，如果是，则匹配，如果不是则停止匹配
 sscanf("123456ABCDbcdefag", "%[^a-z]", buf);
 printf("buf:%s\n", buf);
}

void test(){
 char buf[3] = "abc";
 printf("buf:%s\n",buf);
}

void test(){
 char *p = (char *)malloc(50);
 char buf[] = "abcdef";
 int n = strlen(buf);
 int i = 0;
 for (i = 0; i < n; i++)
 {
  *p = buf[i];
  p++; //修改原指针指向
 }
 free(p);
}

char *get_str()
{
 char str[] = "abcdedsgads"; //栈区，
 printf("[get_str]str = %s\n", str);
 return str;
}

void test(){ 
 char *p = NULL;
 p = (char *)malloc(50);
 strcpy(p, "abcdef");
 if (p != NULL)
 {
  //free()函数的功能只是告诉系统 p 指向的内存可以回收了
  // 就是说，p 指向的内存使用权交还给系统
  //但是，p的值还是原来的值(野指针)，p还是指向原来的内存
  free(p); 
 }
 if (p != NULL)
 {
  free(p);
 }
}

//const修饰变量
void test01(){
 //1. const基本概念
 const int i = 0;
 //i = 100; //错误，只读变量初始化之后不能修改
 
 //2. 定义const变量最好初始化
 const int j;
 //j = 100; //错误，不能再次赋值
 
 //3. c语言的const是一个只读变量，并不是一个常量，可通过指针间接修改
 const int k = 10;
 //k = 100; //错误，不可直接修改，我们可通过指针间接修改
 printf("k:%d\n", k);
 int* p = &k;
 *p = 100;
 printf("k:%d\n", k);
}
 
//const 修饰指针
void test02(){
 
 int a = 10;
 int b = 20;
 //const放在*号左侧 修饰p_a指针指向的内存空间不能修改,但可修改指针的指向
 const int* p_a = &a;
 //*p_a = 100; //不可修改指针指向的内存空间
 p_a = &b; //可修改指针的指向
 
 //const放在*号的右侧， 修饰指针的指向不能修改，但是可修改指针指向的内存空间
 int* const p_b = &a;
 //p_b = &b; //不可修改指针的指向
 *p_b = 100; //可修改指针指向的内存空间
 
 //指针的指向和指针指向的内存空间都不能修改
 const int* const p_c = &a;
}
//const指针用法
struct Person{
 char name[64];
 int id;
 int age;
 int score;
};
 
//每次都对对象进行拷贝，效率低，应该用指针
void printPersonByValue(struct Person person){
 printf("Name:%s\n", person.name);
 printf("Name:%d\n", person.id);
 printf("Name:%d\n", person.age);
 printf("Name:%d\n", person.score);
}
 
//但是用指针会有副作用，可能会不小心修改原数据
void printPersonByPointer(const struct Person *person){
 printf("Name:%s\n", person->name);
 printf("Name:%d\n", person->id);
 printf("Name:%d\n", person->age);
 printf("Name:%d\n", person->score);
}
void test03(){
 struct Person p = { "Obama", 1101, 23, 87 };
 //printPersonByValue(p);
 printPersonByPointer(&p);
}