Get instance count of a specific class in Objective-C/IOS - ios

Question

For QA purposes I want to ensure that instances of specific classes have been deallocated properly (so the actual count of instances is sufficient). I looked into the Objective-C runtime reference, but I could not find the appropriate function. I have checked similar questions but did not find a satisfying answer.
Edit
I took TheCodingArt's mockup and completed it, the result can be obtained at
https://www.generomobile.de/gmi/allocchecker.m
The difficulty was to swizzle dealloc because ARC forbids passing the selector of dealloc for swizzling. I stumbled across this interesting swizzling tutorial at http://defagos.github.io/yet_another_article_about_method_swizzling/
NSString and other class clusters obviously are not freed by dealloc as one can see in the sample. But for my own classes it works our current IOS project and gives some interesting insights.

Answer 1

One solution is to setup a static counter in your .m file. Increment the counter in the designated init method and decrement the counter in the dealloc method. Provide a class method to read the count value.
Don't do this as a rule. This should only be done for testing.
Lets say you want to track the instance count of SomeClass. You can do:
SomeClass.h
#interface SomeClass : NSObject
+ (NSInteger)instanceCount;
// everything else you need
#end
SomeClass.m
#import "SomeClass.h"
static NSInteger instanceCount = 0;
#implementation SomeClass
- (instancetype)init {
self = [super init];
if (self) {
instanceCount++;
// everything else you need
}
return self;
}
// all your other code
+ (NSInteger)instanceCount {
return instanceCount;
}
- (void)dealloc {
instanceCount--;
}
#end

Answer 2

Per request, I've mocked up a category that will keep count of allocated objects using method swizzling and a singleton. This was a quick mock up, so there are a few issues with it (one being that initializing anything that is contained within the storage class will cause an infinite loop). Mind you, this is for keeping track of many objects and should not be used in a production environment. The best methodology overall is to use the instruments tool.
#import "NSObject+Initializer.h"
#import <objc/runtime.h>
#interface ObjectCounter : NSObject
+ (instancetype)sharedObjectCounter;
#property (strong, nonatomic) NSMutableDictionary *objectCounterDictionary;
#end
#implementation ObjectCounter
+ (instancetype)sharedObjectCounter
{
static ObjectCounter *objectCounter;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
objectCounter = [ObjectCounter new];
objectCounter.objectCounterDictionary = [NSMutableDictionary new];
});
return objectCounter;
}
#end
#implementation NSObject (Initializer)
+ (NSNumber *)initializedCount
{
NSLog(#"Dict: %#", [ObjectCounter sharedObjectCounter].objectCounterDictionary);
return [ObjectCounter sharedObjectCounter].objectCounterDictionary[NSStringFromClass([self class])];
}
+ (id)alloc_swizzled
{
NSLog(#"Swizzled");
NSString *className = NSStringFromClass([self class]);
if (![className isEqualToString:NSStringFromClass([NSMutableDictionary class])] && ![className isEqualToString:NSStringFromClass([ObjectCounter class])]) {
ObjectCounter *counter = [ObjectCounter sharedObjectCounter];
NSMutableDictionary *objectDictionary = counter.objectCounterDictionary;
NSNumber *count = objectDictionary[className];
count = count ? #(count.integerValue + 1) : #0;
objectDictionary[className] = count;
}
return [self alloc_swizzled];
}
+ (void)load
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
Class class = [self class];
SEL originalSelector = #selector(alloc);
SEL swizzledSelector = #selector(alloc_swizzled);
Method originalMethod = class_getClassMethod(class, originalSelector);
Method swizzledMethod = class_getClassMethod(class, swizzledSelector);
BOOL didAddMethod = class_addMethod(class, originalSelector, method_getImplementation(swizzledMethod), method_getTypeEncoding(swizzledMethod));
if (didAddMethod) {
class_replaceMethod(class, swizzledSelector, method_getImplementation(originalMethod), method_getTypeEncoding(originalMethod));
} else {
method_exchangeImplementations(originalMethod, swizzledMethod);
}
});
}

Answer 3

You can get a count without subclassing by adding a category and overriding alloc, This is really hacky but it's fine for testing and good for classes you don't own. I have no idea if this would work without ARC.
#implementation UILabel (LableCounter)
static NSInteger labelCount = 0;
+ (id)alloc
{
labelCount++;
return [super alloc];
}
-(void)dealloc{
labelCount--;
}
#end