C 【block类型全方位详解】

———————————————————————————————————————————

block变量的概念



#import <Foundation/Foundation.h>



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

    @autoreleasepool {

//        block 是一个数据类型

//        block 和函数非常相似

//        函数不能在另一个函数的内部嵌套，但是block因为不是函数所以说可以在main里面写



//        *****************************************************************************************

        

//        无参的block变量定义

//        书写格式：    返回值类型 (^block变量名) (参数) =^{  代码块;  };

//        调用格式：    block变量名();

//        意义：在需要的地方调用

       

        void (^myBlock1)() = ^{

            NSLog(@"1234");

        };

        

        myBlock1();



        void (^blocklalala)(void)=^(void){

            NSLog(@"lalala");

        };

        

        blocklalala();

        

//        *****************************************************************************************

        

//        有参的block变量定义

//        书写格式：    返回值类型 (^block变量名) (参数类型列表) =^(形参列表){    代码块;   };

//        调用格式：    block变量名(实参列表);

        void (^eat)(int ,int )=^(int x,int y){ //a,b表示这个block变量有两个参数，且都是int类型的。而后面的x,y就是类似于函数的形参了

            NSLog(@"x+y=%d",x+y);

        };

        

        eat(10,10);

        

        void (^wangzhongyao)(int ,int )=^(int a,int b){

            NSLog(@"a+b=%d",a+b);

        };

        

        wangzhongyao(10,14);

        wangzhongyao(1,2);

        

//        *****************************************************************************************

        

//        带有参数和返回值的block变量定义

        int (^blockSum)(int ,int ,int )=^(int a,int b,int c){

            return a+b+c;

        };

        NSLog(@"blockSum=%d",blockSum(1,2,3));



//        *****************************************************************************************

        

//        注意：block变量的返回值可以是其他的block类型

        

    }

    return 0;

}





———————————————————————————————————————————

block的typedef用法



事实上，typedef是为block起了一个别名。这和函数指针比较的相似。



注：指针和函数

 

   1）指针函数   （返回值是指针的函数）

   2）函数指针   （指向函数的指针）





#import <Foundation/Foundation.h>



int sum(int x,int y)

{

    return x+y;

}



void test1()

{//函数指针的回顾

    int s=sum(5, 10);

    NSLog(@"s=%d",s);

    

    //        定义指向函数的指针

    int (*p)(int x,int y);

    p=sum;

    s=p(3,5);

    NSLog(@"s=%d",s);

    

    //        给函数指针起个别名

    typedef int (*newType)(int x,int y);//newType 就是一个新类型，而不是函数名

    newType p2=sum;//用新的函数指针类型定义一个新的函数指针变量p2，然后用p2指向sum

    

    s=p2(1,2);

    NSLog(@"s=%d",s);

    

}



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

    @autoreleasepool {

//********************************给无参无返回值的block变量重命名**************************************

        

//        先建立一个无参无返回值的block

        void (^myBlock)()=^{

            NSLog(@"这是原来的block!");

        };

        myBlock();

        

//        给无参无返回值的block类型起一个别名

        typedef void (^newMyBlock)();

//        注意：和指针函数差不多，这里的newMyBlock是一个 新的类型，而不再是block类型的变量名了

        newMyBlock f1;//定义一个 无参无返回值的变量f1

        f1=^{

            NSLog(@"这是通过typedef创建的新类型所定义的block");

        };

        f1();

        

//********************************给有参有返回值的block变量重命名**************************************

        

//        先建立一个有参有返回值的block

        int (^sumBlock)(int ,int ,int )=^(int x,int y,int z){

            return x+y+z;

        };

        int sum1=sumBlock(1,2,4);

        NSLog(@"sum1=%d",sum1);

        

//        给有参有返回值的block起一个别名

        typedef int (^newTypeForSum)(int ,int ,int );//这里实际上是定义了一个新的类型，而这个新的类型的类型名是newTypeForSum，这个新的类型是一个 返回值是int类型并且有三个int类型的参数的block类型。

        

        newTypeForSum f2;//用新的block类型声明了一个变量f2

        f2=^(int x,int y,int z){

            return x*y*z;//显然这里可以是对三个参数的任何操作。

        };

        

        int s3=f2(3,5,2);

        NSLog(@"s3=%d",s3);

        

        

//        再写一个block类型，显然我们根本不用先写一个block变量然后再起别名（下面三行代码可以不要），我们可以直接用typedef去写一个新的block类型

//        int (^sumBlock1)(int ,int )=^(int x,int y){

//            return x+y;

//        };

        

        typedef int (^newType1)(int ,int);//直接写了一个返回值是int类型且有两个int类型的参数的新的block类型

        newType1 f3;

        f3=^(int a,int b){

            return a*b;//在新block类型变量内部定义方法

        };

        int ss=f3(12,12);

        NSLog(@"ss=%d",ss);

    }

    return 0;

}





———————————————————————————————————————————

block访问外部变量



/*

 局部变量： 在函数的内部或者代码块的内部定义的变量，都是局部变量

 （局部变量存在于内存的栈区）

 

 全局变量： 在函数的外部定义的变量

 

 注意：如果在函数内部定义和全局变量同名的变量，此时在函数内部，局部变量会暂时屏蔽全局变量的作用域

 */



代码：



#import <Foundation/Foundation.h>



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

    @autoreleasepool {

        int m=100;

        __block int m2=111;

        

        void (^myBlock1)(void)=^(void){

//            首先，在block变量的内部可以直接访问其外部的变量

            

//            int m=200;

//            其次，如果在block内部定义了与外部同名的变量，那么就会覆盖外部的变量

            

//            m=300;

//            我们无法直接修改外部的变量，上面一条语句是错误的

            

            m2=222;

//            如果一定要在block变量的内部修改外部的变量值，那么要将外部定义的变量设置为__block类型（注意有两个下划线）

            NSLog(@"这是在block变量的内部   m=%d,m2=%d",m,m2);

        };

        myBlock1();

    }

    return 0;

}





———————————————————————————————————————————

block应用（1）



日程表，大多数日程计划一致，只有少数不一致时应该怎么使用block



代码：



//用block变量作为函数的参数（可以做到重复输出的时候用block变量只更改需要更改的部分）

#import <Foundation/Foundation.h>

void daysDoThings(void (^dayBlock)())//将 一个无返回值、参数为一个 无返回值无参的block类型 的变量 传进去，这个地方定义传进来的block变量的类型名的时候可以随意

{

    printf("---------------\n");

    printf("起床");

    printf("刷牙");

    

    dayBlock();

 

    printf("吃饭");

    printf("睡觉");

    printf("\n");

}



void daysDoThings222(int n)

{

    typedef void (^newDaysBlock)();//定义一个block变量的新类型

    

    newDaysBlock work;//创建一个newDaysBlock类型的block变量work

    switch (n) {

        case 1:

            work=^{

                printf("Day1");

            };

            break;

            

        case 2:

            work=^{

                printf("Day2");

            };

            break;

            

        case 3:

            work=^{

                printf("Day3");

            };

            break;

            

        case 4:

            work=^{

                printf("Day4");

            };

            break;

            

        default:

            break;

    }

    daysDoThings(work);

}



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

    @autoreleasepool {

        

//        方法①，我们要先创建好这些block类型的变量，然后传入函数进行调用

//        void (^dayBlock1)()=^{

//            printf("1");

//        };

//        daysDoThings(dayBlock1);

//        

//        void (^dayBlock2)()=^{

//            printf("2");

//        };

//        daysDoThings(dayBlock2);

//        

//        void (^dayBlock3)();

//        dayBlock3=^{

//            printf("3");

//        };

//        daysDoThings(dayBlock3);

        

        

//        方法②，我们可以直接在调用函数的同时传block变量

//        

//        daysDoThings(^{

//            printf("5");

//        });

        

//        我们可以这样用是因为我们知道，一个block变量是这样定义的：

//        void (^myBlock)();

//        myBlock=^{ ...  };

//        所以可以将block变量的定义部分传进函数里去

        

//        方法③

        daysDoThings222(1);

        daysDoThings222(2);

        daysDoThings222(3);

        daysDoThings222(4);

    }

    return 0;

}





★附加：用block作为函数的返回值学习完成之后，可以改上面的代码，我现在将改好的代码写在下面，读者学习完毕后可以回来看看。



代码：



#import <Foundation/Foundation.h>

typedef void (^newBlockForDays)();



void days(int day)//记住，block类型的变量名要括号括起来，并且定义block类型的变量的时候要加^

{

    newBlockForDays setDays(int i);

    //引入setDays方法，不然没法用（函数声明部分）

    

    printf("****");

    

    //创建一个newBlockForDays的变量day1去接收setDays方法的返回值

    newBlockForDays day1;

    day1=setDays(day);

    

    //day1接收完值后就是一个具备返回值功能的block变量，所以可以直接调用这个block变量

    day1();

    printf("**********\n");

}



newBlockForDays setDays(int i)

//将这个方法改为返回值为block类型变量的方法

{

    

    newBlockForDays workDay;

    switch (i) {

        case 1:

            workDay=^{

                printf("Day11111");

            };

            break;//如果这里不写break，那么默认向下执行，那么workDay的值会一直改变，直到遇到break跳出程序，才终止了对workDay的赋值

        case 2:

            workDay=^{

                printf("Day22222");

            };

            break;

        case 3:

            workDay=^{

                printf("Day33333");

            };

            break;

        case 4:

            workDay=^{

               printf("Day44444");

            };

            break;

        case 5:

            workDay=^{

                printf("Day55555");

            };

            break;

            

        default:

            break;

    }

    return workDay;

}







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

    @autoreleasepool {

        days(1);

        days(2);

        days(3);

        days(4);

        days(5);

    }

    return 0;

}







———————————————————————————————————————————

block作为函数的返回值



代码：



#import <Foundation/Foundation.h>



//创建一个新的block类型（返回值为int类型，并且含有两个参数）

typedef int (^newBlock1)(int ,int );



//创建一个返回值为newBlock1类型的函数test1  (test函数本身是没有参数的)

newBlock1 test1()

{

    //返回值为newBlock1类型，那么自然要先创建一个newBlock1类型的变量用来返回

    newBlock1 nb;

    

    //自然变量nb也应该拥有两个int类型的形参

    nb=^(int x,int y){

        return x>y?x:y;

    };

    //注意这里返回的是newBlock1类型的变量

    return nb;

}



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

    @autoreleasepool {

        newBlock1 n1;

       n1=test1();//test1就是返回一个可以判断两个数的较大数的block变量，然后将这个具有这个功能的block变量给n1，这样n1就具备接收参数并判断大小的能力了（可以说每次调用无参函数test1，就生成一个具备相应功能的block类型的变量）   

     

//        这样我们再输出n1(12,11) 此时的n1是接收了参数的n1，返回值为int类型

        NSLog(@"n1->max=%d",n1(12,11));



    }

    return 0;

}





//★上面的程序大家可能不是很理解，我觉得不理解的地方应该是不理解怎么调用的。我着重解释一下：

//首先test1函数是一个返回值为newBlock1类型的无参函数，一定注意test1返回的是一个block类型的变量，而返回的这个block类型的变量是具备以下功能的————接收两个数字并判断两个数字大小，最后返回较大值。

//接着在main函数中先创建一个newBlock1类型的变量n1去接受test1的返回值，这样n1就是一个具备上述功能的block类型的变量了。所以说我们可以给n1传值并输出n1的返回值







////       对于上面的程序，我们只是为了让block作为函数的返回值而写的，其实完全没有必要这样做，这样做显得非常的麻烦。我们可以直接这么写:



//#import <Foundation/Foundation.h>

//

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

//    @autoreleasepool {



//        typedef int (^newBlock2)(int x,int y);

//        newBlock2 n2;

//        n2=^(int x,int y){

//            return x>y?x:y;

//        };

//        NSLog(@"n2->max=%d",n2(12,13));

//    }

//}





———————————————————————————————————————————

block的使用技巧及其注意事项



//block和函数的区别：

//①定义方式不一样

//②block是类型，函数就是函数

//③函数不能嵌套定义，block可以嵌套定义

//④block是一中数据类型，所以可以做函数的参数和返回值。函数则不可以（函数不可以做另外函数的参数，也不可以做另外函数的返回值）



#import <Foundation/Foundation.h>



void test(int (^block1)(int num1,int num2))//这里加num1 num2更好，因为这样调用test的时候提示更多

{

    

}



int main()

{

    @autoreleasepool {

        test(//test

             ^int(int num1, int num2) {//注意这里的形式，多了一个int，注意注意注意！！！

                 

                 void (^myblock)()=^{// 随意嵌套定义的block变量

                     NSLog(@"QQQQQ");

                 };

                 myblock();

                 

                 return num1+num2;

             }

             );//test

    }

    return 0;

}





———————————————————————————————————————————

版权声明：本文为博主原创文章，未经博主允许不得转载。