对 ARC 下对象的弱引用 (__unsafe_unretained) 的 NSArray

Question

我需要在 NSArray 中存储对对象的弱引用，以防止保留循环。我不确定要使用的正确语法。这是正确的方法吗？

Foo* foo1 = [[Foo alloc] init];
Foo* foo2 = [[Foo alloc] init];

__unsafe_unretained Foo* weakFoo1 = foo1;
__unsafe_unretained Foo* weakFoo2 = foo2;

NSArray* someArray = [NSArray arrayWithObjects:weakFoo1, weakFoo2, nil];

请注意，我需要支持 iOS 4.x，因此使用 __unsafe_unretained 而不是 __weak。

---

编辑（2015-02-18）：

对于那些想要使用真正的__weak 指针（不是__unsafe_unretained）的人，请查看这个问题：Collections of zeroing weak references under ARC

Answer 1

不，这是不正确的。这些实际上并不是弱引用。您现在不能真正将弱引用存储在数组中。您需要有一个可变数组并在完成后删除引用，或者在完成后删除整个数组，或者滚动您自己的支持它的数据结构。

希望他们会在不久的将来解决这个问题（NSArray 的弱版本）。

Answer 2

正如 Jason 所说，你不能让 NSArray 存储弱引用。实现 Emile 的建议的最简单的方法是将一个对象包装在另一个存储弱引用的对象中：

NSValue *value = [NSValue valueWithNonretainedObject:myObj];
[array addObject:value];

另一种选择：category 使NSMutableArray 可选择存储弱引用。

请注意，这些是“不安全的未保留”引用，而不是自归零弱引用。如果在对象被释放后数组仍然存在，你就会有一堆垃圾指针。

Answer 3

使用 NSValue 助手或创建集合（数组、集合、字典）对象和disable its Retain/Release callbacks 的解决方案都不是 100% 使用 ARC 的故障安全解决方案。

正如各种 cmet 对这些建议所指出的那样，这样的对象引用不会像真正的弱引用那样工作：

ARC 支持的“适当的”弱属性有两种行为：

1. 不持有对目标对象的强引用。这意味着如果对象没有指向它的强引用，则该对象将被释放。
2. 如果引用的对象被释放，弱引用将变为 nil。

现在，虽然上述解决方案将符合行为 #1，但它们不会表现出 #2。

要获得行为 #2，您必须声明自己的帮助程序类。它只有一个弱属性可供您参考。然后将此辅助对象添加到集合中。

哦，还有一件事：iOS6 和 OSX 10.8 据说提供了更好的解决方案：

[NSHashTable weakObjectsHashTable]
[NSPointerArray weakObjectsPointerArray]
[NSPointerArray pointerArrayWithOptions:]

这些应该为您提供包含弱引用的容器（但请注意下面的 matt 的 cmets）。

Answer 4

如果您需要归零弱引用，请参阅this answer 了解可用于包装类的代码。

that question 的其他答案建议使用基于块的包装器，以及从集合中自动删除零元素的方法。

Answer 5

在编写 c++ 20 年后，我是 Objective-C 的新手。

在我看来，Objective-C 在松耦合消息传递方面表现出色，但在数据管理方面却很糟糕。

想象一下我是多么高兴地发现 xcode 4.3 支持 Objective-c++！

所以现在我将所有 .m 文件重命名为 .mm（编译为 Objective-C++）并使用 C++ 标准容器进行数据管理。

因此“弱指针数组”问题变成了 __weak 对象指针的 std::vector：

#include <vector>

@interface Thing : NSObject
@end

// declare my vector
std::vector<__weak Thing*> myThings;

// store a weak reference in it
Thing* t = [Thing new];
myThings.push_back(t);

// ... some time later ...

for(auto weak : myThings) {
  Thing* strong = weak; // safely lock the weak pointer
  if (strong) {
    // use the locked pointer
  }
}

相当于c++的成语：

std::vector< std::weak_ptr<CppThing> > myCppThings;
std::shared_ptr<CppThing> p = std::make_shared<CppThing>();
myCppThings.push_back(p);

// ... some time later ...

for(auto weak : myCppThings) {
  auto strong = weak.lock(); // safety is enforced in c++, you can't dereference a weak_ptr
  if (strong) {
    // use the locked pointer
  }
}

概念证明（鉴于 Tommy 对向量重新分配的担忧）：

main.mm:

#include <vector>
#import <Foundation/Foundation.h>

@interface Thing : NSObject
@end

@implementation Thing


@end

extern void foo(Thing*);

int main()
{
    // declare my vector
    std::vector<__weak Thing*> myThings;

    // store a weak reference in it while causing reallocations
    Thing* t = [[Thing alloc]init];
    for (int i = 0 ; i < 100000 ; ++i) {
        myThings.push_back(t);
    }
    // ... some time later ...

    foo(myThings[5000]);

    t = nullptr;

    foo(myThings[5000]);
}

void foo(Thing*p)
{
    NSLog(@"%@", [p className]);
}

示例日志输出：

2016-09-21 18:11:13.150 foo2[42745:5048189] Thing
2016-09-21 18:11:13.152 foo2[42745:5048189] (null)

Answer 6

我刚刚遇到同样的问题，发现我的 before-ARC 解决方案在按照设计使用 ARC 进行转换后可以正常工作。

// function allocates mutable set which doesn't retain references.
NSMutableSet* AllocNotRetainedMutableSet() {
    CFMutableSetRef setRef = NULL;
    CFSetCallBacks notRetainedCallbacks = kCFTypeSetCallBacks;
    notRetainedCallbacks.retain = NULL;
    notRetainedCallbacks.release = NULL;
    setRef = CFSetCreateMutable(kCFAllocatorDefault,
    0,
    &notRetainedCallbacks);
    return (__bridge NSMutableSet *)setRef;
}

// test object for debug deallocation
@interface TestObj : NSObject
@end
@implementation TestObj
- (id)init {
   self = [super init];
   NSLog(@"%@ constructed", self);
   return self;
}
- (void)dealloc {
   NSLog(@"%@ deallocated", self);
}
@end


@interface MainViewController () {
   NSMutableSet *weakedSet;
   NSMutableSet *usualSet;
}
@end

@implementation MainViewController

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
    self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
    if (self) {
        // Custom initialization
      weakedSet = AllocNotRetainedMutableSet();
      usualSet = [NSMutableSet new];
   }
    return self;
}

- (IBAction)addObject:(id)sender {
   TestObj *obj = [TestObj new];
   [weakedSet addObject:obj]; // store unsafe unretained ref
   [usualSet addObject:obj]; // store strong ref
   NSLog(@"%@ addet to set", obj);
   obj = nil;
   if ([usualSet count] == 3) {
      [usualSet removeAllObjects];  // deallocate all objects and get old fashioned crash, as it was required.
      [weakedSet enumerateObjectsUsingBlock:^(TestObj *invalidObj, BOOL *stop) {
         NSLog(@"%@ must crash here", invalidObj);
      }];
   }
}
@end

输出：

2013-06-30 00:59:10.266 not_retained_collection_test[28997:907] 建造时间 2013-06-30 00:59:10.267 not_retained_collection_test[28997:907] 添加到 设置 2013-06-30 00:59:10.581 not_retained_collection_test[28997:907] 建造时间 2013-06-30 00:59:10.582 not_retained_collection_test[28997:907] 添加到 设置 2013-06-30 00:59:10.881 not_retained_collection_test[28997:907] 2013-06-30 00:59:10.882 建造 not_retained_collection_test[28997:907] 添加到 设置 2013-06-30 00:59:10.883 not_retained_collection_test[28997:907] 解除分配 2013-06-30 00:59:10.883 not_retained_collection_test[28997:907] 解除分配 2013-06-30 00:59:10.884 not_retained_collection_test[28997:907] 解除分配 2013-06-30 00:59:10.885 not_retained_collection_test[28997:907] * -[TestObj respondsToSelector:]: 消息发送到释放的实例 0x1f03c8c0

检查了 iOS 4.3、5.1、6.2 版本。 希望它对某人有用。

Answer 7

我相信最好的解决方案是使用 NSHashTable 或 NSMapTable。键或/和值可能很弱。你可以在这里阅读更多信息：http://nshipster.com/nshashtable-and-nsmaptable/

Answer 8

如果您不需要特定的订单，您可以使用带有特殊键/值选项的 NSMapTable

NSPointerFunctionsWeakMemory

使用适用于 ARC 或 GC 的弱读写屏障。使用 NSPointerFunctionsWeakMemory 对象引用将在上次发布时变为 NULL。

Answer 9

最简单的解决方案：

NSMutableArray *array = (__bridge_transfer NSMutableArray *)CFArrayCreateMutable(nil, 0, nil);
NSMutableDictionary *dictionary = (__bridge_transfer NSMutableDictionary *)CFDictionaryCreateMutable(nil, 0, nil, nil);
NSMutableSet *set = (__bridge_transfer NSMutableSet *)CFSetCreateMutable(nil, 0, nil);

注意：这也适用于 iOS 4.x。

Answer 10

要添加对 NSMutableArray 的弱自引用，请创建一个具有以下给出的弱属性的自定义类。

NSMutableArray *array = [NSMutableArray new];

Step 1: create a custom class 

@interface DelegateRef : NSObject

@property(nonatomic, weak)id delegateWeakReference;

@end

Step 2: create a method to add self as weak reference to NSMutableArray. But here we add the DelegateRef object

-(void)addWeakRef:(id)ref
{

  DelegateRef *delRef = [DelegateRef new];

  [delRef setDelegateWeakReference:ref] 

  [array addObject:delRef];

}

第3步：稍后，如果属性delegateWeakReference == nil，则可以从数组中删除对象

该属性将为 nil，并且引用将在适当的时间释放，独立于该数组引用

Answer 11

如果你经常使用这个组件，它会显示给你自己的 NSMutableArray 类（NSMutableArray 的子类），它不会增加保留计数。

你应该有这样的东西：

-(void)addObject:(NSObject *)object {
    [self.collection addObject:[NSValue valueWithNonretainedObject:object]];
}

-(NSObject*) getObject:(NSUInteger)index {

    NSValue *value = [self.collection objectAtIndex:index];
    if (value.nonretainedObjectValue != nil) {
        return value.nonretainedObjectValue;
    }

    //it's nice to clean the array if the referenced object was deallocated
    [self.collection removeObjectAtIndex:index];

    return nil;
}

Answer 12

我认为 Erik Ralston 先生在他的 Github 存储库中提出了一个优雅的解决方案

https://gist.github.com/eralston/8010285

这是基本步骤：

为 NSArray 和 NSMutableArray 创建一个类别

在实现中创建一个具有弱属性的便利类。您的类别会将对象分配给此弱属性。

.h

 #import <Foundation/Foundation.h>

@interface NSArray(WeakArray)

- (__weak id)weakObjectForIndex:(NSUInteger)index;
-(id<NSFastEnumeration>)weakObjectsEnumerator;

@end

@interface NSMutableArray (FRSWeakArray)

-(void)addWeakObject:(id)object;
-(void)removeWeakObject:(id)object;

-(void)cleanWeakObjects;

@end

.m

#import "NSArray+WeakArray.h"

@interface WAArrayWeakPointer : NSObject
@property (nonatomic, weak) NSObject *object;
@end

@implementation WAArrayWeakPointer
@end

@implementation NSArray (WeakArray)


-(__weak id)weakObjectForIndex:(NSUInteger)index
{
    WAArrayWeakPointer *ptr = [self objectAtIndex:index];
    return ptr.object;
}

-(WAArrayWeakPointer *)weakPointerForObject:(id)object
{
    for (WAArrayWeakPointer *ptr in self) {
        if(ptr) {
            if(ptr.object == object) {
                return ptr;
            }
        }
    }

    return nil;
}

-(id<NSFastEnumeration>)weakObjectsEnumerator
{
    NSMutableArray *enumerator = [[NSMutableArray alloc] init];
    for (WAArrayWeakPointer *ptr in self) {
        if(ptr && ptr.object) {
            [enumerator addObject:ptr.object];
        }
    }
    return enumerator;
}

@end

@implementation NSMutableArray (FRSWeakArray)

-(void)addWeakObject:(id)object
{
    if(!object)
        return;

    WAArrayWeakPointer *ptr = [[WAArrayWeakPointer alloc] init];
    ptr.object = object;
    [self addObject:ptr];

    [self cleanWeakObjects];
}

-(void)removeWeakObject:(id)object
{
    if(!object)
        return;

    WAArrayWeakPointer *ptr = [self weakPointerForObject:object];

    if(ptr) {

        [self removeObject:ptr];

        [self cleanWeakObjects];
    }
}

-(void)cleanWeakObjects
{

    NSMutableArray *toBeRemoved = [[NSMutableArray alloc] init];
    for (WAArrayWeakPointer *ptr in self) {
        if(ptr && !ptr.object) {
            [toBeRemoved addObject:ptr];
        }
    }

    for(WAArrayWeakPointer *ptr in toBeRemoved) {
        [self removeObject:ptr];
    }
}

@end