Blocks in Objective-C

1. Standard Blocks:

Standard blocks are simple blocks that are declared using the ^ symbol. These blocks can be used to control the flow of execution, such as executing multiple pieces of code in sequence.

Syntax of Standard Block:

^(int a, int b) {
    int c = a + b;
    return c;
}

2. Typed Blocks:

Typed blocks are blocks with a specified return type and argument types. These blocks allow you to define behavior for specific types of data.

Syntax of Typed Block:

^int(int a, int b) {
    int c = a + b;
    return c;
}

3. Autoreleasing Blocks:

Autoreleasing blocks are blocks that are declared using the __autoreleasing keyword. These blocks are automatically released when they go out of scope, helping with memory management.

Syntax of Autoreleasing Block:

@autoreleasepool {
    ^int(int a) {
        int b = a + 1;
        return b;
    }
}

Example 1:

// Standard Block
int (^multiply)(int, int) = ^(int num1, int num2) {
    return num1 * num2;
};
int result = multiply(3, 5); // result is 15

// Typed Block
typedef int (^AdditionBlock)(int, int);
AdditionBlock add = ^(int num1, int num2) {
    return num1 + num2;
};
int sum = add(3, 5); // sum is 8

// Autoreleasing Block
@autoreleasepool {
    NSString *string = @"Hello, world!";
    void (^printString)(void) = ^{
        NSLog(@"%@", string);
    };
    printString();
}

Output:

Hello, world!

In this example:

• The multiply block is a standard block that takes two integer parameters and returns their product.
• The add block is a typed block that is declared using typedef and takes two integers as parameters and returns their sum.
• The printString block is an auto-releasing block, declared within an @autoreleasepool statement, that prints a string to the console.

Example 2:

#import <Foundation/Foundation.h>

// Block with no parameters and no return value
typedef void (^SimpleBlock)(void);

// Block with one parameter and no return value
typedef void (^ParameterBlock)(NSString *);

// Block with no parameters and a return value
typedef int (^ReturnBlock)(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // SimpleBlock implementation
        SimpleBlock simpleBlock = ^{
            NSLog(@"Welcome to the World of Blocks!");
        };
        simpleBlock(); // Output: "Welcome to the World of Blocks!"

        // ParameterBlock implementation
        ParameterBlock parameterBlock = ^(NSString *name) {
            NSLog(@"Hello, %@!", name);
        };
        parameterBlock(@"Alice"); // Output: "Hello, Alice!"

        // ReturnBlock implementation
        ReturnBlock returnBlock = ^{
            return 42;
        };
        int result = returnBlock();
        NSLog(@"The result is %d", result); // Output: "The result is 42"

        // Addition Block implementation
        int (^AdditionBlock)(int, int) = ^(int a, int b) {
            return a + b;
        };
        int sum = AdditionBlock(3, 5);
        NSLog(@"The addition of 3 and 5 is %d", sum); // Output: "The addition of 3 and 5 is 8"
    }
    return 0;
}

Output:

Welcome to the World of Blocks!
Hello, Alice!
The result is 42
The addition of 3 and 5 is 8

Explanation:

1. SimpleBlock: A block with no parameters and no return value that outputs a simple message.
2. ParameterBlock: A block that takes a string parameter and outputs a greeting message.
3. ReturnBlock: A block that returns an integer value.
4. AdditionBlock: A block that takes two integers as parameters, adds them together, and returns the sum.