d重载操作符

原文

struct Struct
{
    void opOpAssign(string op)(Struct rhs)
//在此实现`/=`.
    {
        //...
    }
}
unittest
{
   Struct a = Struct(1);
   Struct b = Struct(2);
   a /= b;
   assert(a == Struct(5, 0, -1));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

单元测试,不管用.

但如下,通过测试:

struct S {
    int n;
    void opOpAssign(string op)(S rhs) if (op == "/") {
        n++;
    }
}

unittest {
    auto a = S(1), b = S(2);
    a /= b;
    b /= a;
    assert(a.n == 2);
    assert(b.n == 3);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

问题是,根据未调用opOpAssign,为什么?
可能:

struct S {
    int n;
    void opOpAssign(string op)(S rhs) if (op == "/=") {
        n++;
    }
    void opOpAssign(string op)(S rhs) if (op == "/") {
        // 闲着
    }
}

unittest {
    auto a = S(1), b = S(2);
    a /= b;
    b /= a;
    assert(a.n == 2);
    assert(b.n == 3);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

可用-vcg-ast,让编译器告诉你实际调用的是什么.

输出,用途不大:

unittest
{
    S a = S(1);
    S b = S(2);
    a.opOpAssign(b);
    b.opOpAssign(a);
    assert(a.n == 2);
    assert(b.n == 3);
}
1
2
3
4
5
6
7
8
9

最后,只有1个实例化:

opOpAssign!"/"
{
    pure nothrow @nogc @safe void opOpAssign(S rhs)
    {
    }

}
1
2
3
4
5
6
7

我希望包括模板参数!我相信它通常会?应该提交错误.应该提出增强请求:

void foo(string s, T)(T t) {}

void main()
{
   foo!"hi"(1);
}
//输出:

void foo(string s, T)(T t)
{
}
void main()
{
    foo(1);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

文档说:a op= b应重写为a.opOpAssign!("op")(b),这里没有=,只剩下有效调用.未用其他模板.
我意思是,-vcg-ast未告诉你它如何调用函数.
如果用了其他模板怎么办?
这是实例化foo两次并调用了它3次的代码中的AST,告诉我,谁调用了谁?

import object;
void foo(string s, T)(T t)
{
}
void main()
{
    foo(1);
    foo(1);
    foo(1);
    return 0;
}
mixin _d_cmain!(); // 为了简单,省略了.
foo!("hi", int)
{
    pure nothrow @nogc @safe void foo(int t)
    {
    }

}

foo!("bar", int)
{
    pure nothrow @nogc @safe void foo(int t)
    {
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

我用static if测试,假定是错的.