c语言提高学习笔记——02-c提高01day

 1 typedef unsigned int u32;
 2 typedef struct _PERSON{
 3     char name[64]；
 4     int age；
 5 }Person;
 6 
 7 void test(){
 8     u32 val；//相当于unsigned int val；
 9     Person person；//相当于struct PERSON person；
10 }

1 typedef char* PCHAR
2 
3 PCHAR p1, p2;

1  typedef long long mytype_t;
2 
3 //有利于程序移植性

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct Person
 7 {
 8     char name[64];
 9     int age;
10     struct Person p;   
11 };
12 
13 void test01()
14 {
15     struct Person p;
16 }
17 
18 int main()
19 {
20     test01();
       system("pause");
       return EXIT_SUCCESS;
21 }

 1 //1.sizeof基本用法
 2 void test01(){
 3 
 4 int a=10；
 5 
 6 printf("1en:%d\n",sizeof(a))；
 7 printf("len:%d\n",sizeof(int))；
 8 printf("len:%d\n",sizeof a);
 9 }
10 
11 //2.sizeof结果类型
12 void test02(){
13 
14 unsigned int a=10；
15 
16 if(a-11<0){ //无符号的数a与有符号的数大多数编译器运算结果仍然是无符号的！
17 printf（"结果小于0\n"）；
18 }
19 else{
20 printf（"结果大于0\n"）；
21 }
22 int b=5；
23 
24 if(sizeof(b)-10<0){
25 printf("结果小于0\n"）；
26 }
27 else{
28 printf("结果大于0\n"）；
29 }
30 
31 //3.sizeof 碰到数组
32 void TestArray(int arr[]){
33 printf("TestArray arr size:%d\n",sizeof(arr));
34 }
35 void test03{
36 int arr[]={10,20,30,40，50}；
37 printf("array size:%d\n",sizeof(arr));//20
38 //数组名在某些情况下等价于指针
39 int* pArr=arr；
40 printf("arr[2]:%d\n",pArr[2])；
41 printf("array size:%d\n",sizeof(pArr))；
42 //数组做函数函数参数，将退化为指针，在函数内部不再返回数组大小
43 TestArray(arr)；//4
44 }

 1 //格式一
 2 struct tagPhone
 3 {
 4     char A；
 5     int B；
 6     short C；
 7 }Phone;
 8 //格式二
 9 struct tagPhone
10 {
11     char A；
12     short C；
13     int B；
14 }Phone2;
15 //格式三
16 struct tagPhone3
17 {
18     char A；
19     char B[2]；
20     char c[4j；
21 }Phone3;

 1 void test(){
 2 int a=10；
 3 
 4     //1.直接修改
 5     a=20；
 6     printf（"直接修改，a:%d\n"，a）；
 7 
 8     //2.间接修改
 9     int*p=&a；
10     *p=30；
11     printf（"间接修改，a:%d\n"，a）；
12 }

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct Person
 7 {
 8     char a;
 9     int b;
10     char c;
11     int d;
12 }
13 
14 void test02()
15 {
16     struct Person p = {'a', 100, 'b', 200};
17     printf("p.d:%d\n",p.d);
18 
19     p.d = 1000;//修改d
20 
21 } 
22 int main()
23 {
24     test02();
25     printf()
26     system("pause");
27     return EXIT_SUCCESS;
28 }    

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 struct Person
 7 {
 8     char a;
 9     int b;
10     char c;
11     int d;
12 }
13 
14 void test02()
15 {
16     struct Person p = {'a', 100, 'b', 200};
17     printf("p.d:%d\n",p.d);
18 
19     p.d = 1000;//修改d
20     //(char *)&p +12结构体所占大小按最大的（int）计算，所以p.d的起始地址为：先计算起始地址&p，然后转成(char *)1个字节，然后加上12个字节
21     //printf("(char *)&p +12:%d\n",(char *)&p +12);//测试p.d的起始地址
22     //printf("&p.d:%d\n",&p.d);//测试p.d的起始地址
23     printf("(int *)((char *)&p +12):%d\n",(int *)((char *)&p +12));//找到d
24 } 
25 int main()
26 {
27     test02();
28     printf()
29     system("pause");
30     return EXIT_SUCCESS;
31 }    

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 
 6 //1.栈区的内存自动申请自动释放，不需要程序手动管理
 7 int* myFunc()
 8 {
 9     int a = 10;
10     return &a;//不要返回局部变量的地址
11 }
12 
13 void test01()
14 {
15     //我们并不关心a的值是多少，因为局部变量a的内存已经被回收
16     int* p = myFunc();
17     printf("*p = %d\n", *p);
18 }
19 
20 char *getString()
21 {
22     char str[] = "hello world";
23     return str;
24 }
25 
26 void test02()
27 {
28     char *s = NULL;
29     s = getString();
30     printf("s = %s\n", s);//返回报错！！！
31 }
32 
33 int main(){
34 
35     //test01();
36     test02();
37     
38     system("pause");
39     return EXIT_SUCCESS;
40 }

 1 #char* func(){
 2 char p[]="hello world!"；//在栈区存储乱码
 3 printf("%s\n",p)；
 4 return p；
 5 }
 6 void test(){
 7 char*p=NULL；
 8 p=func()；
 9 printf("%s\n",p);
10 }

 1 char* func(){
 2 char* str=malloc(100）；
 3 strcpy(str，"hello world!"）；
 4 printf("%s\n"，str)；
 5 return str；
 6 }
 7 void test01(){
 8 char*p=NULL；
 9 p=func()；
10 printf（"%s\n"，p）；
11 }
12 void allocateSpace(char* p){
13 p=malloc(100）；
14 strcpy(p，"hello world!"）；
15 printf（"%s\n"，p)；
16 }
17 void test02(){
18 char*p=NULL；
19 allocateSpace(p)；
20 printf("%s\n"，p)；
21 }

 1 #include<stdlib.h>
 2 void *calloc(size_t nmemb,size_t size);
 3 功能：
 4     在内存动态存储区中分配nmemb块长度为size字节的连续区域。calloc自动将分配的内存置0。
 5 参数：
 6     nmemb：所需内存单元数量
 7     size：每个内存单元的大小（单位：字节）
 8 返回值：
 9     成功：分配空间的起始地址
10     失败：NULL

 1 #include<stdlib.h>
 2 void *realloc(void *ptr,size_t size);
 3 功能：
 4     重新分配用malloc或者calloc函数在堆中分配内存空间的大小。realloc不会自动清理增加的内存，需要手动清理，如果指定的地址后面有连续的空间，那么就会在已有地址基础上增加内存，如果指定的地址后面没有空间，那么realloc会重新分配新的连续内存，把旧内存的值拷贝到新内存，同时释放旧内存。
 5 参数：
 6    ptr:为之前用malloc或者calloc分配的内存地址，如果此参数等于NULL，那么和realloc与malloc功能一致
 7    size：为重新分配内存的大小，单位：字节
 8 返回值：
 9     成功：新分配的堆内存地址
10     失败：NULL

 1 void test01){
 2 int* pl=calloc(10,sizeof(int))；
 3 if(pl==NULL){
 4 return；
 5 }
 6 for(int i=0；i<10；i++){
 7 pl[i]=i+1；
 8 }
 9 for(inti=0；i<10；i++){
10 printf（"%d"，pl[i]）；
11 }
12 printf("\n")；
13 free(pl)；
14 }
15 
16 void test02(){
17 int* pl=calloc(10,sizeof(int))；
18 if(pl==NULL){
19 return；
20 }
21 for(int i=0;i<10;i++){
22 pl[i]=i+1；
23 }
24 
25 int* p2=realloc(pl,15* sizeof(int))；
26 if(p2==NULL){
27 return；
28 }
29 printf("%d\n"，pl)；
30 printf（"%d\n"，p2）；
31 
32 //打印
33 for(int i=0;i<15;i++){
34 printf("%d"，p2[i])；
35 }
36 printf("\n")；
37 
38 //重新赋值
39 for(inti=0;i<15;i++){
40 p2[i]=i+1;
41 }
42 
43 //再次打印
44 for(int i=0；i<15;i++){
45 printf("%d"，p2[i])；
46 printf("\n")；
47 free(p2)；
48 }

1 int v1=10；//全局/静态区
2 const int v2=20；//常量，一旦初始化，不可修改
3 static int v3=20;//全局/静态区
4 char*p1；//全局/静态区，编译器默认初始化为NULL
5 //那么全局static int和全局int变量有什么区别?
6 void test(){
7 static int v4=20；//全局/静态区
8 }

 1 char* func（){
 2 static char arr[]="hello world!";//在静态区存储可读可写
 3 arr[2]='c'；
 4 char*p="hello world!"；//全局/静态区-字符串常量区
 5 //p[2]='c'；//只读，不可修改
 6 printf("%d\n",arr)；
 7 printf("%d\n",p)；
 8 printf("%s\n",arr)；
 9 return arr；
10 }
11 
12 void test(){
13 char*p=func()；
14 printf("ss\n",p);
15 }