d的析构与垃集.

原文在此
但好像原链接的js代码有问题.
作者:M.P.(mike parker)

本文探索垃集与析构的交互.是垃集系列的一部分.
讨论分2篇:1,确定性/非确定性的差异,考虑两种情况下单析构的后果,并建立准则来避免它.2,在准则不管用时,如何写可靠析构器.

确定性析构

可预测,程序员,可根据代码流来知道何时何地析构.对栈上分配的构实例,为自动/确定性析构,编译器在明确点上插入调用析构器代码.
自动析构的两个基本规则:
1,退出域时,调用域中所有栈分配的构的析构器.
2,以与声明顺序相反的顺序析构.
现在可检查代码:

导入 标.标io;
构 可预期
{
   整 数字;
   本(整 n)
  {
       写行(n,"号构造器");
       数字=n;
  }
  ~本()
  {
       写行(数字,"号析构器");
  }
}

空 主()
{
   可预期 s0=可预期(0);
  {
       可预期 s1=可预期(1);
  }
   可预期 s2=可预期(2);
}

可见,s0/s2都在主函数中,在主退出时,调用其析构器.先s2后s0(逆序).而s1在s2与s0间的匿名域中.

#0构造器
#1构造器
#1析构器//1在0与2间.
#2构造器
#2析构器
#0析构器

程序员,可手动确定性析构,用malloc或std.experimental.allocator在非垃集堆上实现,这是必需的.先前文章,我介绍了用std.conv.emplace在非垃集堆上分配实例,并在此提及,可用消灭手动调用析构器.
这是自动导入的对象模块中的函数模板,因而始终可用.本文章只讨论手动析构.
下面,我们重用可预测构和消灭可预测来手动调用析构器.为完整,我提供了从非垃集堆分配和释放实例函数:分配可预期,消灭可预期.

空 主()
{
   可预期*s0=分配可预期(0);
   域(退出){消灭可预期(s0);}
  {
       可预期*s1=分配可预期(1);
       域(退出){消灭可预期(s1);}
  }
   可预期*s2=分配可预期(2);
   域(退出){消灭可预期(s2);}
}

空 消灭可预期(可预期*p)
{
   如(p){消灭(*p);回收可预期(p);}
}

可预期*分配可预期(整 n)
{
   导入 核心.标c.标准库:分配;
   导入 标.转换:原位;
   动 p=转换(可预期*)分配(可预期.的大小);
   中 原位!可预期(p,n);
}

空 回收可预期(可预期*p)
{
   导入 核心.标c.标准库:释放;释放(p);
}

跑该程序与上一个输出一样.我们在消灭可预期用消灭解引用指针,无带指针重载.对类,接口,按引用传递构,其他按引用的类型,有特化版.在有析构器上的类型上调用它们.退出前,函数用引用置参为初值.
注意,如果我们不解引用前消灭指针,仍可编译.
将按引用接收该指针,并置为空针(指针默认初值),但不会调用构的析构器,即消灭了指针,但未消灭构实例.

   消灭(*p);写行(*p);

如上,对每个析构对象,将打印可预测(0).这是该构的默认初值.D构的默认初值为其内部成员初值的聚集.定义构时可改.
消灭不仅针对非垃集堆上分配实例,无论在哪分配的聚集(构,类,接口)类型,都可用消灭.

非确定性析构

支持垃集的语言,析构责任落在垃集身上.称为终止.回收内存前,垃集终止器调用对象的终止器.虽然方便,但价格贵.可能导致死锁/悬挂.
而D不至于那么惨,但也有警告:对未解引用对象,不保证运行析构器,且未指定调用未引用对象析构器的顺序.
意思是说:终止器是不确定的,不能依赖它.
不像构,d中类默认是引用类型,程序员无法直接访问底层类实例.未初化的实例默认为空针.一般用新分配.d中实例化类,一般由垃集管理,而其析构器作为终止器.看实验:

导入 标.标io;
类 不可预期
{
   整 数字;
   本(整 n)
  {
       写行(n,"构造器");
       数字=n;
  }
  ~本()
  {
       写行(数字,"析构器");
  }
}

空 主()
{
   不可预期 s0=新 不可预期(0);
  {
       不可预期 s1=新 不可预期(1);
  }
   不可预期 s2=新 不可预期(2);
}

我们会看见:

#0构造器
#1构造器
#2构造器
#0析构器
#1析构器
#2析构器

对简单程序可预测,但程序更复杂时,则无法预测.垃集可任何时候任何顺序调用析构器.即垃集在需要内存时,清理.不是长期运行,标记对象不可达调用析构器可能管用.在此范围内,可预测.但除此外,就说不准了.我们不知道请求分配时是否调用析构器,或按何顺序调用.不确定性影响了如何实现析构器.
对初学者,不要在垃集管理对象的析构器中采取可能的分配内存.如果这样做,会导致运行时的无效内存操作错误.
可能,即有些操作间接导致错误,如索引不存在键(区间错误),断定失败错误,调用未标记@无垃集函数.在垃集对象析构器中,应避免这些操作.
@无垃集函数中前7个禁止操作可以看看.
更大的问题是,你不能依赖垃集调用析构器时仍有效的资源.考虑析构器中关闭套接字句柄的类.很可能,关闭程序时,才会调用析构器.运行时捕捉不了.这样,导致安静失败/崩溃/关机等.
因而,不要用垃集管理对象的析构器来管理确定性资源.

设计析构

对d新手,析构器看起来没用,可从垃集/非垃集内存上分配构/类实例,而不保证运行垃集管理类对象的析构器.且终止时禁止垃集操作.我们如何依赖他们?
但,问题并不大.基本了解d析构器后,很容易避免问题,如果你遵守下面2个规则,则基本没问题.

假装不存在类析构器

一般用新分配类实例,即其析构器基本上是非确定性的.你析构器中想做的,一般依赖某种程序状态:期望状态(写入打开文件),或修改特定状态(释放资源句柄).
非确定析构,意味着不能有期望.可能已关闭文件,可能只有在结束程序前,才释放资源句柄.即使通过测试,运行时仍可能有问题,长期运行程序,更是某个时候会出现问题.游戏随机崩溃时,你就好好调试吧.在d中用类时,假定不存在析构器,就像java有个过时的终止器.

构有析构器时,不要在垃集堆上分配

我们假定类无析构器,假定只构需要析构器.在栈上按值分配构满足大部分需要.但有时要在堆上分配.这时,记住,不要用新来分配.这个构类似类了,要避免析构器.现在确定性的析构器变成非确定性的了.
我们可在非垃集堆上分配构实例,如用分配内存(malloc),然后在消灭函数中手动调用析构器.
如果要在堆上分配有析构器的构,则不能用新.
没有准则,叫你用类/构.个人更偏爱构.只有当构不能层次,无效时,用类.其他人会考虑是否需要标识.如演员,对比坐标.旧对象一般为构.其余看偏好.
前2准则为我及与其他人交谈的经验,当构建程序时,帮助你理解构/类差别.不是强制的.
如,混合垃集/手动管理内存.有的程序员就喜欢类.如果你的演员类,必须有个析构器,或你喜欢类,你如何避免在垃集堆中分配呢?