19用d编程转换

两种类型不同,当然不能一起操作,会出现编译错误.

从	到
bool	int
byte
ubyte
short
ushort
char
wchar
dchar	uint

类型提升,从低到高.没问题,不会出现

截断

.

int    a = 0;
    int    b = 1;
    size_t c = 0;
    writeln(a - b + c);  //最大整
           

因为没有-1的正整数.

切片也可指向

静态数组

import std.stdio;

void foo() {
    int[2] array = [ 1, 2 ];
    bar(array);//静态数组
}

void bar(int[] slice) {//切片
    writeln(slice);
}

void main() {
    foo();
}
           

不要返回局部切片,不然你返回的是个悬挂指针.

import std.stdio;

void foo() {
    int[2] array = [ 1, 2 ];
    bar(array);//静态数组

}  //在此外数组就释放了

int[] sliceForLaterUse;//全局

void bar(int[] slice) {//进来的切片参数可疑
    sliceForLaterUse = slice;//这里复制的是钥匙
//全局变量钥匙指向局部钥匙.
    writefln("钥匙内部: %s", sliceForLaterUse);
}

void main() {
    foo();
    writefln("全局钥匙: %s", sliceForLaterUse);
}
           

总感觉

d

把事情搞复杂了.不如

c++

.谁知道切片是个钥匙还是个实体啊,难道还要去猜,去动脑壳想?

按

生命期理论

.就是

大生命期

的钥匙/指针不能指向

小生命期

的

钥匙/指针

.否则就是崩溃之源.

char[] parenthesized(const char[] text) {
    return "{" ~ text ~ "}";
}

void main() {
    char[] greeting;
    greeting ~= "你好世界";
    parenthesized(greeting);
}
           

常转,

非常->常

.没问题.这是

加限制

char[] parenthesized(const char[] text) {
    char[] argument = text;//编译错误
    ...
}
           

常=>非常

,对不起,编译错误.上面的针对的是引用.

const int totalCorners = 4;
    int theCopy = totalCorners;
           

这是复制值,所以没问题.

string a = "你好";    // 不变
    char[] b = a;//编译错误
    string c = b;//编译错误
//仍然是针对引用类型.
    immutable a = 10;
    int b = a;// 编译,值类型
           

枚举类型

.枚可

直接

转成

整数

,参与运算.

int result = 10 + Suit.hearts;
    assert(result == 11);
  Suit suit = 2; //编译错误
           

极值

转换

int a = false;
    assert(a == 0);
    int b = true;
    assert(b == 1);
    bool a = 0;
    assert(!a);     // 假

    bool b = 1;//0,1可转换,其余不行
    assert(b);      // 真
    int i;
    // ...

    if (i) {    //
        // 非零

    } else {
        // ... i==0
    }
 int[] a;
    // ...

    if (a) {
    //非空针

    } else {
    //空针
    }
           

以下情况不会

自动

转换:

1,

宽->窄

2,

常->变

3,

不变

转换至

其他

4,

整至枚

.因为

枚

更限定.

如果是安全的,得

显式

构造符

std.conv.to

,

3,

std.exception.assumeUnique

4,

cast(...)

如:

int i;
    //DestinationType(value)
    // ...
    const result = double(i) / 2;
//类型(..)
    to!(DestinationType)(value)
//直接搞,犯错.
void main() {
    double d = -1.75;

    short s = d;     // 编译错误
    int i = "42";    // 编译错误
}
//这样就行了.
import std.conv;

void main() {
    double d = -1.75;

    short s = to!short(d);
    assert(s == -1);

    int i = to!int("42");
    assert(i == 42);
}
//也可转不变

    int[] slice = [ 10, 20, 30 ];
    auto immutableSlice = to!(immutable int[])(slice);//其实与`.idup`没啥区别.
//
    assert(&(slice[0]) != &(immutableSlice[0]));
//新实体了.
           

移动

变为

不变

void calculate(immutable int[] coordinates) {
    // ...
}

void main() {
    int[] numbers;
    numbers ~= 10;
    // ... 其他修改...
    numbers[0] = 42;

    calculate(numbers);    // 编译错误
}
//编译错误
import std.exception;
// ...
    auto immutableNumbers = assumeUnique(numbers);
    calculate(immutableNumbers);
    assert(numbers is null); 
           

这里的效果是,原来的

可变

变量被移动成

不变

的变量.

而原来的变量被置为

空针

了.

上面的

to

与

assumeUnique

都利用了

cast

cast(DestinationType)value

to不行的地方.

Suit suit = to!Suit(7);    //抛异常
    bool b = to!bool(2);       //
           

虽然可能不正确,这时由

程序员

保证

正确性

//可能不正确,但能够通过编译
    Suit suit = cast(Suit)7;
    bool b = cast(bool)2;
    assert(b);
           

void * v;
    // ...
    int * p = cast(int*)v;
           

size_t savedPointerValue = cast(size_t)p;
    // ...
    int * p2 = cast(int*)savedPointerValue;