C基础：指针高级

//

//  main.m

//  第三周第二天

//

//  Created by scjy on 15/10/27.

//  Copyright (c) 2015年第三周. All rights reserved.

//

#import <Foundation/Foundation.h>

//(宏定义，也叫预编译指令)

//# define Sub(X,Y) X-Y

//# define PI 3.14

//# define MUL(A,B) ((A)*(B))

//条件编译

//# ifdef PI

//#define PI 3.14

//#else

//#define PI 6.28

//#endif

//

//# ifndef PI

//#define PI 6.28

//#else

//#define PI 3.14

//#endif

#ifndef KB 1024

#define kb 1024

#else

#define kb 1000

#endif

// 使用指针计算字符串长度。提示：遇到‘\0’表示字符串结束；定义

//int length(char array[]){

//    int count= 0;

//    char *p = array;

//    while (*p != '\0') {

//        count++;

//        p++;

//    }

//    return count;

//}

//方法二(老师写的)

//int stringLength(char *p){

//    int length=0;

//    while (*p != '\0') {

//        length++;//字符串只要不是\0就加一

//        p++;//

//    }

//    return length;

//}

//int st(int *p){

//    int l=0;

//    while (*p!=0) {

//        l++;//自己试验

//    }

//    return l;}

//借用

//void swap(int *x,int *y){

//    int temp=*x;

//    *x=*y;

//    *y=temp;

//}

//int length(char array[]){

//    int i = 0;

//    char *w = array;

//    while (*w != '\0') {

//        i++;

//        w++;

//    }

//    return i;

//}

int main(int argc,const char * argv[]) {

    @autoreleasepool {

        // insert code here...

        NSLog(@"Hello, World!");

       // C语言第九讲指针高级

   

        //数组的内存地址在C语言中，数组是构造类型，系统会分配一段连续的内存空间，来存储数组的全部数据

        //  数组名代表数组首个元素的地址

        //  &array==&array[0];(恒等于)

        //   指针与数组的区别：所占空间不同（指针只与操作系统有关，数组与元素个数和类型有关）

        //  数组名可以是常量地址，不能被赋值(但数组元素可以被直接赋值)，不能重指向；指针可以重指向

        

        

//        int array[5]={0,1,2,3,4};

//        printf("&array=%p\n",array);

//        int *u=&array[0];

//        for (int i=0; i<5; i++) {

//            printf("%d  %p\n",*u,u);

//            u++;

//        }

//

        int array[5]={0,1,2,3,4};

        printf("&array=%p\n",array);

        for (int i=0; i<5; i++) {

            printf("array[%d]=%d\n",i,array[i]);

        }

        for (int i=0; i<5; i++) {

            printf("&array[%d]=%p\n",i+1,&array[i]);

        }

        int *y=array;

        printf("y=%p\n",y);

//        // 指针y与array相同，都指向数组第一个元素的内存地址

//        printf("*y=%d\n",*y);

//        printf("*(y+1)=%d\n",*(y+1));

//        printf("*(y+2)=%d\n",*(y+2));

//        printf("*(y+3)=%d\n",*(y+3));

//        printf("*(y+4)=%d\n",*(y+4));

//        printf("*(y)+1=%d\n",*(y)+1);

//        

//        *(y+2)=6;

//        printf("array[2]=%d\n",array[2]);

//        

        // （y+1）的内部实现是：y是数组元素的首地址，y+1*int（当前数组类型所占的字节数）

        //（y+1）= (y + 1 *当前数组类型所占的字节数）

        // *（y）+ 1

        

        /* 自己总结的定义： *（y+n），输出的是下标为n+1的值,（其实是地址的值）

        // *（y）+ n,输出的是y再加n;

        */

     

        

     //  指针可以当数组名使用

        

//        int array[5]={0,1,2,3,4};

//        int *y=array;

//

//        for (int i=0; i<5; i++) {

//            printf("y[%d]=%d\n",i,y[i]);

//        }

        

        //  下边四个结果都一样，都是数组的第二个元素

        // y[1] == array[1] == *(y+1) == *(array + 1)

        

//        int array1[5]={0};

        

//         array1[5]=array[5];

//         array1=array;

        //  数组不能被赋值(但数组元素可以被直接赋值)

        

//        int cou=0;

//        cou=sizeof(array)/sizeof(8);

//        printf("cou=%d\n",cou);

        

//        char arra[5]={'a','b'};

//        int co=0;

//        co=sizeof(arra)/sizeof(arra[0]);

//        printf("co=%d\n",co);

        

        

        

//        //指针变量的类型一定要和数组的类型相匹配

//        short a[4]={110,211,235,453};

//        short *o=a;

//        short *i=a;

//        short *u=a;

//        short *e=a;

//        printf("*o=%d\n",*o);

//        printf("*i=%d\n",*i);

//        printf("*u=%d\n",*u);

//        printf("*e=%d\n",*e);

        

        

       

        

        //指针与字符串；

//        char string[20]="lanoujiaoyu";

//        char *p=string;

//        for (int i=0; i<20; i++) {

//             printf("string[%d]=%p\n",i,&string[i]);

//        }

//

//       printf("string[0]=%p\n",&string[0]);

//        printf("string[1]=%p\n",&string[1]);

//        printf("string[2]=%p\n",&string[2]);

//        printf("string[3]=%p\n",&string[3]);

        

        

        //string是数组名，它存放这个数组第一个元素的地址

        

//        *(p+1)='v';

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

//        

//        printf("%s\n",p+1);// 从字符串中第二个元素开始输出字符串

//        

        //使用指针计算字符串长度。提示：遇到‘\0’表示字符串结束；

        

//        

//        int length(char array[]);

//        char array[]="iphone";

//        printf("%d\n",length(array));

        

        //方法二（老师写的）

//         char p1[20]="lanoujiaoyu";

//        unsigned long count = stringLength(p1);

//        printf("字符串长度为：%lu\n",count);

        

//        int a[]={11,1,123,564,5,456};

//        unsigned long count = st(a);//自己试验

//        printf("数组长度为：%lu\n",count);

//        

        

    //结构体指针：指向结构体变量的指针，就叫做结构体指针

//        

//        Student stu1 ={"lamborghini",21,'m',64};

        Student *p2 = &stu1;

//        printf("p2=%p\n",p2);

//        printf("&stu1=%p\n",&stu1);

//        printf("&stu1.name=%p\n",&stu1.name);

//        printf("&stu1.age=%p\n",&stu1.age);

//        printf("&stu1.gender=%p\n",&stu1.gender);

//        printf("&stu1,weight=%p\n",&stu1.weight);

        //结论：结构体指针变量指向的是结构体变量的首地址，其本质是结构体结构体第一个成员的地址

        //Student * 是结构体指针类型，  p2结构体指针变量，&stu1结构体变量地址

        

        //结构体指针访问成员

//        (*p2).age = 23;

//        (*p2).gender = 65;

//       

//        (*p2).weight = 100;

//        printf("age=%d\n",(*p2).age);

//        printf("gender=%d\n",(*p2).gender);

//       

//        printf("weight=%d\n",(*p2).weight);

//        

//        p2->age=27;

//        printf("%d %c %d\n",stu1.age,stu1.gender,stu1.weight);

        

//        typedef struct cpoint {

//            

//            float  x;

//            float  y;

//            

//        }CPoint;

//        float  n;

//        CPoint a={3,4};

//        CPoint b={0,0};

//        CPoint *p1=&a;

//        CPoint *p2=&b;

//        n=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));

//        printf("%f\n",n);

        

        

        

        //结构体数组的 数组名  是一个结构体指针 常量。

        // 结构体数组第二个元素（p3+1）=p3+1*一个结构体占用内存的大小

//        

//        Student stu[4]={

//            {"zhangpengfei",29,'m',65;},

//            {"zhaoyantao",28,'m',64;},

//            {"zhongchenyang",27,'m',63;},

//            {"qiaozipeng",26,'m',62;}

//        };

//        Student *p3 =stus;

//        printf("p3 %p=\n",p3);

//        printf("stus=%p\n",stus);

//        

        

        //假设圆的半径为5，求面积

//        int round = PI *5 *5;

//        printf("round=%d\n",round);

        

//        int round1 = PI *8 *8;

//        printf("round1=%d\n",round1);

//        

//        int round2 = PI *10 *10;

//        printf("round2=%d\n",round2);

        

//        

//        int j=5,k=7;

//        printf("5*7=%d\n",MUL(j,k));

//        printf("5-7=%d\n",SUB(5,7));

        

        

        

        

               

        

    }

    return 0;

}