我对Xcode 7中看到的东西感到有些困惑,下面的3种颜色都有你想要的单独地址,但弱颜色都有相同的地址.我知道弱色是选项,所以weak_R和color_R有不同的地址,但我不能完全解释为什么所有3个弱显示相同的地址.

这看起来是否正确,如果是,有人可以解释我所看到的吗？如果不是我猜它是一个错误.

码

    var color_R = SKColor.redColor()
    var color_G = SKColor.greenColor()
    var color_B = SKColor.blueColor()
    weak var weak_R = color_R
    weak var weak_G = color_G
    weak var weak_B = color_B

DEBUG

[weak self]作为一个参数传递给一个闭包与传递有什么区别[weak self] ()

例如 :

dispatch_async(dispatch_get_main_queue()) { [weak self] in 
     //Some code here
}

V/S

dispatch_async(dispatch_get_main_queue()) { [weak self] () -> Void in
     //Some code here
}

我想TParent通过使用聚合构建一个包含多个子对象的类.有些对象是独立的,有些也可能依赖于其他孩子.所有子对象都必须具有对父对象的引用.我也想尽可能使用接口.

为此我使用TInterfacedObject的TParent并TAggregatedObject为孩子.由于孩子和父母都知道彼此,我使用弱引用以避免循环依赖.事实上,这种行为已经在中定义TAggregatedObject.当我只使用独立的子对象(TIndependantChild)时,一切正常.

当子对象也依赖于其他孩子时会出现问题,请参阅构造函数TDependantChild.我将引用存储在fChild变量中的另一个子对象中,该变量用[weak]Delphi 10 Berlin中引入的attibute标记.FastMM4报告关机时的内存泄漏:

此外,访问违规会导致System.TMonitor.Destroy加注,但只有当FastMM4处于使用状态并且ReportMemoryLeaksOnShutDown为True时才会发生这种情况.

program Project1;

{$APPTYPE CONSOLE}

uses
  FastMM4,
  System.SysUtils;

type
  IParent = interface
  ['{B11AF925-C62A-4998-855B-268937EF30FB}']
  end;

  IChild = interface
  ['{15C19A4E-3FF2-4639-8957-F28F0F44F8B4}']
  end;

  TIndependantChild = class(TAggregatedObject, IChild)
  end;

  TDependantChild = class(TAggregatedObject, IChild)
  private
    [weak] fChild: IChild;
  public
    constructor Create(const Controller: IInterface; const AChild: IChild); reintroduce;
  end;

  TParent = class(TInterfacedObject, IParent)
  private
    fIndependantChild: TIndependantChild;
    fDependantChild: TDependantChild;
  public
    constructor Create;
    destructor Destroy; override; …

在编译此 C 代码期间

extern void Default_Handler(void);
void NMI_Handler(void) __attribute__ ((weak, alias ("Default_Handler")));

我收到了这个

extern void Default_Handler(void);
void NMI_Handler(void) __attribute__ ((weak, alias ("Default_Handler")));

如何在外部定义的函数上创建别名？

编译器：

gcc version 7.2.1 20170904 (release) [ARM/embedded-7-branch revision 255204] (GNU Tools for Arm Embedded Processors 7-2017-q4-major)

处理软引用和弱引用时遇到问题.代码有一个标志,可以在软引用和弱引用之间切换所有逻辑.虽然弱引用似乎都工作正常,使用软引用我一直得到OutOfMemoryError.这种情况发生在MacOSX上的JDK7和JDK6以及Debian上的IcedTea6.然而,与JDK7 G1收集器的设置,我发现与软引用的工作,其他的一切我试过(串行/并行GC,-client/-server等)失败抛出异常.

代码有点大,但我试图在保留问题的同时尽量缩小代码.
我在其上面留下了一个大量的评论,更详细地描述了如何重现这个问题.

/*
 *
 * Leakling.java
 *
 *
 * Issue:
 *
 *
 *   This code throws OutOfMemoryError when using soft references, whereas weak references
 *   work ok. Moreover, with JDK7 G1 garbage collector soft references work as well. Other
 *   collectors seem to fail. Code was tested with MacOSX 10.8.2 JDKs 1.7.0_10-b18 and
 *   1.6.0_37-b06-434-11M3909, with Debian 6.0 IcedTea6 1.8.13.
 *   Various command line options including -Xmx, -client/-server, -XX:+UseParallelOldGC,
 *   -XX:+UseSerialGC were tested.
 *
 *
 * Examples:
 * …

考虑下面的简单程序：

__attribute__((weak)) void weakf(void);

int main(int argc, char *argv[])
{
        weakf();
}

当用 gcc 编译它并在 Linux PC 上运行它时，它会出现段错误。在 ARM CM0 (arm-none-eabi-gcc) 上运行它时，链接器通过跳转到以下指令和 nop 替换未定义的符号。

这种行为记录在哪里？是否有可能通过命令行选项更改它？我已经通过GCC和LD文档，没有关于这方面的信息。

但是，如果我检查 ARM 编译器文档，则会清楚地解释这一点。

我总是[weak self]在快速关闭中使用以防止引用循环。这是下面的代码，这是正确的方法吗？

someTask(completion: {[weak self] (result) in
        if self == nil {  
            return
        }

        //is it safe when reach here? 

        self!.xxx = yyy
        self!.doLongTermWork()
        self!.finish()  //will crash when self is nil?
    })

弱自我不会对实例保持强大的控制。那么什么时候self.doLongTermWork(), 会self在nil其他地方再次设置？

gcc在处理不同优化级别（即或）上的弱常量变量时，我得到了一个奇怪的行为。-O0-O1

这是代码：

def.h : 声明

const int var;
int copy;
int do_copy(void);

weak.c : 弱var定义，do_copy实现做copy = var

#include "def.h"
const int __attribute__((weak)) var = 1;
int do_copy(void)
{
    copy = var;
    return var;
}

main.c : 强var定义和使用do_copy

#include <stdio.h>
#include "def.h"
int copy = 0;
int copy2 = 0;
const int var = 2;
int main(void)
{
    copy2 = do_copy();
    printf("copy=%d, copy2=%d\n", copy, copy2);
    return 0;
} …

如果我在另一个闭包中有一个闭包，是否足以在外部闭包中使用一次 unowned/weak 来避免保留循环？

例子：

foo.aClosure({[unowned self] (allowed: Bool) in
            if allowed {
                self.doStuff()

                self.something.anotherClosure({ (s:String) -> (Void) in
                    self.doSomethingElse(s)
                })   
            }
        })

我试图将 tableView 的数据源分离到一个单独的委托对象中。由于该委托需要在某个时刻访问表视图，因此我需要对委托中的委托对象的引用；由于两者都是类，我需要通过委托来避免强引用循环weak

为了实现这一目标，我尝试了以下代码。

class MyViewController: UIViewController {

    @IBOutlet weak var tableView: UITableView!
    weak var tableViewDelegate: UITableViewDataSource?

    override func viewDidLoad() {
        super.viewDidLoad()
        tableViewDelegate = TableViewDelegate() // throwing a warning
        tableView.dataSource = tableViewDelegate
    }
}

当我尝试实例化委托时，Xcode 会抛出警告：“实例将立即释放，因为属性‘tableViewDelegate’为‘弱’”

因此，为了修复它，我执行以下操作：

class MyViewController: UIViewController {

    @IBOutlet weak var tableView: UITableView!
    weak var tableViewDelegate: UITableViewDataSource?

    override func viewDidLoad() {
        super.viewDidLoad()
        let delegate = TableViewDelegate() // worried this creates a strong reference.
        self.tableViewDelegate = delegate
        tableView.dataSource = delegate
    }
}

请确认以下内容是否正确：通过在 viewDidLoad() 方法中初始化委托，我不会面临创建强引用的危险，因为一旦我们离开该方法的范围，保存该实例的变量就会被释放。或者换句话说：我们唯一需要担心变量（指向类）创建强引用的情况是该变量是否在类级别初始化，因此只要该类存在，该变量就会一直存在。

那是对的吗？