On Wednesday, 12 December 2012 at 08:23:48 UTC, Simen Kjaeraas
wrote:
On 2012-09-12 00:12, js.mdnq <[email protected]> wrote:
struct bbyte {
byte value;
...
}
bbyte a; bbyte b;
b = a + b; // uses bbyte's operators and casts to do the
computation and assignment but then returns a bbyte instead of
an int.
You should have no problems implicitly converting bbyte to
built in types or built in types to bbyte.
Not entirely true. Converting from bbyte to built-in works, but
these
are to my knowledge currently impossible:
void foo(bbyte b);
byte b;
foo(b); // No conversion.
bbyte bar( ) {
byte b;
return b;
}
What I mean is that you use bbyte for all your arithmetic
operations and computations. When you need to convert it to a
byte(hopefully at the end of the process), you can use an
implicit cast.
struct bbyte {
byte b;
byte opCast(bbyte a) { return a.b; }
alias b this;
bbyte bar(byte b) { bbyte q; q.b = b; return q; }
byte foo(bbyte b) { return b.b; }
}
byte bar2(byte b) { return b; }
int main(string[] argv)
{
bbyte bb;
byte b;
bb.foo(bb);
bb.bar(b);
b = bb;
bb = b;
}
the point is no explicit op casts are required. Essentially a
bbyte is a byte. One can overload all the operators that are
needed for bit manipulation, even using asm if necessary and one
should be able to hide most of the details. `alias this` might
not stop some of the value propagation in some cases. If one only
converts to the built-in types when actually needed(when passing
to and from routines that use them) but uses bbyte for all bit
manipulations it shouldn't be much of a problem(if at all).
The idea is that conversion from bbyte to byte does not induce an
expansion to int, only the arithmetic operations. Hence,
overriding them can stop that.
but something like
byte b1;
byte b2;
bbyte b3 = b1 + b2;
is computing the arithmetic operation from byte(which converts to
an int). This is why I say one must use bbytes for all arithmetic
operations to solve that problem. (or write a cast for int, if
you just don't want to deal with it but don't mind the expansion)
But this works:
byte b1;
byte b2;
bbyte b3;
b3 = b1 + b2;
if one has bbyte opAssign(int i) { this.b = cast(byte)i; return
this; } in bbyte.
which avoids having to do b3 = cast(byte)(b1 + b2) which I think
was what the original post was about.
