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