構造体、共用体

struct S
{
    int i;
}

void main()
{
    S a;
    a.i = 3;

    S b = a; // aをコピーする
    a.i++;
    assert(a.i == 4);
    assert(b.i == 3);
}

union U
{
    ubyte i;
    char c;
}

void main()
{
    U u;
    u.i = 3;
    assert(u.c == '\x03');
    u.c++;
    assert(u.i == 4);
}

struct S
{
    S* ptr;     // OK
    S[] slice;  // OK

    S s;        // エラー
    S[2] array; // エラー

    static S global; // OK
}

struct S;
S.sizeof; // エラー、サイズがわからない
S s;      // エラー、未知のコンテンツを初期化できない
S* p;     // OK、メンバーに関する知識は必要ない

struct S { int a = 4; int b; }
S x; // x.aは4、x.bは0に設定される

struct S { int a, b, c, d = 7; }

S r;                          // r.a = 0, r.b = 0, r.c = 0, r.d = 7
S s = { a:1, b:2 };           // s.a = 1, s.b = 2, s.c = 0, s.d = 7
S t = { c:4, b:5, a:2, d:5 }; // t.a = 2, t.b = 5, t.c = 4, t.d = 5
S u = { 1, 2 };               // u.a = 1, u.b = 2, u.c = 0, u.d = 7
S v = { 1, d:3 };             // v.a = 1, v.b = 0, v.c = 0, v.d = 3
S w = { b:1, 3 };             // w.a = 0, w.b = 1, w.c = 3, w.d = 7

S x = { 1, a:2 };  // エラー: フィールド`a`のイニシャライザーが重複している

union U { int a = 4; long b; }
U x; // x.aは4に設定され、x.bは実装で定義された値に設定される

union V { int a; long b = 4; }     // エラー: デフォルトの初期化値`4`を持つ共用体のフィールド`b`はフィールド`a`の前になければならない
union W { int a = 4; long b = 5; } // エラー: `a`と`b`のデフォルト初期化が重複している

union U { int a; double b; }
U u = { 2 };       // u.a = 2
U v = { b : 5.0 }; // v.b = 5.0

U w = { 2, 3 };    // エラー: フィールド`a`と`b`の重複初期化

struct S { int a, b, c, d = 7; }

void test(int i)
{
    S q = { 1, b:i }; // q.a = 1, q.b = i, q.c = 0, q.d = 7
}

struct S { int a; }
S t;      // デフォルトで初期化される
t.a = 3;
S s = t;  // s.aは3に設定されている

struct S
{
    int a;

    this(int v)
    {
        this.a = v;
    }
}

S s = 3; // Sのコンストラクタを使ってs.aを3に設定する

struct S
{
    int a;

    static S opCall(int v)
    {
        S s;
        s.a = v;
        return s;
    }

    static S opCall(S v)
    {
        assert(0);
    }
}

S s = 3; // S.opCall(int)を使ってs.aを3に設定する
S t = s; // t.aを3に設定、S.opCall(S)は呼び出されない

union U { int a; double b; }

void test(int i)
{
    U u = { a : i };   // u.a = i
    U v = { b : 5.0 }; // v.b = 5.0
}

struct S { int x; float y; }

S s1 = S(1, 2); // フィールドxを1、フィールドyを2に設定する
S s2 = S(y: 2, x: 1); // 上記と同じ
assert(s1 == s2);

struct S { int x = 1, y = 2, z = 3; }

S s0 = S(y: 5, 6, x: 4); // フィールド`z`には`6`が代入され、これは`y`の後に来る
assert(s0.z == 6);

S s1 = S(y: 5, z: 6);    // フィールドxは割り当てられず、デフォルトのイニシャライザー`1`に設定される
assert(s1.x == 1);

//S s2 = S(y: 5, x: 4, 5); // エラー: フィールド`y`が2回代入されている
//S s3 = S(z: 2, 3);       // エラー: フィールド`z`以上にフィールドがない

union U
{
    byte a;
    char[2] b;
}

U u = U(2);
assert(u.a == 2);
assert(u.b == [2, 0]);

struct S
{
    int a;
    union
    {
        byte b;
        char c;
    }
}

S s = S(1, 2);
assert(s.a == 1);
assert(s.b == 2);
assert(s.c == 2); // `b`と重複する

union U
{
    int a;
    struct
    {
        uint b;
        bool c;
    }
}

U u = U(1);
assert(u.a == 1);
assert(u.b == 1); // `a`と重複する
assert(u.c == false); // 重なっていない

const struct S { int a; int b = 2; }
void main()
{
    S s = S(3); // s.aを3に初期化する
    S t;        // t.aを0に初期化する
    t = s;      // エラー、t.aとt.bはconstなので変更できない。
    t.a = 4;    // エラー、t.aはconstである
}

struct S
{
    int x, y = 4, z = 6;
    this(int a, int b)
    {
        x = a;
        y = b;
    }
}

void main()
{
    S a = S(4, 5); // S.this(4, 5)を呼び出す:  a.x = 4, a.y = 5, a.z = 6
    S b = S();  // デフォルトの初期化:    b.x = 0, b.y = 4, b.z = 6
    S c = S(1); // エラー、this(int)が見つからない
}

struct S
{
    int x;
    int y;
    this(int y, int z) { this.x = y; this.y = z; }
}
S a = S(x: 3, y: 4); // エラー: コンストラクタに`x`というパラメータがない
S b = S(y: 3, 4); // `y: 3`はパラメータ`y`を通してフィールド`x`を設定する

struct S
{
    int x;
    this() { } // エラー、struct default constructor not allowed
}

struct S
{
    int j = 1;
    long k = 2;
    this(long k)
    {
        this.k = k;
    }
    this(int i)
    {
        // この時点で: j=1, k=2
        this(6); // コンストラクタ呼び出しの委譲
        // この時点で: j=1, k=6
        j = i;
        // この時点で: j=i, k=6
    }
}

struct S1
{
    int[] a;
    this(int n) { a = new int[](n); }
}
struct S2
{
    int[] a;
    this(int n) immutable { a = new int[](n); }
}
void main()
{
    // ミュータブル・コンストラクタはミュータブル・オブジェクトを生成する。
    S1 m1 = S1(1);

    // 構築されたミュータブル・オブジェクトは暗黙のうちにconstに変換可能である。
    const S1 c1 = S1(1);

    // 構築されたミュータブル・オブジェクトは暗黙のうちにイミュータブルに変換できない。
    immutable i1 = S1(1); // エラー

    // ミュータブル・コンストラクタはイミュータブル・オブジェクトを構築できない。
    auto x1 = immutable S1(1); // エラー


    // イミュータブル・コンストラクタがイミュータブル・オブジェクトを生成する。
    immutable i2 = immutable S2(1);

    // イミュータブル・コンストラクタはミュータブル・オブジェクトを構築できない。
    auto x2 = S2(1); // エラー

    // 構築されたイミュータブル・オブジェクトは暗黙的にミュータブルに変換できない。
    S2 m2 = immutable S2(1); // エラー

    // 構築された不変のオブジェクトは暗黙のうちにconstに変換される。
    const S2 c2 = immutable S2(1);
}

struct S
{
    this(int);           // 共有でないミュータブル・コンストラクタ
    this(int) shared;    // 共有ミュータブル・コンストラクタ
    this(int) immutable; // 不変のコンストラクタ
}

void fun()
{
    S m = S(1);
    shared s = shared S(2);
    immutable i = immutable S(3);
}

struct S
{
    this(int) pure;
    // 定義に基づいて、これはミュータブル・オブジェクトを生成する。しかし、
    // 生成されたオブジェクトは、変更可能なグローバル・データを含むことはできない。
    // したがって、生成されるオブジェクトは一意である。

    this(int[] arr) immutable pure;
    // 定義に基づけば、これは不変のオブジェクトを生成する。しかし、
    // 引数int[]は生成されたオブジェクトには現れないので、
    // 暗黙のうちにイミュータブルに変換されることはない。また、不変の
    // グローバル・データを格納することもできない。
    // したがって、生成されるオブジェクトは一意である。
}

void fun()
{
    immutable i = immutable S(1); // this(int) pureが呼ばれる
    shared s = shared S(1);       // this(int) pureが呼ばれる
    S m = S([1,2,3]);             // this(int[]) immutable pureが呼ばれる
}

struct S
{
    int x;

    // デフォルトの構築を無効にする
    @disable this();

    this(int v) { x = v; }
}
struct T
{
    int y;
    S s;
}
void main()
{
    S s;          // エラー: デフォルトの構築は無効になっている
    S t = S();    // エラー: also disabled
    S u = S(1);   // `S.this(1)`を呼び出して構築する
    S v = void;   // 初期化されないが、許可される
    S w = { 1 };  // エラー: コンストラクタが存在するので{ }は使えない
    S[3] a;       // エラー: デフォルトのコンストラクタは無効になっている
    S[3] b = [S(1), S(20), S(-2)]; // OK
    T t;          // エラー: デフォルトのコンストラクタは無効になっている
}

struct S
{
    int num;
    int ber;
    this(int i)
    {
        num = i + 1;   // 初期化
        num = i + 2;   // 代入
        ber = ber + 1; // 初期化の前に読み込めばOK
    }
    this(int i, int j)
    {
        this(i);
        num = i + 1;  // 代入
    }
}

struct A
{
    this(int n) {}
    void opAssign(A rhs) {}
}
struct S
{
    A val;
    this(int i)
    {
        val = A(i);  // valはA(i)の値に初期化される
        val = A(2);  // val.opAssign(A(2))に書き換えられる
    }
}

struct S
{
    immutable int num;
    this(int)
    {
        num = 1;  // OK
        num = 2;  // エラー: 不変への代入
    }
}

struct S
{
    immutable int num;
    immutable int ber;
    this(int i)
    {
        if (i)
            num = 3;   // 初期化
        else
            num = 4;   // 初期化
    }
    this(long j)
    {
        j ? (num = 3) : (num = 4); // OK
        j || (ber = 3);  // エラー: 1つのパスのみで初期化された
        j && (ber = 3);  // エラー: 1つのパスのみで初期化された
    }
}

struct S
{
    immutable int num;
    immutable string str;
    this(int j)
    {
        foreach (i; 0..j)
        {
            num = 1;    // エラー: フィールドの初期化はループでは許可されない
        }
        size_t i = 0;
    Label:
        str = "hello";  // エラー: フィールドの初期化はラベルの後では許可されない
        if (i++ < 2)
            goto Label;
    }
    this(int j, int k)
    {
        switch (j)
        {
            case 1: ++j; break;
            default: break;
        }
        num = j;        // エラー: `case`と`default`もラベルである
    }
}

struct S { int y; @disable this(); }

struct T
{
    S s;
    this(S t) { s = t; }       // OK
    this(int i) { this('c'); } // OK
    this(char) { }             // エラー: sが初期化されていない
}

struct A
{
    int[] a;
    this(ref return scope A rhs) {}
}

void fun(immutable A) {}

void main()
{
    immutable A a;
    fun(a);        // エラー: コピーコンストラクタは、(immutable) immutable型で呼び出すことはできない
}

struct A
{
    @disable this(ref A);
}

void main()
{
    A a;
    A b = a; // エラー: コピーコンストラクタは無効である
}

struct S
{
    this(ref S);
}

union U
{
    S s;
}

void main()
{
    U a;
    U b = a; // エラー、Uのコピーコンストラクタを生成できなかった
}

struct A
{
    this(ref return scope A another) {}                        // 1 - ソースがミュータブル、デスティネーションがミュータブル
    this(ref return scope immutable A another) {}              // 2 - ソースがイミュータブル、デスティネーションがミュータブル
    this(ref return scope A another) immutable {}              // 3 - ソースがミュータブル、デスティネーションが不変
    this(ref return scope immutable A another) immutable {}    // 4 - ソースが不変、デスティネーションが不変
}

void main()
{
    A a;
    immutable A ia;

    A a2 = a;      // 1を呼び出す
    A a3 = ia;     // 2を呼び出す
    immutable A a4 = a;     // 3を呼び出す
    immutable A a5 = ia;    // 4を呼び出す
}

struct A
{
    this(ref return scope inout A rhs) immutable {}
}

void main()
{
    A r1;
    const(A) r2;
    immutable(A) r3;

    // `inout`がワイルドカードのように働くので、すべて同じコピーコンストラクタを呼び出す
    immutable(A) a = r1;
    immutable(A) b = r2;
    immutable(A) c = r3;
}

struct S
{
    int[] a;    // 配列はこのインスタンスによって私有される
    this(this)
    {
        a = a.dup;
    }
}

struct T
{
    @disable this(this);  // 無効にするとTはコピーできなくなる
}
struct S
{
    T t;   // コピー不可能なメンバはSもコピー不可能にする
}

void main()
{
    S s;
    S t = s; // エラー、Sはコピー可能ではない
}

// エイリアス__xpostblit = __postblitを持つ構造体
struct X
{
    this(this) {}
}

// X.__xpostblitへの呼び出しを含む
// エイリアス__xpostblit = __fieldPostblitを持つ構造体
struct Y
{
    X a;
}

// エイリアス__xpostblit = __aggrPostblitを持つ構造体で、
// Y.__xpostblitへのコールと Z.__postblitへのコールを含む
struct Z
{
    Y a;
    this(this) {}
}

void main()
{
    // Xは__postblitと__xpostblitを持っている(__postblitを指している)
    static assert(__traits(hasMember, X, "__postblit"));
    static assert(__traits(hasMember, X, "__xpostblit"));

    // Yは__postblitを持っていないが、__xpostblit(__fieldPostblitを指す)を持っている
    static assert(!__traits(hasMember, Y, "__postblit"));
    static assert(__traits(hasMember, Y, "__xpostblit"));
    // __fieldPostblitは構造体のメンバではない
    static assert(!__traits(hasMember, Y, "__fieldPostblit"));

    // Zは__postblitと__xpostblitを持つ(__aggrPostblitを指す)
    static assert(__traits(hasMember, Z, "__postblit"));
    static assert(__traits(hasMember, Z, "__xpostblit"));
    // __aggrPostblitは構造体のメンバではない
    static assert(!__traits(hasMember, Z, "__aggrPostblit"));
}

struct X
{}

int a;

struct Y
{
    int a;
    X b;
    void __fieldPostPostblit()
    {
        a = 42;
    }
}

void main()
{
    static assert(!__traits(hasMember, X, "__postblit"));
    static assert(!__traits(hasMember, X, "__xpostblit"));

    static assert(!__traits(hasMember, Y, "__postblit"));
    static assert(!__traits(hasMember, Y, "__xpostblit"));

    Y y;
    auto y2 = y;
    assert(a == 0); // __fieldPostBlitが呼び出されない
}

struct X
{
    this(this) {}
    this(this) const {} // エラー: 関数X.__postblitが関数X.__postblitと衝突する
}

struct S
{
    int n;
    this(this) { ++n; }
}

void main()
{
    immutable S a;      // shared S a; => エラー : 共有でないメソッドは共有オブジェクトを使用して呼び出すことができない
    auto a2 = a;
    import std.stdio: writeln;
    writeln(a2.n);     // 1を表示
}

struct S
{
    this(this)
    { }
}

// `__xpostblit`集約ポストブリットのエイリアスなので、`const`が適用される。
// しかし、集約されたpostblitは修飾子が適用されていないフィールド
// postblitを呼び出すため、修飾子の不一致エラーが発生する
const struct B
{
    S a;        // エラー : 変更可能なメソッドB.__fieldPostblitは、constオブジェクトを使用して呼び出すことはできない
    this(this)
    { }
}

// `__xpostblit`はフィールドpostblitをエイリアスする; エラーなし
const struct B2
{
    S a;
}

// Bと似ている
immutable struct C
{
    S a;        // エラー : 変更可能なメソッドC.__fieldPostblitは、不変のオブジェクトを使用して呼び出すことはできない
    this(this)
    { }
}

// B2と同様、コンパイルされる
immutable struct C2
{
    S a;
}

shared struct A
{
    this(this)
    {
        import std.stdio : writeln;
        writeln("the shared postblit was called");
    }
}

struct B
{
    A a;
}

void main()
{
    shared B b1;
    auto b2 = b1;
}

struct S
{
    int count;
    this(this)
    {
        ++count;
    }
}

union U
{
    S s;
}

void main()
{
    U a = U.init;
    U b = a;
    assert(b.s.count == 0);
    b.s.__postblit;
    assert(b.s.count == 1);
}

struct S
{
    int i;

    ~this()
    {
        import std.stdio;
        writeln("S(", i, ") is being destructed");
    }
}

void main()
{
    auto s1 = S(1);
    {
        auto s2 = S(2);
        // s2デストラクタが呼ばれた
    }
    S(3); // s3デストラクタが呼ばれた
    // s1デストラクタが呼ばれた
}

struct S
{
    char c;

    ~this()
    {
        import std.stdio;
        writeln("S(", c, ") is being destructed");
    }
}

struct Q
{
    S a;
    S b;
}

void main()
{
    Q q = Q(S('a'), S('b'));
    S[2] arr = [S('0'), S('1')];
    // arr[1]、arr[0]、q.b、q.aに対してデストラクタが呼び出された
}

struct S
{
    ~this()
    {
        import std.stdio;
        writeln("S is being destructed");
    }
}

union U
{
    S s;
}

void main()
{
    import std.stdio;
    {
        writeln("entering first scope");
        U u = U.init;
        scope (exit) writeln("exiting first scope");
    }
    {
        writeln("entering second scope");
        U u = U.init;
        scope (exit)
        {
            writeln("exiting second scope");
            destroy(u.s);
        }
    }
}

struct Date
{
    this(int d, int h)
    {
        day = d;    // 日数は1..31
        hour = h;   // 時間は0..23
    }

    invariant
    {
        assert(1 <= day && day <= 31);
        assert(0 <= hour && hour < 24);
    }

  private:
    int day;
    int hour;
}

struct Foo
{
    public void f() { }
    private void g() { }

    invariant
    {
        f();  // エラー、invariantからパブリック・メンバ関数を呼び出すことはできない
        g();  // OK、g()はpublicではない
    }
}

struct S
{
    int[] buf;
    int a;

    ref S opAssign(ref const S s) return
    {
        a = s.a;
        return this;
    }

    this(this)
    {
        buf = buf.dup;
    }
}

struct S
{
    int x;
    alias x this;
}

int foo(int i) { return i * 2; }

void main()
{
    S s;
    s.x = 7;
    int i = -s;
    assert(i == -7);
    i = s + 8;
    assert(i == 15);
    i = s + s;
    assert(i == 14);
    i = 9 + s;
    assert(i == 16);
    i = foo(s);  // intへの暗黙の変換
    assert(i == 14);
}

class Foo
{
    int baz = 4;
    int get() { return 7; }
}

struct Bar
{
    Foo foo;
    alias foo this;
}

void main()
{
    Bar bar = Bar(new Foo());
    int i = bar.baz;
    assert(i == 4);
    i = bar.get();
    assert(i == 7);
}

struct S
{
    int x;
    @property int get()
    {
        return x * 2;
    }
    alias get this;
}

void main()
{
    S s;
    s.x = 2;
    int i = s;
    assert(i == 4);
}

struct S
{
    int a;
    bool opEquals(S rhs) const
    {
        return this.a == rhs.a;
    }
}

struct T
{
    int b;
    S s;
    alias s this;
}

void main()
{
    S s1, s2;
    T t1, t2;

    assert(s1 == s2);      // S.opEqualsを呼び出す
    assert(t1 == t2);      // メンバ単位の等式を実装するコンパイラが生成したT.opEqualsを呼び出す

    assert(s1 == t1);      // s1.opEquals(t1.s);を呼び出す
    assert(t1 == s1);      // t1.s.opEquals(s1);を呼び出す
}

struct U
{
    int a;
    bool opCmp(U rhs) const
    {
        return this.a < rhs.a;
    }
}

struct V
{
    int b;
    U u;
    alias u this;
}

void main()
{
    U u1, u2;
    V v1, v2;

    assert(!(u1 < u2));    // U.opCmpを呼び出す
    assert(!(v1 < v2));    // U.opCmpを呼び出す。VはopCmpメソッドを定義していないため、
                           // v1のエイリアスのthisが使用され; U.opCmpは
                           // U型のパラメータを期待するため、v2のエイリアスのthisが使用される

    assert(!(u1 < v1));    // u1.opCmp(v1.u);を呼び出す
    assert(!(v1 < u1));    // v1.u.opCmp(v1);を呼び出す
}

void foo()
{
    int i = 7;
    struct SS
    {
        int x,y;
        int bar() { return x + i + 1; }
    }
    SS s;
    s.x = 3;
    s.bar(); // 11を返す
}

void foo()
{
    int i = 7;
    static struct SS
    {
        int x, y;
        int bar()
        {
            return i; // エラー、SSは入れ子構造体ではない
        }
    }
}