02 変数と型

///src.d
import std.stdio;

void main()
{
    int a = 1 + 2;
    writeln(a);

    a = 3 + 1;
    writeln(a);

    a = a + 2;
    writeln(a);
}

$ rdmd src.d
3
4
6

int a = 12,
    b = a + 1,
    c = a + b,
    d;

import std.stdio;

// ここはグローバルスコープ

int a = 0;

void main()
{
    // ここはmain関数のスコープ

    double a = 1;       // グローバルなシンボルを上書きすることは可能

    writeln(a);         // 1; このスコープのa
    writeln(.a);        // 0; グローバルなa

    {
        //ここはmainより1つ内側のスコープ

        //string a;     // グローバルでないシンボルを上書きすることはできない
        string b = "foo";

        writeln(a);     // 1
        writeln(.a);    // 0
        writeln(b);     // foo

        // string型のbの寿命はここまで
    }

    {
        //writeln(b);   // このスコープから、上のスコープのbを見ることはできない
    }

    //writeln(b);       // 外側のスコープから、内側のbは見れない
    uint b;             // 内側のbは見えないから、bをシンボルとして定義してもよい

    foo();              // グローバルスコープにあるシンボルは、ソースコードで下にあっても使える
    writeln(bar);       // 同上

    // double型のaやuint型のbの寿命はここまで
}


int bar = 12;


void foo()
{
    //writeln(b);       // 0; main関数のuint型のbも、string型のbも見えない
}

int a;

a = 12;         // OK

(a + 3) = 4;    // NG

int a;
writeln(a);         // 0; intのデフォルト初期化値は 0

writeln(int.init);  // Type.init でデフォルト初期化値を取得できる

int b = void;       // 初期化を阻止
writeln(b);         // 何が表示されるかわからない

* void      : 値(または型)なし。

* bool      : 真偽値(`true`, `false`)

bool b;

writeln(b); // false
b = !b;
writeln(b); // true

b = true;
writeln(b); // true

b = false;
writeln(b); // false

* byte      :  8bitの符号あり(signed)な整数
* ubyte     :  8bitの符号なし(unsigned)な整数
* short     : 16bitの符号あり整数
* ushort    : 16bitの符号なし整数
* int       : 32bitの符号あり整数
* uint      : 32bitの符号なし整数
* long      : 64bitの符号あり整数
* ulong     : 64bitの符号なし整数
* cent      : 128bitの符号あり整数(将来のために名前だけ付けられてる)
* ucent     : 128bitの符号なし整数(将来のために名前だけ付けられてる)

* size_t    : ポインタ値が十分に入る大きさの符号なし整数型
              32bit環境だと32bit(uint), 64bit環境だと64bit(ulong)

* ptrdiff_t : size_tと同じ大きさの符号あり整数型

int a;

writeln(a);             // 0

ulong b = -1;

writeln(b);             // 18446744073709551615
                        // -1 は int型 だが、int -> long -> ulongと暗黙に変換される。
                        // longからulongへの変換によってこのようになる。

writeln(1uL - 2uL);     // 18446744073709551615
                        // 1uL は ulong型の1なので、
                        // 上のbと同様に負の数を表せず、このようになる。

writeln(1u);            // 数値の後ろに u とつけると uint型
writeln(1U);            // 大文字で U とつけても同じ

writeln(1L);            // 大文字の L をつければ long型

writeln(1uL);           // uL や、UL は ulong型

()の中の3つの数字は、(符号部bit数, 指数部bit数, 仮数部bit数)
* float     : 32bitの浮動小数点の実数(1, 8, 23)
* double    : 64bitの浮動小数点の実数(1, 11, 52)
* real      : 64bit以上(システムによって違う)の浮動小数点の実数

float  f = 1.0f;        // 数値の後に f をつければ float型
double d = 1.0;         // 少数点のある数値は double型
real   r = 1.0L;        // 少数点があり、最後に L が付いていると real型

writeln(f / 0);         // inf
writeln(0.0 / 0.0);     // -nan

* ifloat    : 32bitの浮動小数点の虚数
* idouble   : 64bitの浮動小数点の虚数
* ireal     : 64bit以上(システムによって違う)の浮動小数点の虚数

ifloat f = 1.0fi;       //  i を末尾につければ虚数型

* cfloat    : 32bitの浮動小数点の複素数, 64bit
* cdouble   : 64bitの浮動小数点の複素数, 128bit
* creal     : 64bit以上(システムによって違う)の浮動小数点の複素数(64bit以上 * 2の大きさ)

* char      : UTF-8でエンコードされた文字(8bit)
* wchar     : UTF-16でエンコードされた文字(16bit)
* dchar     : UTF-32でエンコードされた文字(32bit)

* string    : 文字列型(immutable(char)[])
* wstring   : 文字列型(immutable(wchar)[])
* dstring   : 文字列型(immutable(dchar)[])

//import std.utf;       追加でこの2つをimportする
//import std.range;

string  utf8  = "ほげほげ";
wstring utf16 = "ほげほげ"w;
dstring utf32 = "ほげほげ"d;

writeln(utf8);                                  // ほげほげ
writeln(utf16);                                 // ほげほげ
writeln(utf32);                                 // ほげほげ

writeln( utf8[std.utf.stride( utf8, 0) .. $]);  // げほげ
writeln(utf16[std.utf.stride(utf16, 0) .. $]);  // げほげ
writeln(utf32[1 .. $]);                         // げほげ

writeln(std.range.drop( utf8, 2));              // ほげ
writeln(std.range.drop(utf16, 2));              // ほげ
writeln(std.range.drop(utf32, 2));              // ほげ

* T*        : T型に対するポインタ型(Pointer)
* T[]       : T型を要素とするスライス(Slice)(動的配列; Dynamic Array)
* T[N]      : T型を連続してN要素集めた型。静的配列(Static Array)
* V[K]      : K型の値に対してV型の値が1:1で対応する型。連想配列(Associative Array)
* R function(T...)
            : T...型を受け取ってR型の値を返す関数ポインタ型
* R delegate(T...)
            : T...型を受け取ってR型の値を返すデリゲート(委譲)型

* enum      : 列挙型
* struct    : 構造体
* union     : 共用体
* class     : クラス
* interface : インターフェース

void main()
{
    int a;
    const(int*) p = &a;     // すべての型はconstに暗黙変換可能

    //*p += 3;              // Error: cannot modify const expression *p
                            // constは推移的なので、*pはconst(int)型
                            // constなデータは書き換え不可なのでエラーがでる

    int* q = &a;            // constでないポインタ
    *q = 13;                // 書き換え可能

    const(int*) cq = q;     // 非const型からconst型へは暗黙変換可能
    //q = p;                // 逆は不可能
}

int a;
//immutable(int)* p = &a;   //Error: cannot implicitly convert expression (& a) of type int* to immutable(int)*
                            // &aはint*なのでimmutable型へは暗黙変換不可

immutable(int) b;

immutable(int*) p = &b;     // OK
                            // immutable(int)*からimmutable(int*)への暗黙変換は可能

immutable(int)* r = &b;
//*r += 3;                  // Error: cannot modify immutable expression *r
                            // immutable型は変更不可能

immutable(immutable(T))     ->      immutable(T)
immutable(const(T))         ->      immutable(T)
const(immutable(T))         ->      immutable(T)
const(const(T))             ->      const(T)

immutable(immutable(T)*)    ->      immutable(T*)
immutable(const(T)*)        ->      immutable(T*)
const(immutable(T)*)        ->      変化しない
const(const(T)*)            ->      const(T*)

int a;

//shared(int)* p = &a;      // Error: cannot implicitly convert expression (& a) of type int* to shared(int)*
shared(int)* q = cast(shared)&a;

const int a = 12;       // const(int) a = 12;と書くのと等しい

immutable int a = 12;   // immutable(int) a = 12;と等しい

shared int a = 12;

class Foo{ this(){}; }

scope foo = new Foo();  // スタックへ割り当てられる
                        // スコープを抜けると同時に破棄される

// クラスに対するscopeは、そのうち「非推奨な機能」となるためstd.typecons.Scopedを使うとよい
import std.typecons;
auto bar = scoped!Foo();

auto a = 12;
pragma(msg, typeof(a)); // int

auto b = "ほげほげ";
pragma(msg, typeof(b)); // string

auto c = a + 13.5;
pragma(msg, typeof(c)); // double

const d = 3;
pragma(msg, typeof(d)); // const(int)

immutable e = 4;        // 記憶域クラスのみでも型推論される
pragma(msg, typeof(e)); // immutable(int)

void main()
{
    intt a;         // intでないのに注意
}