d rebinding unchanged

原文

// Nullable,How to work better?技术上是`安全`的,但真不是.
module turducken;

import std.algorithm;
import std.datetime;

// 如何在`evil type`上,Unbind early,And then late binding
// Turducken是答案.

// 先,设置舞台,value type
struct S
{
    
    // There is an immutable value field that refers to immutable data
    immutable int[] i;

    // SysTime:Conflict with me in the past
    SysTime st;

    // 无默认
    @disable this();

    // violates its invariant.init
    bool properlyInitialized = false;

    invariant {
     assert(properlyInitialized); }

    // Overload copy assignment,Copy assignment can be prohibited.
    void opAssign(S) {
     assert(false); }

    // To confirm that each constructor call matches the destructor call,It counts references
    int *refs;

    this(int* refs)
    pure @safe @nogc
    {
    
        this.properlyInitialized = true;
        this.refs = refs;
        (*refs)++;
    }

    this(this)
    pure @safe @nogc
    {
     (*refs)++; }

    // Now that the destructor is defined,我们肯定会,determined to be broken`.init`.
    ~this()
    pure @safe @nogc
    in(refs)
    out(; *refs >= 0)
    do {
     (*refs)--; }
}

// 挑战!
//函数为:
pure // pure,
@safe // safe,
@nogc // 及nogc:
unittest
{
    
    // Dry late binding and early unbinding

    // 准备

    // (验证)
    int refs;

    // (欺骗)
    int* refsp = () @trusted {
     return &refs; }();

    {
    
        // Start with default initialization variables
        Turducken!S magic;
        // Bind to a constructed value
        magic.bind(S(refsp));

        // 只一份
        assert(refs == 1);

        // 为了开心,绑定它
        magic.bind(S(refsp));

        // There is still only one copy
        assert(refs == 1);

        // The included values ​​are all OK
        assert(magic.value.properlyInitialized);

        // Unbind before the domain ends
        magic.unbind;

        // S离开了
        assert(refs == 0);
    }
    // 只析构一次,正确.
    assert(refs == 0);
}

// 如何完成
// Turducken!
struct Turducken(T)
{
    
    // Tasty center
    alias Chicken = T;

    //UnionMake sure not to callT析构函数
    union Duck
    {
    
        Chicken chicken; // 
    }

    //确保可用moveEmplaceand magical(against the norm)的memcpy的构
    struct Turkey
    {
    
        Duck duck;
    }

    Turkey store = Turkey.init; // Turkey shop

    bool set = false;

    // 插入吸管,进入中心
    @property ref T value() in(set) {
     return store.duck.chicken; }

    // Special sauce
    void bind(T value)
    {
    
        // Just come back in a few seconds,清理
        unbind;

        //Make a destructor-protected copy to paste in our store
        Turkey wrapper = Turkey(Duck(value));

        // Ignore often,遍历数据.
        () @trusted {
     moveEmplace(wrapper, store); }();

        set = true;
    }

    // 调味品
    void unbind()
    {
    
        if (set)
        {
    
            static if (is(T == struct)) {
    
                destroy(value);
            }
            set = false;
        }
    }

    // Because the value has been avoidedD的监视,
    // 必须手动清理
    ~this()
    {
    
        unbind;
    }
}

这就是火鸡技术!