Blog

Numbers in detail

In Objective-C, numbers are treated as objects instead of primitive data types like in other programming languages. This allows for a greater range of values and offers various methods to work with numbers through the NSNumber class. These methods make number handling in Objective-C more flexible and powerful.

Instead of using primitive data types such as int, float, and double, Objective-C allows these types to be encapsulated as objects, providing additional functionality. Using NSNumber, you can perform a variety of mathematical operations and store numbers as objects, which can then be manipulated and returned using specific methods.

Example 1: Addition of Two Numbers

In this example, we create an NSNumber object for each number and then add them together. The result is also stored as an NSNumber object.

#import <Foundation/Foundation.h>

@interface MathOperations:NSObject
- (NSNumber *)addNumber:(NSNumber *)a withNumber:(NSNumber *)b;
@end

@implementation MathOperations

- (NSNumber *)addNumber:(NSNumber *)a withNumber:(NSNumber *)b {
   float num1 = [a floatValue];  // Extract the first number as a float
   float num2 = [b floatValue];  // Extract the second number as a float
   float sum = num1 + num2;     // Calculate the sum
   NSNumber *result = [NSNumber numberWithFloat:sum];  // Store the sum in an NSNumber
   return result;  // Return the result
}

@end

int main() {
   @autoreleasepool {
       MathOperations *operations = [[MathOperations alloc] init];
       NSNumber *num1 = [NSNumber numberWithFloat:15.5];  // First number
       NSNumber *num2 = [NSNumber numberWithFloat:9.0];   // Second number
       NSNumber *sum = [operations addNumber:num1 withNumber:num2];  // Add the numbers
       NSString *sumString = [sum stringValue];  // Convert the result to a string for display
       NSLog(@"The sum is %@", sumString);  // Output the result
   }
   return 0;
}

Components of a For Loop:

1. Initialization: Used to initialize counters or iterators (e.g., int counter = 1;).
2. Condition: Determines how long the loop will run (e.g., counter <= 10;).
3. Updation: Updates the counter or iterator after each iteration (e.g., counter++;).

Examples:

The sum is 24.5

Methods for Working with Numbers in Objective-C

The NSNumber class provides several methods that make working with numbers easier. These include:

• (BOOL)boolValue: Converts the NSNumber to a boolean.
• (float)floatValue: Converts the NSNumber to a float.
• (NSString *)stringValue: Converts the NSNumber to a NSString.
• (int)intValue: Converts the NSNumber to an int.
• (NSNumber *)numberWithFloat:(float)value: Creates an NSNumber object with a float value.

Objective-C also includes several mathematical functions, such as:

• CEIL(): Returns the smallest integer greater than or equal to the given number.
• COS(): Returns the cosine of a given number.
• FLOOR(): Returns the largest integer less than or equal to the given number.
• MOD(): Returns the remainder of dividing two numbers.
• RAND(): Generates a random number.

Example 2: Subtracting Two Numbers

In this example, we will subtract two numbers, 100 and 40, and display the result.

#import <Foundation/Foundation.h>

@interface MathOperations:NSObject
- (NSNumber *)subtractNumber:(NSNumber *)x fromNumber:(NSNumber *)y;
@end

@implementation MathOperations

- (NSNumber *)subtractNumber:(NSNumber *)x fromNumber:(NSNumber *)y {
   float num1 = [x floatValue];  // Extract the first number as a float
   float num2 = [y floatValue];  // Extract the second number as a float
   float result = num1 - num2;   // Calculate the difference
   NSNumber *resultObj = [NSNumber numberWithFloat:result];  // Store the result as an NSNumber
   return resultObj;  // Return the result
}

@end

int main() {
   @autoreleasepool {
       MathOperations *operations = [[MathOperations alloc] init];
       NSNumber *num1 = [NSNumber numberWithFloat:100.0];  // First number
       NSNumber *num2 = [NSNumber numberWithFloat:40.0];   // Second number
       NSNumber *difference = [operations subtractNumber:num1 fromNumber:num2];  // Subtract the numbers
       NSString *resultString = [difference stringValue];  // Convert the result to a string
       NSLog(@"The result is %@", resultString);  // Output the result
   }
   return 0;
}

Output:

The result is 60

Blocks in Objective-C are a powerful tool that help simplify development by allowing you to write more concise and efficient code. Blocks are self-contained pieces of code that can be passed around and executed as objects. They are widely used in Objective-C for purposes such as callbacks, iterators, and passing data between objects.

Blocks in Objective-C are similar to functions in that they take arguments, execute code, and return a value. However, they also have the added benefit of being assignable to variables and passed as arguments to methods. Blocks can access and modify variables in the scope in which they are defined, making them highly flexible.

Types of Blocks

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.

Defining and Calling Functions

In Objective-C, functions are defined outside of any class or method and can be called from anywhere in the program where they are visible. Functions can accept parameters and return values.

Defining Functions

A function definition includes the return type, function name, and parameters (if any).

// Function definition
int add(int a, int b) {
    return a + b;
}

Calling a Function

To call a function, simply use its name followed by arguments in parentheses.

// Function call
int result = add(5, 3);  // result is 8
NSLog(@"The result is %d", result);

Function Parameters and Return Values

Functions can accept parameters and return values of various data types.

Function with Parameters

You can define a function with parameters to pass values to it.

// Function with parameters
void printGreeting(NSString *name) {
    NSLog(@"Hello, %@", name);
}

// Calling the function with an argument
printGreeting(@"Alice");

Function with Return Value

A function can return a value using the return statement.

// Function with a return value
double multiply(double x, double y) {
    return x * y;
}

// Calling the function and storing the return value
double product = multiply(4.5, 2.3);
NSLog(@"The product is %f", product);

Function with No Parameters and No Return Value

You can also define a function with no parameters and no return value.

// Function with no parameters and no return value
void sayHello() {
    NSLog(@"Hello, world!");
}

// Calling the function
sayHello();

Function Pointers

Function pointers are used to store the address of a function, allowing you to call a function indirectly.

Declaring a Function Pointer

To declare a function pointer, specify the return type, followed by (*pointerName), and the parameter list.

// Declare a function pointer
int (*operation)(int, int);

Assigning a Function to a Function Pointer

Assign a function to a function pointer by specifying the function’s name without parentheses.

// Use the function pointer to call the function
int sum = operation(10, 5);  // Calls the 'add' function
NSLog(@"The sum is %d", sum);

Example: Using Function Pointers

Here’s a complete example demonstrating the use of function pointers:

#include <Foundation/Foundation.h>

// Define a function
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Declare a function pointer
        int (*operation)(int, int);

        // Assign functions to the function pointer and call them
        operation = add;
        NSLog(@"Add: %d", operation(10, 5));  // Outputs 15

        operation = subtract;
        NSLog(@"Subtract: %d", operation(10, 5));  // Outputs 5
    }
    return 0;
}

In programming, there are scenarios where you need to execute a specific block of code multiple times. Typically, program statements are executed in a linear sequence, where the first statement is followed by the second, and so forth. However, programming languages provide control structures to manage more complex execution flows.

A loop statement allows a specific block of code to be executed repeatedly based on a condition. Below is the general structure of a loop statement, which is common across most programming languages: Types of Loops

Types of Loops

For Loop in Objective-C

The for loop in Objective-C is a control structure used for repeating a set of instructions for a specified number of iterations. Unlike while or do-while loops, the for loop allows variable initialization, condition checking, and variable updates all in a single line.

Syntax:

for (initialisation_of_expression; condition_of_expression; update_expression)
{
    // Body of the loop
    // Instructions to execute
}

Components of a For Loop:

1. Initialization: Used to initialize counters or iterators (e.g., int counter = 1;).
2. Condition: Determines how long the loop will run (e.g., counter <= 10;).
3. Updation: Updates the counter or iterator after each iteration (e.g., counter++;).

Examples:

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int counter;

    for (counter = 1; counter <= 10; counter++)
    {
        NSLog(@"%d. Hello, World!", counter);
    }

    [myPool drain];
    return 0;
}

Output:

1. Hello, World!
2. Hello, World!
3. Hello, World!
4. Hello, World!
5. Hello, World!
6. Hello, World!
7. Hello, World!
8. Hello, World!
9. Hello, World!
10. Hello, World!

Example 2: Breaking Out of a For Loop

The break statement allows exiting the loop before the condition becomes false.

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int counter;

    for (counter = 1; counter <= 10; counter++)
    {
        NSLog(@"%d. Processing...", counter);

        if (counter == 7)
        {
            NSLog(@"Breaking out of the loop...");
            break;
        }
    }

    [myPool drain];
    return 0;
}

Output:

1. Processing...
2. Processing...
3. Processing...
4. Processing...
5. Processing...
6. Processing...
7. Processing...
Breaking out of the loop...

Example 3: Nested For Loops

This program demonstrates how nested loops work.

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int i, j;

    for (i = 1; i <= 3; i++)
    {
        NSLog(@"Outer loop iteration: %d", i);

        for (j = 1; j <= 5; j++)
        {
            NSLog(@"  Inner loop iteration: %d", j);
        }
    }

    [myPool drain];
    return 0;
}

Output:

Outer loop iteration: 1
  Inner loop iteration: 1
  Inner loop iteration: 2
  Inner loop iteration: 3
  Inner loop iteration: 4
  Inner loop iteration: 5
Outer loop iteration: 2
  Inner loop iteration: 1
  Inner loop iteration: 2
  Inner loop iteration: 3
  Inner loop iteration: 4
  Inner loop iteration: 5
Outer loop iteration: 3
  Inner loop iteration: 1
  Inner loop iteration: 2
  Inner loop iteration: 3
  Inner loop iteration: 4
  Inner loop iteration: 5

Example 4: For Loop with Multiple Variables

This example shows a for loop that initializes and updates two variables simultaneously.

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int i, j;

    for (i = 1, j = 10; i <= 10 && j >= 1; i++, j--)
    {
        NSLog(@"i = %d and j = %d", i, j);
    }

    [myPool drain];
    return 0;
}

Output:

i = 1 and j = 10
i = 2 and j = 9
i = 3 and j = 8
i = 4 and j = 7
i = 5 and j = 6
i = 6 and j = 5
i = 7 and j = 4
i = 8 and j = 3
i = 9 and j = 2
i = 10 and j = 1

Do-While Loop in Objective-C

Just like other programming languages, Objective-C supports the do..while loop. A do..while loop is also known as an inverted while loop because, in a while loop, the condition is checked before executing the loop body. If the condition is false, the loop does not execute. However, in a do..while loop, the condition is evaluated at the end of the loop body, ensuring the body executes at least once, regardless of the test condition.

Syntax:

do {
    // Loop Body
    // Update Statement
} while(expression);

Parts of a Do-While Loop:

1. Loop Body: Contains the statements or logic to be executed repeatedly.
2. Update Statement: Modifies the loop control variable (e.g., incrementing or decrementing).
3. Expression: A condition evaluated after the loop body. If true, the loop continues; if false, the loop terminates.

How the Do-While Loop Works:

1. The loop body executes once when the do block is encountered.
2. Statements in the loop body run.
3. The update statement executes.
4. The test condition is evaluated. If true, the control flow returns to Step 2.If false, the loop ends, and control exits the loop.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int num = 8;

    // Do-While Loop
    do {
        // Loop Body
        NSLog(@"Loop is executing.");

        // Update Statement
        num++;
    } while (num < 10);

    [pool drain];
    return 0;
}

Output:

Loop is executing.
Loop is executing.

Example 2:

Objective-C program to print the multiplication table of 16:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int num = 1;
    int res;

    // Do-While Loop
    do {
        // Loop Body
        res = 16 * num;
        NSLog(@"16 * %d = %d", num, res);

        // Update Statement
        num++;
    } while (num <= 16);

    [pool drain];
    return 0;
}

Output:

16 * 1 = 16
16 * 2 = 32
16 * 3 = 48
16 * 4 = 64
16 * 5 = 80
16 * 6 = 96
16 * 7 = 112
16 * 8 = 128
16 * 9 = 144
16 * 10 = 160
16 * 11 = 176
16 * 12 = 192
16 * 13 = 208
16 * 14 = 224
16 * 15 = 240
16 * 16 = 256

While Loop in Objective-C

In Objective-C, the while loop allows for repeating a statement or a group of statements as long as the specified condition evaluates to true. Unlike other loops, the while loop checks its condition before executing the loop body. This makes it ideal for situations where the number of iterations is not known beforehand. If the condition is true, the loop executes; if the condition is false, the loop exits.

while(condition) {
    // Body
}

How the While Loop Works:

1. The program encounters the while loop.
2. The condition is evaluated. If the condition is true, control enters the loop body. If the condition is false, the loop exits.
3. After executing the loop body, any necessary updates occur.
4. Control returns to the condition check. Steps 2–3 repeat as long as the condition remains true.
5. When the condition becomes false, the loop ends, and control moves to the next part of the program.

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int num = 8;

    // While loop execution
    while(num < 10) {
        NSLog(@"Loop is running.");
        num++;
    }

    [pool drain];
    return 0;
}

Output:

Loop is running.
Loop is running.

Explanation:

1. The variable num is initialized with 8.
2. The while loop checks the condition (num < 10). For num = 8, the condition is true, so the loop body executes, printing “Loop is running,” and num is incremented to 9.. For num = 9, the condition is still true, and the loop executes again.
3. When num = 10, the condition becomes false, and the loop ends.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int num = 1;
    int res;

    // While loop execution
    while(num <= 15) {
        res = 15 * num;
        NSLog(@"15 * %d = %d", num, res);
        num++;
    }

    [pool drain];
    return 0;
}

Output:

15 * 1 = 15
15 * 2 = 30
15 * 3 = 45
15 * 4 = 60
15 * 5 = 75
15 * 6 = 90
15 * 7 = 105
15 * 8 = 120
15 * 9 = 135
15 * 10 = 150
15 * 11 = 165
15 * 12 = 180
15 * 13 = 195
15 * 14 = 210
15 * 15 = 225

Nested loops in Objective-C

Objective-C provides three fundamental repetition control structures, commonly known as loops. These loops enable programmers to repeatedly execute a single statement or a block of statements as long as a specified condition is met. Additionally, loops can be embedded within one another, a concept referred to as Nested Loops. Let’s explore them in detail.

Objective-C supports three types of loops that can be nested:

1. Nested While Loop
2. Nested Do-While Loop
3. Nested For Loop

1. Nested While Loop: In Objective-C, a nested while loop occurs when one while loop is placed inside another. For every iteration of the outer loop, the inner loop executes completely, starting from its initial condition and continuing until its termination condition is satisfied.

Syntax:

// Outer while loop
while (condition_expr_1)
{
    // Inner while loop
    while (condition_expr_2)
    {
        // Statements executed by the inner loop
        statement_1;

        // Update the inner loop condition
        increment/decrement of condition_expr_2;
    }

    // Statements executed by the outer loop
    statement_3;

    // Update the outer loop condition
    increment/decrement of condition_expr_1;
}

Execution Flow of Nested While Loops

Step 1: The control checks the condition of the outer while loop (condition_expr_1).

Step 2: If condition_expr_1 is true:

• The control enters the body of the outer loop.
• The inner while loop condition (condition_expr_2) is checked.

Step 3: The control enters the body of the outer loop. The inner while loop condition (condition_expr_2) is checked.

Step 4: If condition_expr_2 is false, the control exits the inner loop and continues with the statements following it in the outer loop.

Step 5: The outer loop condition (condition_expr_1) is updated and rechecked.

Step 6: If condition_expr_1 is false, the control exits the outer loop and proceeds with the next statements in the program.

Example:

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int i = 1;
    int j;

    // Outer while loop
    while (i <= 3)
    {
        // Message from outer while loop
        NSLog(@"%d. Message from outer while loop.", i);

        j = 1;

        // Inner while loop
        while (j <= 5)
        {
            // Message from inner while loop
            NSLog(@"    %d. Message from inner while loop.", j);

            // Update the inner while loop condition
            j++;
        }

        // Update the outer while loop condition
        i++;
    }
    [myPool drain];
    return 0;
}

Output:

1. Message from outer while loop.
    1. Message from inner while loop.
    2. Message from inner while loop.
    3. Message from inner while loop.
    4. Message from inner while loop.
    5. Message from inner while loop.
2. Message from outer while loop.
    1. Message from inner while loop.
    2. Message from inner while loop.
    3. Message from inner while loop.
    4. Message from inner while loop.
    5. Message from inner while loop.
3. Message from outer while loop.
    1. Message from inner while loop.
    2. Message from inner while loop.
    3. Message from inner while loop.
    4. Message from inner while loop.
    5. Message from inner while loop.

2. Nested Do-While Loop: Similar to a while loop, Objective-C allows you to nest two or more do-while loops within a program. The primary distinction between a while loop and a do-while loop is that a do-while loop executes its body at least once before checking its condition. In the case of nested loops, both the outer and inner do-while loops execute their bodies at least once, following the same basic logic as the while loop.

Syntax

// Outer do-while loop
do
{
    // Inner do-while loop
    do
    {
        // Statements executed by the inner do-while loop
        statement_1;

        // Update the inner do-while loop condition
        increment/decrement of condition_expr_2;

    } while (condition_expr_2);

    // Statements executed by the outer do-while loop
    statement_3;

    // Update the outer do-while loop condition
    increment/decrement of condition_expr_1;

} while (condition_expr_1);

Execution Flow of Nested Do-While Loops

Step 1: The control enters the body of the outer do-while loop.
Step 2: The control then enters the body of the inner do-while loop.
Step 3: Execute the body of the inner loop.
Step 4: Update the condition variables of the inner loop.
Step 5: Check the condition of the inner do-while loop: If true it return to Step 2 and if false: Exit the inner loop and move to the next statements in the outer loop.
Step 6: Update the condition variables of the outer loop.
Step 7: Check the condition of the outer do-while loop. If condition is true then it returns to Step 1.If false: Exit the outer loop.

Example:

#import <Foundation/Foundation.h>

int main ()
{
    NSAutoreleasePool *myPool = [[NSAutoreleasePool alloc] init];

    int i = 1;
    int j;

    // Outer do-while loop
    do
    {
        // Message from outer do-while loop
        NSLog(@"%d. Message from outer do-while loop.", i);

        j = 1;

        // Inner do-while loop
        do
        {
            // Message from inner do-while loop
            NSLog(@"    %d. Message from inner do-while loop.", j);

            // Update the inner loop condition
            j++;

        } while (j <= 5);

        // Update the outer loop condition
        i++;

    } while (i <= 3);

    [myPool drain];
    return 0;
}

Output:

1. Message from outer do-while loop.
    1. Message from inner do-while loop.
    2. Message from inner do-while loop.
    3. Message from inner do-while loop.
    4. Message from inner do-while loop.
    5. Message from inner do-while loop.
2. Message from outer do-while loop.
    1. Message from inner do-while loop.
    2. Message from inner do-while loop.
    3. Message from inner do-while loop.
    4. Message from inner do-while loop.
    5. Message from inner do-while loop.
3. Message from outer do-while loop.
    1. Message from inner do-while loop.
    2. Message from inner do-while loop.
    3. Message from inner do-while loop.
    4. Message from inner do-while loop.
    5. Message from inner do-while loop.

The Objective-C language, built on top of C, retains many of the same operators as C. These operators are crucial for creating mathematical expressions and performing various operations. Operators act on variables (operands) to produce a result. For example, in the expression c = a + b, the + and = are operators, and a, b, and c are operands.

Objective-C is widely used for developing iOS and macOS applications. The operators can be categorized as follows:

Types of Operators

1. Arithmetic Operators: Arithmetic operators perform basic mathematical operations on operands, such as addition, subtraction, multiplication, and division.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int n1 = 5, n2 = 3;
    NSLog(@"ADDITION = %d", (n1 + n2));
    NSLog(@"SUBTRACTION = %d", (n1 - n2));
    NSLog(@"MULTIPLICATION = %d", (n1 * n2));
    NSLog(@"DIVISION = %d", (n1 / n2));
    NSLog(@"MODULUS = %d", (n1 % n2));

    [pool drain];
    return 0;
}

Output:

ADDITION = 8
SUBTRACTION = 2
MULTIPLICATION = 15
DIVISION = 1
MODULUS = 2

2. Relational (Comparison) Operators: Relational operators compare two values, returning true or false based on the comparison.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int n1 = 5, n2 = 3;
    NSLog(@"ADDITION = %d", (n1 + n2));
    NSLog(@"SUBTRACTION = %d", (n1 - n2));
    NSLog(@"MULTIPLICATION = %d", (n1 * n2));
    NSLog(@"DIVISION = %d", (n1 / n2));
    NSLog(@"MODULUS = %d", (n1 % n2));

    [pool drain];
    return 0;
}

Output:

ADDITION = 8
SUBTRACTION = 2
MULTIPLICATION = 15
DIVISION = 1
MODULUS = 2

3. Relational (Comparison) Operators: Relational operators compare two values, returning true or false based on the comparison.

Examples:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int n1 = 5, n2 = 3;
    NSLog(@"Equal = %d", (n1 == n2));
    NSLog(@"NOT Equal = %d", (n1 != n2));
    NSLog(@"LESS THAN = %d", (n1 < n2));
    NSLog(@"GREATER THAN = %d", (n1 > n2));

    [pool drain];
    return 0;
}

Output:

Equal = 0
NOT Equal = 1
LESS THAN = 0
GREATER THAN = 1

4. Logical Operators: Logical operators perform logical operations and return either true (1) or false (0).

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int n1 = 1, n2 = 0;
    NSLog(@"LOGICAL AND = %d", (n1 && n2));
    NSLog(@"LOGICAL OR = %d", (n1 || n2));
    NSLog(@"LOGICAL NOT = %d", (!n1));

    [pool drain];
    return 0;
}

Output:

LOGICAL AND = 0
LOGICAL OR = 1
LOGICAL NOT = 0

5. Bitwise Operators: Bitwise operators operate on bits and are often used for low-level programming.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    // n1 = 12(00001100), n2 = 10(00001010)
    int n1 = 12, n2 = 10;

    // The result is 00001000
    NSLog(@"Bitwise AND(n1&n2) = %d\n", (n1 & n2));

    // The result is 00001110
    NSLog(@"Bitwise OR(n1|n2) = %d\n", (n1 | n2));

    // The result is 00101000
    NSLog(@"LEFT SHIFT(n2<<2) = %d\n", (n2 << 2));

    // The result is 00000010
    NSLog(@"RIGHT SHIFT(n2>>2) = %d\n", (n2 >> 2));

    // The result is 00000110
    NSLog(@"XOR(n1^n2) = %d\n", (n1 ^ n2));

    // The result is 11110011
    NSLog(@"ONCE COMPLIMENT(~n1) = %d\n", (~n1));

    [pool drain];
    return 0;
}

• Bitwise AND:
  n1&n2=12&10n1 \& n2 = 12 \& 10n1&n2=12&10
  Binary: 00001100&00001010=0000100000001100 \& 00001010 = 0000100000001100&00001010=00001000
  Result: 8
• Bitwise OR:
  n1∣n2=12∣10n1 | n2 = 12 | 10n1∣n2=12∣10
  Binary: 00001100∣00001010=0000111000001100 | 00001010 = 0000111000001100∣00001010=00001110
  Result: 14
• Left Shift (<<):
  n2<<2=10<<2n2 << 2 = 10 << 2n2<<2=10<<2
  Binary: 00001010<<2=0010100000001010 << 2 = 0010100000001010<<2=00101000
  Result: 40
• Right Shift (>>):
  n2>>2=10>>2n2 >> 2 = 10 >> 2n2>>2=10>>2
  Binary: 00001010>>2=0000001000001010 >> 2 = 0000001000001010>>2=00000010
  Result: 2
• XOR:
  n1⊕n2=12⊕10n1 \oplus n2 = 12 \oplus 10n1⊕n2=12⊕10
  Binary: 00001100⊕00001010=0000011000001100 \oplus 00001010 = 0000011000001100⊕00001010=00000110
  Result: 6
• One’s Complement (~):
  ∼n1=∼12\sim n1 = \sim 12∼n1=∼12
  Binary: ∼00001100=11110011\sim 00001100 = 11110011∼00001100=11110011 (in two’s complement, signed integer representation)
  Result: -13

6. Assignment Operators: Assignment operators assign values or results of expressions to variables.

Example:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int n1 = 20;
    n1 += 10;
    NSLog(@"After +=: %d", n1);
    n1 &= 2;
    NSLog(@"After &=: %d", n1);

    [pool drain];
    return 0;
}

Output:

After +=: 30
After &=: 2

Miscellaneous or Special Operators

Special operators are unique to programming languages and are used to perform specific tasks.

Example:

Size of num1 (int) = 4 bytes
Value of num1 = 8
Value pointed by ptr = 8
Result (a == 10) = 0
Result (a == 15) = 1

Operator Precedence

Operator precedence determines the order in which operators are evaluated in an expression based on their priority. If two or more operators have the same precedence, their associativity determines the evaluation order. Associativity can be either left-to-right or right-to-left.

For example:
In the expression m = 5 - 2 / 2, the result is m = 4, not m = 1, because / (division) has higher precedence than - (subtraction). First, 2 / 2 is evaluated, then 5 - 1.

Operator Precedence Table

Data Types in Objective-C

In Objective-C, each variable is associated with a data type, and each data type requires a specific amount of memory in the system. A data type defines the kind of data a variable will store and the space it occupies in memory. Data types in Objective-C are classified as follows:

Data Types and Their Properties

Below is the list of common data types in Objective-C along with their storage sizes, format specifiers, and example constants:

Primitive Data Types Examples

1. Integers: The int type is used to store whole numbers, including decimal, hexadecimal, and octal values. Unsigned integers store only positive values.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    int a = 9;         // Positive integer
    int b = -9;        // Negative integer
    unsigned int c = 89U;  // Unsigned integer
    long int d = 9998L;    // Long integer

    NSLog(@"Positive Integer: %i", a);
    NSLog(@"Negative Integer: %d", b);
    NSLog(@"Unsigned Integer: %u", c);
    NSLog(@"Long Integer: %li", d);

    [pool drain];
    return 0;
}

Output:

Positive Integer: 9
Negative Integer: -9
Unsigned Integer: 89
Long Integer: 9998

2. Short Integers: The short int type is used for storing 2-byte integer values, which can be positive or negative.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    short int number = 67;
    NSLog(@"Short Integer Value: %hi", number);

    [pool drain];
    return 0;
}

Output:

Short Integer Value: 67

3. Long Integers: The long int type is used when standard int is insufficient for large values.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    long int bigInt = 9223372036854775807;
    NSLog(@"Long Integer Value: %li", bigInt);

    [pool drain];
    return 0;
}

Output:

Long Integer Value: 9223372036854775807

4. Character Data Type: Stores single characters, typically 1 byte.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    char a = 'a';
    NSLog(@"Character Value: %c", a);

    a++;
    NSLog(@"After Increment: %c", a);

    [pool drain];
    return 0;
}

Output:

Character Value: a
After Increment: b

5. Floating Point Types: Floating-point types store decimal numbers.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    float a = 9.8f;
    float b = 2.5f;

    NSLog(@"Float A: %f", a);
    NSLog(@"Float B: %f", b);

    [pool drain];
    return 0;
}

Output:

Float A: 9.800000
Float B: 2.500000

6. Double Types: Double precision floating-point values.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    double a = 12345.678;
    NSLog(@"Double Value: %lf", a);

    [pool drain];
    return 0;
}

Output:

Double Value: 12345.678000

7. Boolean Type: Used to store true or false values, represented as YES or NO.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    BOOL isStudent = YES;

    if (isStudent) {
        NSLog(@"The person is a student.");
    } else {
        NSLog(@"The person is not a student.");
    }

    [pool drain];
    return 0;
}

Output:

The person is a student.

8. String Data Type: Strings are objects created using the NSString class.

Example:

#import <Foundation/Foundation.h>
int main() {
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    NSString *name = @"Objective-C";
    NSLog(@"Programming Language: %@", name);

    [pool drain];
    return 0;
}

Output:

Programming Language: Objective-C

Variables in Objective-C

A variable is a name given to a storage area that programs can manipulate. Each variable in Objective-C has a specific type that determines the size and layout of the variable’s memory, the range of values that can be stored, and the operations that can be applied.

The name of a variable can be composed of letters, digits, and underscores. It must begin with a letter or an underscore. Uppercase and lowercase letters are distinct because Objective-C is case-sensitive. The following are the basic variable types in Objective-C:

Objective-C also allows various other types of variables, such as enumerations, pointers, arrays, structures, and unions, which are covered in later chapters. This section focuses on basic variable types.

Variable Definition in Objective-C

A variable definition tells the compiler where and how much storage to allocate for the variable. A definition specifies the data type and a list of one or more variables of that type as follows:

type variable_list;

Here, type must be a valid Objective-C data type, such as char, int, float, double, BOOL, or any user-defined object, and variable_list may consist of one or more identifier names separated by commas. Examples include:

int i, j, k;
char c, ch;
float f, salary;
double d;

Variables can be initialized during their declaration using the following syntax:

type variable_list;

Here, type must be a valid Objective-C data type, such as char, int, float, double, BOOL, or any user-defined object, and variable_list may consist of one or more identifier names separated by commas. Examples include:

int i, j, k;
char c, ch;
float f, salary;
double d;

Variables can be initialized during their declaration using the following syntax:

type variable_name = value;

Examples:

int a = 3, b = 5;      // Definition and initialization
char x = 'x';          // The variable x has the value 'x'
float pi = 3.14;       // Definition and initialization

For variables without an initializer:

• Variables with static storage duration are initialized to NULL (all bytes have the value 0).
• The initial value of all other variables is undefined.

Variable Declaration in Objective-C

A variable declaration informs the compiler of a variable’s type and name, enabling the compiler to proceed with compilation without requiring the variable’s complete details. Declarations are particularly useful when working with multiple files. For instance, you can declare a variable in one file and define it in another using the extern keyword.

extern int a, b;
extern float pi;

Though a variable can be declared multiple times, it can be defined only once in a file, function, or block of code.

Examples:

#import <Foundation/Foundation.h>

// Variable declaration
extern int a, b;
extern int c;
extern float f;

int main () {
  /* Variable definition */
  int a, b;
  int c;
  float f;

  /* Variable initialization */
  a = 10;
  b = 20;

  c = a + b;
  NSLog(@"Value of c: %d", c);

  f = 70.0 / 3.0;
  NSLog(@"Value of f: %f", f);

  return 0;
}

Output:

Value of c: 30
Value of f: 23.333334

Lvalues and Rvalues in Objective-C

Expressions in Objective-C can be categorized as:

• Lvalue: Refers to a memory location and can appear on the left or right side of an assignment.
• Rvalue: Refers to a data value stored at an address and can appear only on the right side of an assignment.

Example of Valid assignment:

int g = 20;

Example of  Invalid assignment:

10 = 20; // Compile-time error

Introduction to Objective-C

Objective-C is an object-oriented programming language that extends the C language with additional features, primarily for use in macOS and iOS applications. It was originally developed in the early 1980s by Brad Cox and Tom Love and later became the primary programming language used by Apple for its software development.

Uses of Objective-C

1. iOS and macOS App Development: Objective-C has been the cornerstone for developing applications on Apple platforms, ranging from mobile and desktop applications to utilities and games.
2. Legacy Codebases: Many existing iOS and macOS projects are built using Objective-C. Developers with expertise in Objective-C are often needed to maintain, extend, or modernize these projects.
3. Cocoa and Cocoa Touch Frameworks: These frameworks are integral to macOS and iOS development. Objective-C seamlessly integrates with these frameworks, enabling developers to create user interfaces, handle events, and access system services.
4. Open Source Projects: Objective-C is commonly used in open-source libraries and tools. For example, GNUStep offers a cross-platform implementation of the Cocoa API for Objective-C development.
5. High-Level Abstractions: Its object-oriented features allow developers to create modular and reusable software components using classes, objects, inheritance, and polymorphism.

 Comparison: Objective-C vs. Swift

Characteristics of Objective-C

1. Object-Oriented: Objective-C is built on top of C, adding object-oriented capabilities, which allow developers to define classes and objects, promoting code reusability and modularity.
2. Dynamic Typing: Objective-C supports dynamic typing, which means that the type of an object is determined at runtime, allowing for more flexible and adaptable code.
3. Message Passing: Unlike function calls in C, Objective-C uses a messaging model similar to Smalltalk. Messages are sent to objects, and the method invoked is determined at runtime, enabling polymorphism and dynamic behavior.
4. Categories and Protocols: Categories allow you to add methods to existing classes without modifying the original class. Protocols define a set of methods that a class can implement, similar to interfaces in other languages, facilitating polymorphic behavior.
5. Interoperability with C and C++: Objective-C is fully compatible with C, allowing developers to include C code and libraries directly. It can also work with C++ code using Objective-C++.
6. Automatic Reference Counting (ARC): ARC is a memory management feature that automatically handles the retain and release of objects, reducing the need for manual memory management and minimizing memory leaks.
7. Rich Foundation Framework: Objective-C includes a powerful Foundation framework that provides essential classes and APIs for data management, collections, string manipulation, and more, forming the core of macOS and iOS development.
8. Cocoa and Cocoa Touch Frameworks: These frameworks provide a comprehensive set of APIs for building macOS and iOS applications, including user interface components, networking, graphics, and data persistence.
9. Backward Compatibility: Objective-C maintains backward compatibility with older versions of the language, allowing developers to continue using legacy code while taking advantage of new features.
10. Bridging with Swift: Objective-C is interoperable with Swift, Apple’s modern programming language, allowing developers to gradually integrate Swift into existing Objective-C codebases.

Limitations of Objective-C

1. Verbose Syntax: Objective-C’s syntax, with features like square brackets for method calls, can be challenging for developers accustomed to modern languages.
2. Declining Trend: With Swift’s emergence, the industry is shifting towards newer, more efficient languages, impacting the demand for Objective-C.
3. Manual Memory Management: Developers must handle memory manually, increasing the risk of errors like memory leaks and crashes.
4. Limited Safety Features: Objective-C lacks many safety features found in Swift, such as compile-time nullability checks, leading to potential runtime errors.
5. Steep Learning Curve: New developers may find Objective-C difficult to learn due to its syntax and manual memory management requirements.
6. Transition to Swift: While Objective-C and Swift are interoperable, migrating projects or integrating codebases can be complex and time-consuming.

Examples and Outputs

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // Basic program to print a message
        NSLog(@"Hello from Objective-C!");
    }
    return 0;
}

Output:

Hello from Objective-C!