同级性能

Question

有什么目标C魔法我可以用它来执行以下操作：

说我有一个类Foo，具有两个属性MyObj中A和B. otherObj

现在...

在myObj（A）的类实现文件（.m）中，我想访问 它是“父类”Foo中的“兄弟”属性“otherObj B”。

有没有类似这样的目标C，以帮助获得同级性质的东西：

self.ParentClass.b; ？ 或 self.OwningClass.b; ？

我知道惯例可能是通过一个refence A的初始化期间B，但我不希望有创建多个自定义initalisers

，如果有一个快捷方式只是想知道。

@interface Foo : NSObject 
    @property A 
    @property B 
@end 

@interface A : NSObject 
    @property B 
@end 

@implementation A : NSObject 
    self.B = self.parent.B; 
@end 

感谢，

Answer 1

没有内置“父”或“所有者”的概念（很大，因为对象可能在理论上具有由多个对象维护的强引用）。但是，仅仅添加自己的parent属性：

因此，可以考虑：

@interface Foo : NSObject 

@property (nonatomic, strong) A *a; 
@property (nonatomic, strong) B *b; 

@end 

@interface A : NSObject 

@property (nonatomic, weak) Foo *parent; 

- (id)initWithParent:(Foo *)foo; 

@end 

@interface B : NSObject 

@property (nonatomic, weak) Foo *parent; 

- (id)initWithParent:(Foo *)foo; 

@end 

所以，Foo将自己A和B对象（因此strong引用），和A和B的情况下，将继续保持weak参考给他们的父母。请注意，weak对父项的引用至关重要，以避免强参考周期（也称为保留周期）。

这些类的实现可能是这样的：

@implementation Foo 

- (id)init 
{ 
    self = [super init]; 
    if (self) { 
     _a = [[A alloc] initWithParent:self]; 
     _b = [[B alloc] initWithParent:self]; 
    } 
    return self; 
} 

@end 

@implementation A 

- (id)initWithParent:(Foo *)foo 
{ 
    self = [super init]; 
    if (self) { 
     _parent = foo; 
    } 
    return self; 
} 

- (void)someRandomMethod 
{ 
    B *sibling = self.parent.b; 

    // now do whatever you want with your reference to the sibling object 
} 

@end 

@implementation B 

- (id)initWithParent:(Foo *)foo 
{ 
    self = [super init]; 
    if (self) { 
     _parent = foo; 
    } 
    return self; 
} 

@end 

通知，A我有一个someRandomMethod这说明它如何能获得访问它的兄弟姐妹，B。您也可以从B到A做同样的事情。

我知道你说你不想写自己定制的init方法，但这是正确的做法。或者只是调用默认的init方法并手动设置子对象的parent属性，例如，：

_a = [[A alloc] init]; 
_a.parent = self; 
_b = [[B alloc] init]; 
_b.parent = self; 

Answer 2

如果你有

@interface A : NSObject 
@property A 
@end 

@interface B : NSObject 
@property B 
@end 

然后有没有办法知道B和反之亦然。至于你说的：你必须通过一个参考

IF你曾经只有A的一个实例和B的一个实例，那么你可以使用一个单例模式。但它引入了额外的依赖关系，并使得代码的可重用性更低。所以虽然它可能工作，那不是我会推荐的方式。