指针

#include<stdio.h> int main(void) { double *p; double x=66.6; p=&x; //x占8个字节，一个字节是8位。一个字节一个地址。X存放一个地址，一般为首地址

 double arr []={1.1,2.2,3.3};
 double *q;
 q=&arr[0];
 printf ("%p/n",q);
 q=&arr[1];
 printf("%p/n",q);
 return 0;
 //地址相差8个字节，指针变量都只占四个字节 

}

 #include<stdio.h> 
 ​
 void f(int*p); 
 int main(void)
 {
   int i=10;
   
   f(&i);
   printf("i=%d/n",i);
   
   return 0;
   
   
 }
 void f(int *p)
 {
     *p=99;
 }

 #include<stdio.h>
 void f(int**p);
 int main(void)
 {
     int i=9;
     int*p=&i;
     printf("%p/n",p);
     f(&p);//存放的是地址 
     
     printf("%p/n",p);
     
     return 0;
     
 }
 void f(int**q){
     *q=(int*)0xffffffff;
 }

结构体

为什么会出现结构体

为了表示一些复杂的数据，普通类型无法满足要求

什么是结构体

结构体是用户根据实际需要定义自己的复合数据类型

两种方式

struct Student st={1000,”sunkuan”,20}; struct Student pst;

1. st.sid

2. pst=&st; pst->sid=99;//等价于（*pst）.sid==st.sid （推荐）

注意事项：

1. 不可以加减乘除，但可以相互赋值

2. 普通结构体变量和结构体指针变量作为函数相互传参问题

 #include<stdio.h>
 #include<string.h>
 //struct Student//类型是整体struct Student 
 //{
 //  int sid;
 //  char name[200];
 //  int age;
 //  
 // } ;//这个分号不能省 
 // 
 // int main(void) 
 // {
 //  printf("%d/n",2);
 //  struct Student st={1000,"sunkuan",20}; 
 // 
 ////    st.age=20;
 ////    strcpy(st.name,"sunkuan");
 ////    st.sid=1000;
 //  printf("%d %s %d/n",st.sid,st.name,st.age);//不可以直接使用st 
 //  return 0;
 // }
 // 
 int main(void) 
  {
     printf("%d/n",2);
     struct Student st={1000,"sunkuan",20}; 
     struct Student *pst;
     pst=&st;
     pst->sid=99;//等价于（*pst）.sid==st.sid 
     printf("%d %s %d/n",st.sid,st.name,st.age);//不可以直接使用st 
     return 0;
  }

 #include<stdio.h>
 #include<string.h>
 struct Student//类型是整体struct Student 
 {
     int sid;
     char name[200];
     int age;
     
  } ;//这个分号不能省 
   void f(struct Student*pst);
   void g(struct Student st);
   void g2(struct Student *pst);
 int main(void) 
  {
     
     struct Student st;
     f(&st);
 //  g(st);//整体赋值过来 
 g2(&st);//推荐。直接传地址 
     return 0;
 ​
  }
  //耗费内存 耗时间 不推荐 
  void g(struct Student st){
     printf("%d %s %d/n",st.sid,st.name,st.age);//不可以直接使用st 
  }
  void g2(struct Student *pst) {
     printf("%d %s %d/n",pst->sid,pst->name,pst->age);//不可以直接使用st 
  }
  void f(struct Student*pst){
     (*pst).sid=99;
     strcpy(pst->name,"sunkuan");
     pst->age=20;
 //  printf("%d %s %d/n",pst->sid,pst->name,pst->age);//不可以直接使用st 
  }

动态内存分配

 #include<stdio.h>
 #include<malloc.h> 
 #include<stdlib.h>
 //使用了malloc是动态，没有的全是静态
 int main(void)
 {
     int a[5]={1,10,2,8,6};
     int len;
     printf("请输入所需要的分配数组长度：len=");
     scanf("%d",&len);
     int*pArr=(int *) malloc (sizeof(int)*len);//请求操作系统分配(sizeof(int)*len)个空间
 //  //malloc只返回第一个字节地址，干地址，无实际意义
 //  //用(int *)强制类型转换来告诉我们，是什么类型地址
 //  *pArr=4;//类似于a[]=4;
 //  pArr[1]=10;//类似于a[1]=10;
 //  printf("%d %d",*pArr,pArr[1]);
 //  free(pArr);//pArr所代表的的动态分配的20个字节的内存释放
 ​
 //吧pArr当做普通数组
 for (int i=0;i<len;++i) 
 scanf ("%d",&pArr[i]);
 for (int i=0;i<len;++i)
 printf("%d/n",pArr[i]);
 ​
 ​
     return 0;
 ​
 }