Posing in Objective-C

In Objective-C, posing is a runtime mechanism that allows one class to completely replace another class so that all messages sent to the original class are handled by the posing class. The class that replaces the original is said to pose as it.

⚠️ Important (Modern Reality)
Class posing is deprecated and not supported with ARC. It existed in older Objective-C runtimes (pre–macOS 10.5). Today, it is mainly a theoretical and historical concept, useful for understanding the Objective-C runtime.

What Is Posing?

Posing enables a subclass to assume the identity of its superclass at runtime. Once posing occurs:

• The original class is replaced globally
• All messages to the original class are redirected to the posing class
• Existing instances behave as instances of the posing class

This was historically used to:

• Intercept and customize behavior
• Extend or fix system classes
• Aid debugging and testing

Key Characteristics of Posing

• Only a subclass can pose as its superclass
• Posing affects the entire program
• The original class becomes unavailable
• Must occur before the original class is used
• Unsafe and hard to debug (reason for deprecation)

Important Clarification (Very Common Confusion)

Many examples online confuse class posing with object-level class swapping.

❌ Not Posing:

Using object_setClass(obj, NewClass)
This only changes the class of a single object instance, not the class itself.

✅ True Posing (Legacy):

Using +poseAsClass:
This replaces the entire class globally.

True (Legacy) Posing Syntax

[PosingClass poseAsClass:[OriginalClass class]];

Once executed:

• OriginalClass is replaced everywhere
• All messages to OriginalClass go to PosingClass

Conceptual Example (Legacy Runtime Only)

Original Class

@interface Printer : NSObject
- (void)printMessage;
@end

@implementation Printer
- (void)printMessage {
    NSLog(@"Original Printer");
}
@end

Posing Class

@interface DebugPrinter : Printer
@end

@implementation DebugPrinter
+ (void)load {
    [self poseAsClass:[Printer class]];
}

- (void)printMessage {
    NSLog(@"Debug Printer (Posing)");
}
@end

Usage

Printer *p = [[Printer alloc] init];
[p printMessage];

Output

Debug Printer (Posing)

Even though Printer is instantiated, the runtime routes the call to DebugPrinter.

“Static” vs “Dynamic” Posing (Clarified)

Static Posing (Historical Concept)

• Occurs during program load (+load)
• Fixed for the program’s lifetime
• Requires recompilation to change

Dynamic Runtime Tricks (Not True Posing)

• Using object_setClass
• Affects only specific objects
• Does not replace the class globally
• Often mislabelled as “dynamic posing” (incorrect)

Why Posing Was Removed

Posing caused serious problems:

• Global side effects
• Unpredictable behavior
• Difficult debugging
• Breaks encapsulation
• Unsafe with multithreading
• Incompatible with ARC

Apple deprecated posing in favor of safer alternatives.

Modern Alternatives to Posing

1. Categories (Most Common)

Add methods without replacing the class.

@interface Printer (Debug)
- (void)debugPrint;
@end

2. Method Swizzling (Advanced, Use Carefully)

Swap method implementations at runtime.

method_exchangeImplementations(original, swizzled);

3. Subclassing

Override behavior in a controlled, object-oriented way.

4. Composition (Best Practice)

Wrap behavior instead of replacing it.

Interview Perspective

If asked about posing:

• Clearly state it is deprecated
• Explain what it does conceptually
• Clarify the difference between class posing and object_setClass
• Mention modern alternatives

This shows strong understanding of the Objective-C runtime.

Summary

• Posing allows a subclass to completely replace its superclass
• All messages to the original class are redirected
• Extremely powerful but unsafe
• Deprecated and unsupported with ARC
• Replaced by categories, swizzling, subclassing, and composition