对ARC下的对象的弱引用（__unsafe_unretained）的NSArray

我需要在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）的人，请改用以下问题：在ARC下对弱引用进行归零的集合

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

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

另一种选择：可以选择性地存储弱引用的类别NSMutableArray。

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

对于使用ARC，使用NSValue助手或创建集合（数组，集合，字典）对象并禁用其保留/释放回调的解决方案都不是100％故障安全解决方案。

正如对这些建议的各种评论所指出的那样，此类对象引用将无法像真正的弱引用一样工作：

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

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

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

为了获得第二种行为，您必须声明自己的帮助器类。它只有一个较弱的属性可供您参考。然后，您将此助手对象添加到集合中。

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

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

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

在编写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
  }
}

概念证明（鉴于汤米对向量重新分配的关注）：

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)

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

NSPointerFunctionsWeakMemory

使用适合ARC或GC的弱读写屏障。在上一个发行版中，使用NSPointerFunctionsWeakMemory对象引用将变为NULL。

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

要将弱自我引用添加到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，并且引用将在适当的时间释放，而与此数组引用无关

最简单的解决方案：

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);

注意：这也适用于iOS4.x。

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

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

我刚刚遇到了同样的问题，发现我的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 responsesToSelector：]：消息发送到已释放实例0x1f03c8c0

已检查iOS版本4.3、5.1、6.2。希望对别人有用。

如果需要将弱引用归零，请参见此答案以获取可用于包装器类的代码。

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

如果您经常使用此注释，则会将其指示给您自己的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;
}

我认为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