cs107_sf_note_02

1. 先来段对数组的

   #include<stdio.h>
   
   typedef struct fraction{
     int mum;
     int demum;
   }fr;
    
   int main()
   {
     fr pi;
     pi.mum=22;
     pi.demum=7;
     printf("%d\n",pi.mum);
     printf("%d\n",pi.demum);
     ((fr *)&(pi.demum))->mum=12;
     ((fr *)&(pi.demum))->demum=33;
     printf("%d\n",((fr *)&(pi.demum))->mum);
     printf("%d\n",((fr *)&(pi.demum))->demum);
     
     return 0;
   }

   其实和第一个笔记差不多，就是通过对arrary首地址取址，强行让其解释为（array *）型这样再用数组的对内赋值->来对越界的内存进行操作，还是很好理解的

2. 再对int arrary乱来点

   #include<stdio.h> 
   int main()
   {
       int arr[10];
       arr[0]=44;
       arr[9]=100;
       arr[10]=4; //越界操作，C中不管
       arr[25]=22;
       arr[-7]=77; 
   }

    这个其实没什么意思，就是告诉你，只要我得到一个数组首地址，可以通过arr[k]=*(arr+k)操作任何内存

   #include<stdio.h> 
   int main()
   {
       int arr[5];
       arr[3]=128;
       ((short *)arr)[7]=2;
       printf("%d\n",arr[3]);
       return 0; 
        
   }

    这个就数组和强换指针结合下，本来在arr[3]中存放 8*0 8*0 8*0 10000000 ，然后用short*找到了第二个8*0的位置，复制00000000 00000010 那么再组合取值就是00000000 00000010 10000000 00000000，即2^17+2^7。

3. 下面就好玩了，其实就是组合，要会画内存逻辑图，然而我太懒了，不想传上来。

   #include<stdio.h> 
   
   typedef struct student{
       char *name;
       char sud[8];
       int num;
   }st;
   //地址按照顺序 name上面是sud，上面是num堆起来的
    
   int main()
   {
       st pupils[4];
       //按整个struct 构造内存 连续4个
       pupils[0].num=21;
       pupils[2].name=strdap("Adam");
       //strdap 是在Heap中的内存，返回address of 'A' 
        pupils[3].name=pupils[0].sud+6;
        //就是pupil数组中第一个struct 中的sud数组首地址+6
        strcpy(pupils[1].sud,"40415XX");
        //和strdap差不多，不过不是动态分配的
       strcpy(pupils[3].name,"123456");
       //已经超了pupils[0]中sud数组的界限了,到了num中去了
       pupils[7].sud[11]='A';
       //这个就没意思了，纯告诉你可以瞎搞 
       return 0;      
   }

    理清楚这些应该对画内存逻辑图就OK了，下面指针间相互操作才是有意思的