[iOS]Block series exploration – a preliminary study

OC blocks and Java lambdas have been confused, deliberately studied OC blocks. If there is any misunderstanding or not in place, welcome to correct. In this article, we’ll take a look at the general flow of a Block from declaration to invocation.

preface

In development, we generally declare variables in the following form:

NSInteger number;
UIView *view;
Copy the code

But the Block declaration for egg pain is:

void (^block)(int number);
Copy the code

Why not this form:

void(^) (int number) block;
Copy the code

With doubt, we looked down.

C language function pointer

First, I want to show you a piece of code:

int main(int argc, char * argv[]) {
    FuncPtr is a pointer variable
    int (*funcPtr)(int count);
    // The pointer variable points to the address of the function
    funcPtr = &func;
    int count = 10;
    // Call the method
    (*funcPtr)(count);
}

// Function implementation
int func(int count) {
    int result = count++;
    NSLog(@"Count = %d, address :%p", count, &count);
    printf("result = %d\n", result);
    return result;
}
Copy the code

FuncPtr in the code above is not a function name, but a pointer variable that points to the address of the func function.

Let’s look at the declaration and implementation of blocks:

- (void)block {
    / / statement block
    void (^block)(int count);
    int count = 10;
    // The implementation of block
    block = ^void (int count) {
        count++;
        NSLog(@"count = %d, address :%p", count, &count);
    };
    // Block calls
    block(count);
    NSLog(@"count = %d, address :%p", count, &count);
}
Copy the code

We can see that the declaration of a function pointer is similar to that of a Block. There are only two differences:

• Block has no function name
• Block with “^”(insert token) : Since macOS and iOS APP source code use blocks extensively, insert token is easy to find so we can guess that the underlying implementation of Block is probably C function pointer?

The underlying implementation of the Block declaration

Could the underlying implementation of a block be a function pointer in C? So let’s verify that. First we create a new macOS command-line project, and then declare and call a block in the main.m function as follows:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        / / statement block
        void (^block)(int count);
        int count = 10;
        // The implementation of block
        block = ^void (int count) {
            count++;
            NSLog(@"count = %d, address :%p", count, &count);
        };
        // Block calls
        block(count);
        NSLog(@"count = %d, address :%p", count, &count);
    }
    return 0;
}
Copy the code

Use clang(LLVM compiler) to convert OC code to C/C++ code:

clang -rewrite-objc main.m
Copy the code

The main. CPP file will be created in the main.m folder. At the bottom of the file, we find the code we need:

// __block_imp structure
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

// the __main_block_desc_0 structure
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0.sizeof(struct __main_block_impl_0)};

// the __main_block_impl_0 structure
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; }};/ / __main_block_func_0 function
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int count) {

            count++;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_3c0991_mi_0, count, &count);
}

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        void (*block)(int count);
        int count = 10;
        
        // The implementation of block
        block = ((void(*) (int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        
        // Block calls
        ((void (*)(__block_impl *, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, count);
        
        / / print the count
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_3c0991_mi_1, count, &count);
    }
    return 0;
}
Copy the code

Next, we’ll examine the individual constructs in the code above.

2.1 __block_impl structure

// __block_imp structure
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
Copy the code

__block_IMP can be understood as the structure of a block class object. I will describe each member of this structure. The ISA pointer indicates that a block is instantiated by _NSConcreteStackBlock, _NSConcreteGlobalBlock, or _NSConcreteMallocBlock. So, block objects have these three base classes. I’ll elaborate on these three base classes in a future article, so stay tuned. Flags Identifier. Default is 0. Reserved indicates the Reserved field. FuncPtr pointer variable, which is a function pointer to the code __main_block_func_0 function that implements the customization within the block closure.

2.2 __main_block_desc_0 structure

// the __main_block_desc_0 structure
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0.sizeof(struct __main_block_impl_0)};
Copy the code

Reserved indicates a reserved field, which is not used at present and may be used in the future. Block_size indicates how much space the structure occupies.

2.3 __main_block_IMPL_0 structure

// the __main_block_impl_0 structure
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) { impl.isa = &_NSConcreteStackBlock; impl.Flags = flags; impl.FuncPtr = fp; Desc = desc; }};Copy the code

The __main_block_IMPL_0 structure has two members, which are Pointers to the __block_impl structure and the __main_block_DESc_0 structure. Let’s look at the __main_block_IMPL_0 constructor:

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0)
Copy the code

We can see that we need to pass a pointer to FP, which is a function pointer assigned to the FuncPtr variable of the IMPL member, and the DESC structure. Fp points to the __main_block_func_0 function.

2.4 __main_block_func_0 function

/ / __main_block_func_0 function
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int count) {

            count++;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_3c0991_mi_0, count, &count);
}
Copy the code

The __main_block_func_0 function is code that the user writes inside a block closure.

---

The above sections are the declaration and implementation of blocks into C/C ++ language. Let’s look at the block call inside main().

The bottom layer of Block calls

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        void (*block)(int count);
        int count = 10;
        
        // Block assignment
        block = ((void(*) (int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        
        // Block calls
        ((void (*)(__block_impl *, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, count);
        
        / / print the count
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_0r_hkkmpct143n4wd3xxk0l1j8c0000gn_T_main_3c0991_mi_1, count, &count);
    }
    return 0;
}
Copy the code

Let’s focus on the main() function above.

3.1 Block assignment

// Block assignment
block = ((void(*) (int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
Copy the code

((void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)); This code is the creation of a __main_block_IMPL_0 structure, passing in __main_block_func_0 and __main_block_desc_0_DATA. Void (^block)(int count); void (^block)(int count); . This is where function Pointers come in.

3.2 Invocation of Block

// Block calls
((void (*)(__block_impl *, int))((__block_impl *)block)->FuncPtr)((__block_impl *)block, count);
Copy the code

The FuncPtr function __main_block_func_0 calls the block function of type __block_impl *. The __main_block_func_0 function requires passing blocks of type __block_impl * and void (^block)(int count); In the count.

That’s the block inside main().

Iv. Comb the process

Let’s take a look at the flow of a block from declaration to invocation. To summarize, a block is just a pointer to a C function, with some extra structure for OC objects. The overall process is as follows:

• Step1: declare a function pointervoid (*block)(int count);
• Step2: create__main_block_impl_0Structure, FuncPtr refers to__main_block_func_0Function, the block pointer variable in step1 points to__main_block_impl_0The address of the
• Step3: Call block(that is__main_block_impl_0FuncPtr(i.e__main_block_func_0) function.

Compare the above three steps to the C function pointer in Chapter 1:

FuncPtr is a pointer variable
int (*funcPtr)(int count);
// The pointer variable points to the address of the function
funcPtr = &func;
int count = 10;
// Call the method
(*funcPtr)(count);
Copy the code

This makes the flow of a block from declaration to invocation clear. So blocks are ostensibly anonymous functions, but underneath they declare a function __main_block_func_0, which has a function name.