Block

C的函数指针

typedef void (*pType)();  //将函数指针类型void (*)()  重命名为pType

void fun()
{
NSLog(@"fun");
}

void fun1()
{
NSLog(@"fun1");
}

//1. 在形参中声明函数指针变量
//2. 形参中的函数指针变量指向实参的函数名(间接指向)
//3. 函数指针变量调用函数 – 函数回调

void FunMain(pType p)
{
    p();  //函数回调， 传入哪个函数名，那么回调哪个函数
}

int main(int argc, const char * argv[]) {
@autoreleasepool {
    // insert code here...

    //fun();  //普通C函数调用

//函数指针的使用步骤：

    //1.声明函数指针变量；(声明要与要调用的函数的返回值及参数类型匹配)
    //2.函数指针变量指向函数名；
    //3.函数指针调用函数名

//函数指针的第一种调用方法：直接指向函数名

if 0
    void (*p)();
    p = fun;
    p();    //--调用fun函数
    p = fun1;
    p();    //--调用fun1函数
endif

//函数指针的第二种用法： 间接指向函数名(传参形式指向指向函数名)

    FunMain(fun);
    FunMain(fun1);

block的基本用法

//block的使用步骤：

    //1. 声明block变量；
    //2. block变量指向block块
    //3. block变量调用块中的内容

//block的第一种使用方式： block变量直接指向block块

    //a. 声明一个无参数无返回值的block变量
    void (^block)();  //声明无参无返回值的block变量

    block = ^{       //无参无返回值的block块: ^{}

        NSLog(@"222");
        NSLog(@"无参数无返回值的block");
    };

    NSLog(@"111");

    block();         //block调用无参数的块中的内容

    NSLog(@"333");



    //b.声明一个有参数无返回值的block变量
    void (^block1)(NSInteger a);  //声明有参的block

    block1 = ^(NSInteger a){  //有参的block块：^(参数){}
        NSLog(@"a= %ld",a);
    };

    block1(5);  //block调用有参数的块中的内容



    //c.声明一个有参数有返回值的block变量
    NSInteger (^block2)(NSInteger a);//声明有参有返回值的block

    NSInteger b = 4;
    __block NSInteger c = 6;  //加入__block，在block块中c变成可读可写

    block2 = ^NSInteger(NSInteger a){ //有参有返回值的block块：^类型(参数){}

        //b = 5;   err 外部的变量，可读不可写
        c  = 7;    //__block修饰后，可读可写
        NSLog(@"有参有返回值 a = %ld",a+b);  //在块中可使用外部的变量
        return 1;
    };
    NSLog(@"返回值：%ld",block2(3));

block test

//1.声明一个有参数有返回值的block

    NSString * (^block)(NSString *str);

//2.block变量指向block块

    block = ^NSString *(NSString *str){

        NSMutableString *mutStr = [[NSMutableString alloc] init];
        NSInteger len = [str length];  //获取传入字符串长度
        for(NSInteger i=len-1;i>=0;i--)
        {
            //根据下标获取字符串的每个字符，存储到可变字符串中
            [mutStr appendFormat:@"%c",[str characterAtIndex:i]];
        }
        return mutStr;
    };

//3.block调用block块内容

    NSLog(@"逆序后：%@",block(@"hello"));

block作为函数参数使用

    //需求： 打印每个人的说话；
    //A说：  ABC
    //B人说： BCA
    //C说：CAB

/*   弊端： 类中方法太多
    Person *baoA = [[Person alloc] init];
    baoA.name  = @"A";
    [baoA baoAnSay];  //A说：

    Person *gongR = [[Person alloc] init];
    gongR.name = @"B";
    [gongR gongRenSay];  //B说：

    Person *yuan = [[Person alloc] init];
    yuan.name = @"C";
    [yuan yuanSay];      //C说：
 */

    //block的第二种用法： block间接指向block块 (重点) (以参数形式使用block)

    Person *baoA = [[Person alloc] init];
    baoA.name  = @"baoAn";
    [baoA allSay:^(NSString *name) {
        NSLog(@"%@说：一个月挣800多",name);
    }];

    Person *gongR = [[Person alloc] init];
    gongR.name  = @"gongRen";
    [gongR allSay:^(NSString *name) {
        NSLog(@"%@说：ABC",name);
    }];

    Person *yuan = [[Person alloc] init];
    yuan.name  = @"BCA";
    [yuan allSay:^(NSString *name) {
        NSLog(@"%@说：CAB",name);
    }];


    //Block作用： 统一接口的调用、方便界面间的传值

    _int32er_ a = 5; //typedef中int重命名的类型 _int32er_
    NSLog(@"a = %d",a);

//void (^)(NSString *))－>block的类型

//1. 声明block变量： void (^block)(NSString * name)
//2. 形参的block变量，指向实参的block： block－> ^(NSString *name){}

-(void)allSay:(blockType)block
{
block(_name);  //3.block回调－>通过block变量调实参块中的内容
}

使用block完成数组排序

//#import <Foundation/Foundation.h>


void sortLength(NSMutableArray * mutArr)
{
NSInteger count = [mutArr count];

//冒泡排序法： 总共比较count－1次
for(NSInteger i=0;i<count-1;i++)
{
    //每次循环count-i-1
    for(NSInteger j=0;j<count-i-1;j++)
    {
        //每次两两相比较,最大的数放右边
        if([mutArr[j] length]>[mutArr[j+1] length])
        {
            //交换相邻两数
            [mutArr exchangeObjectAtIndex:j withObjectAtIndex:j+1];
        }
    }
}
}

void  sortAscii(NSMutableArray *mutArr)
{
NSInteger count = [mutArr count];

//冒泡排序法： 总共比较count－1次
for(NSInteger i=0;i<count-1;i++)
{
    //每次循环count-i-1
    for(NSInteger j=0;j<count-i-1;j++)
    {
        //每次两两相比较,最大的数放右边
        if(NSOrderedDescending == [mutArr[j] compare:mutArr[j+1]])
        {
            //交换相邻两数
            [mutArr exchangeObjectAtIndex:j withObjectAtIndex:j+1];
        }
    }
}
}

//使用block的步骤：
//1.声明block变量
//2.block变量指向实参的block块
void sortForBlock(NSMutableArray *mutArr,NSInteger (^block)(NSString *obj1,NSString *obj2))
{
NSInteger count = [mutArr count];

//冒泡排序法： 总共比较count－1次
for(NSInteger i=0;i<count-1;i++)
{
    //每次循环count-i-1
    for(NSInteger j=0;j<count-i-1;j++)
    {
        //每次两两相比较,最大的数放右边
        if(block(mutArr[j],mutArr[j+1]))  //通过block回调，将两个字符串传出；自定义做判断
        {
            //交换相邻两数
            [mutArr exchangeObjectAtIndex:j withObjectAtIndex:j+1];
        }
    }
}
}

int main(int argc, const char * argv[]) {
@autoreleasepool {
    // insert code here...

    NSMutableArray *mutArr = [[NSMutableArray alloc] initWithObjects:@"11111",@"2222",@"33",@"4",@"555555",@"666", nil];

方法1.直接通过冒泡排序可求出，但是冗余太多

    sortLength(mutArr);  //按照字符串长度排序

    NSLog(@"字符串长度排序：%@",mutArr);

    sortAscii(mutArr);    //按ascii码排序

    NSLog(@"ascii排序：%@",mutArr);

方法2: 通过自定义block来完成排序

    sortForBlock(mutArr, ^NSInteger(NSString *obj1, NSString *obj2) {
        //block块的内容中，实现比较的判断
        //按照字符串转整数值判断
        if([obj1 intValue] > [obj2 intValue])
        {
            return 1;
        }
        return 0;
    });
    NSLog(@"按整数值排序：%@",mutArr);

    //通过自定义block来完成排序
    sortForBlock(mutArr, ^NSInteger(NSString *obj1, NSString *obj2) {
        //block块的内容中，实现比较的判断
        //按照字符串的ascii来判断
        if(NSOrderedDescending == [obj1 compare:obj2])
        {
            return 1;
        }
        return 0;
    });
    NSLog(@"按字符串的ascii排序：%@",mutArr);

//方法3：系统提供的排序方法

    [mutArr sortUsingComparator:^NSComparisonResult(id obj1, id obj2) {
        //按照长度排序：
        if([obj1 length]>[obj2 length])
        {
            return NSOrderedDescending;
        }
        return NSOrderedSame;
    }];
    NSLog(@"按长度排序：%@",mutArr);
}
return 0;
}