函数指针、回调 、堆内存管理、日期和时间

函数指针

1.函数名是函数第一条语句的（常量）地址

2.函数指针（变量）中保存的是函数名

3.可以用函数指针直接调用其所指向的函数

void fa(){ //fa是个地址，是函数fa第一条语句的地址

    NSLog(@"in function fa");
}

void invoke(void(*f)()){       //可以实现在抽象层面上的编程

    //........ 
    f();                 //回调
    //.........
}


void fc(int x){

    NSLog(@"in fc x=%d",x);
}


double fd(int x,double y)
{
    return x+y;
}


double fe(int x,double y)
{
    return x*y;
}


void invoke1(double(*f)(int,double)){

    NSLog(@"%lg",f(10,3.14));
}

void invoke2(double(*f)(int,double),int a,double b){          //带参回调
    NSLog(@"%lg",f(a,b));
}


int main()
{
    @autoreleasepool {
        NSLog(@"%p",fa);        //输出函数fa()地址
        void(*pf)();           //函数指针的定义，其数据类型是void(*)(),即pf指向没有返回值也没有形参的地址
        pf=fa;
        fa();                      //标准函数调用方法
        pf();                      //使用指针调用函数
        invoke(fa);
        void(*pfc)(int );
        pfc=fc;
        int a=10;
        pfc(a);
        double(*pfd)(int,double);
        pfd=fd;
        NSLog(@"%lg",pfd(10,3.14));
        NSLog(@"----------------------");
        invoke1(fd);                               //传进invoke1的是处理数据的方法
        invoke1(fe);
        int x=10;
        double y=4.2;
        invoke2(fe,x,y);                       //x*y
        invoke2(fd, x, y);                     //x+y
    }
    return 0;
}    

堆内存管理

1.malloc：向堆空间申请变量或数组

2.free：将申请的变量或数组还给堆

#define SIZE 5
typedef struct{

    char name[100];
    BOOL gender;
    int age;
}Student;

int main()
{
    @autoreleasepool {
        int a=10;
        int *p=&a;
        NSLog(@"%d",*p);
        p=(int*)malloc(sizeof(int)); //malloc函数向堆上申请一个整形变量。（堆上的变量没有名字，只有地址）
        *p=20;
        NSLog(@"%d",*p);
        free(p);                        //将申请的变量还回给堆，不会造成内存泄漏。

        float* pf;
        double* pd;
        char* pch;
        pf=(float*)malloc(sizeof(float));
        pd=(double*)malloc(sizeof(double));
        pch=(char*)malloc(sizeof(char));
        *pf=3.14;
        *pd=4.11;
        *pch='a';
        NSLog(@"%g,%lg,%c",*pf,*pd,*pch);
        free(pf);
        free(pd);
        free(pch);

        Student *pStu;
        pStu=(Student*)malloc(sizeof(Student));
        strcpy(pStu->name, "张三");
        pStu->gender=YES;
        pStu->age=18;
        printf("%s,%s,%d\n",pStu->name,pStu->gender?"男":"女",pStu->age);
        free(pStu);

        p=(int *)malloc(sizeof(int)*SIZE);       //malloc向堆上申请了一个有5个元素的整形数组
        p[0]=10; //*(p+0)=10;
        p[1]=2; //*(p+1)=20;
        for(int i=0;i<SIZE;i++)
        {
            p[i]=(i+1)*10;
        }
        for(int i=0;i<SIZE;i++){
            printf("%d ",p[i]);
        }
        printf("\n");
        free(p);
        pStu=(Student*)malloc(sizeof(Student)*3);       //申请了3个元素的结构体数组
        ; //.......
        free(pStu);

        char *str =(char*)malloc(sizeof(char)*100);     //字符串
        scanf("%s",str); 
        printf("%s\n",str);
        free(str);




    }
    return 0;
}

3.calloc：向堆空间申请变量并清零，效率低，用得少。

4.realloc: 将申请的空间扩容

int main()
{
    @autoreleasepool {
        int *p=(int*)malloc(sizeof(int)*5);
        for(int i=0;i<5;i++){
            p[i]=(i+1)*10;

        }
        p=(int*)realloc(p, sizeof(int)*10);     //扩容到10，原数据不会丢失
        for(int i=5;i<10;i++){
            p[i]=i;
        }
        for(int i=0;i<10;i++){
            printf("%d ",p[i]);
        }
        printf("\n");
    }
    return 0;
}

日期和时间

int main()
{
    @autoreleasepool {
        clock_t t=clock();
        NSLog(@"%lu",t);

        clock_t begin=clock();  //设置起点
        for(int i=0;i<210000000;i++)
        {;}
        clock_t end=clock();    //设置终点
        NSLog(@"%lg",(end-begin)*1.0/CLOCKS_PER_SEC);   //查看循环所用时间

        time_t t1;
        time(&t1); //获取当前日历时间
        NSLog(@"%s",ctime(&t1));
    }
    return 0;
}