Objective-C 块中的泄漏C++ shared_ptr

Question

摘要：

在下面的示例应用程序中，shared_ptr被捕获在Objective-C块中。Objective-C块被分配给使用Objective-C运行时APIobject_setIvarWithStrongDefault动态创建的类的ivar。当 Objective-C 对象被解除分配时，shared_ptr会泄漏，并且它保留的C++对象不会被删除。为什么？

当使用object_setIvar代替时，可以防止泄漏，但是一旦块超出范围，ivar就会指向垃圾，因为object_setIvar假设分配unsafe_unretained。

我认为这与Objective-C如何捕获C++对象，复制块以及shared_ptr如何处理被复制有关，但我希望有人能比下面列出的文档更清楚地了解这一点。

引用：

• Apple 的块和变量文档包含关于C++对象的简短部分，但我并不完全清楚它如何影响共享指针。

• LLVM关于块和C++支持的文档比Apple的更详细一些。

• objc-class.mm 包含object_setIvarWithStrongDefault的实现

背景故事：

此示例代码是从更大的项目中提取的，并且已显著减少到显示问题所需的最小值。该项目是一个Objective-C macOS应用程序。该应用程序包含多个整体式C++对象，这些对象是美化的键/值存储。每个对象都是同一类的实例，但在键类型上模板化。我想动态创建一个 Objective-C 类，其中包含由 C++ 类支持的类型化属性 getter。

(是的，这一切都可以通过自己编写很多很多的getter来手动完成，但我宁愿不这样做。C++类有足够的信息来知道属性的名称及其类型，因此我想使用一些元编程技术来"解决"这个问题。

笔记：

在理想的世界中，我只能在适当的shared_ptr类型的Objective-C类上定义iVar，但我无法弄清楚如何使用Objective-C运行时API来做到这一点。

鉴于此：

std::shared_ptr<BackingStore<T>> backingStore

你如何使用这个：

class_addIvar和object_setIvar

由于我无法弄清楚这一点，我决定将shared_ptr包装到Objective-C块中，因为块是一等对象，可以在预期id的地方传递。

示例应用程序：

(复制/粘贴到类似CodeRunner的东西以查看输出)

#import <Foundation/Foundation.h>
#import <objc/runtime.h>
#import <memory>
typedef NSString* (^stringBlock)();
/**
*  StoreBridge
*
*  Objective-C class that exposes Objective-C properties
*  which are "backed" by a C++ object (Store). The implementations
*  for each property on this class are dynamically added.
*/
@interface StoreBridge : NSObject
@property(nonatomic, strong, readonly) NSString *storeName;
@end
@implementation StoreBridge
@dynamic storeName;
- (void)dealloc {
NSLog(@"StoreBridge DEALLOC");
}
@end
/**
*  BackingStore
*
*  C++ class that for this example just exposes a single,
*  hard-coded getter function. In reality this class is
*  much larger.
*/
class BackingStore {
public:
BackingStore()  { 
NSLog(@"BackingStore constructor."); 
}
~BackingStore() { 
NSLog(@"BackingStore destructor.");  
}
NSString *name() const { 
return @"Amazon"; 
}
// Given a shared_ptr to a BackingStore instance, this method
// will dynamically create a new Objective-C class. The new
// class will contain Objective-C properties that are backed
// by the given BackingStore. 
//
// Much of this code is hard-coded for this example. In reality,
// a much larger number of properties are dynamically created
// with different return types and a new class pair is
// only created if necessary.
static id makeBridge(std::shared_ptr<BackingStore> storePtr) {
// For this example, just create a new class pair each time.
NSString *klassName = NSUUID.UUID.UUIDString;
Class klass = objc_allocateClassPair(StoreBridge.class, klassName.UTF8String, 0);
// For this example, use hard-coded values and a single iVar definition. The
// iVar will store an Objective-C block as an 'id'.
size_t ivarSize = sizeof(id);
NSString *ivarName = @"_storeNameIvar";
NSString *encoding = [NSString stringWithFormat:@"%s@", @encode(id)];
SEL selector = @selector(storeName);
// Implementation for @property.storeName on StoreBridge. This 
// implementation will read the block stored in the instances 
// iVar named "_storeNameIvar" and call it. Fixed casting to 
// type 'stringBlock' is used for this example only.
IMP implementation = imp_implementationWithBlock((id) ^id(id _self) { 
Ivar iv = class_getInstanceVariable([_self class], ivarName.UTF8String);
id obj = object_getIvar(_self, iv);
return ((stringBlock)obj)();
});
// Add iVar definition and property implementation to newly created class pair.
class_addIvar(klass, ivarName.UTF8String, ivarSize, rint(log2(ivarSize)), @encode(id));
class_addMethod(klass, selector, implementation, encoding.UTF8String);
objc_registerClassPair(klass);
// Create instance of the newly defined class.
id bridge = [[klass alloc] init];
// Capture storePtr in an Objective-C block. This is the block that
// will be stored in the instance's iVar. Each bridge instance has
// its own backingStore, therefore the storePtr must be set on the
// instance's iVar and not captured in the implementation above.
id block = ^NSString* { return storePtr->name(); };
Ivar iva = class_getInstanceVariable(klass, ivarName.UTF8String);
// Assign block to previously declared iVar. When the strongDefault
// method is used, the shared_ptr will leak and the BackingStore
// will never get deallocated. When object_setIvar() is used,
// the BackingStore will get deallocated but crashes at
// runtime as 'block' is not retained anywhere. 
//
// The documentation for object_setIvar() says that if 'strong'
// or 'weak' is not used, then 'unretained' is used. It might
// "work" in this example, but in a larger program it crashes
// as 'block' goes out of scope.
#define USE_STRONG_SETTER 1
#if USE_STRONG_SETTER
object_setIvarWithStrongDefault(bridge, iva, block);
#else 
object_setIvar(bridge, iva, block);
#endif
return bridge;
}
};
int main(int argc, char *argv[]) {
@autoreleasepool {
std::shared_ptr<BackingStore> storePtr = std::make_shared<BackingStore>();
StoreBridge *bridge = BackingStore::makeBridge(storePtr);
NSLog(@"bridge.storeName: %@", bridge.storeName);
// When USE_STRONG_SETTER is 1, output is:
//
//   > BackingStore constructor.
//   > bridge.storeName: Amazon
//   > StoreBridge DEALLOC
// When USE_STRONG_SETTER is 0, output is:
//
//  > BackingStore constructor.
//  > bridge.storeName: Amazon
//  > BackingStore destructor.
//  > StoreBridge DEALLOC
}
}

Answer 1

让我们快速跳入时间机器，C.A. 2010。这是一个更简单的时间，在不得不处理多架构切片、64 位和其他花哨的东西之前，比如重要的 ARC。

在这个看似遥远的世界里，今天，当你有记忆的时候，你不得不自己喘息着释放它。这意味着，如果你的班级里有一个iVar，你必须明确地，在里面dealloc调用release。

好吧，这实际上并没有随着 ARC 而改变。唯一改变的是编译器在dealloc内部为你生成所有这些很好的release调用，即使你没有定义方法。真好。

然而，这里的问题是编译器实际上并不知道包含该块的 iVar - 它是在运行时完全定义的。那么编译器如何释放内存呢？

答案是没有。你需要做一些魔法来确保你在运行时发布这些东西。我的建议是遍历类的 iVar，并将它们设置为nil，而不是直接调用objc_release(因为如果您使用 ARC，它会导致很多哭泣和咬牙

切齿)。像这样：

for (ivar in class) {
if ivar_type == @encode(id) {
objc_setIvar(self, ivar, nil)
}
}

现在，如果您进入并有意为此类添加__unsafe_unretained ivar，您可能会遇到更多问题。但是你真的不应该从这样的类继承，mmkay？