Merhaba,

Bugün kendimce, D'nin tüm olanakları (belki de değil...:)) kullanıldığında nasıl karmaşık yapıların üstesinden gelinebildiğini deneyimlemek istedim. İnsanın ilk aklına doğal olarak matrisler geliyor. Ayrıca şu sıralar çalıştığım konu bitler olunca aşağıdaki gibi basit bir şey çıktı:

Alıntı ("testcode.d"):

> import std.stdio, dersler.advancedstructs;
> // dmd derstest dersler/advancedstructs -unittest
>
> void main() {
>   //auto test = byteX!(ubyte, 3).LOW;/* <-- bitXb72.LOW'a eşit
>   auto test = bitXs64.HIGH;//*/
>
>   with(test.satır[0]) {
>     a.writeln("<-- HIGH ile kurulmuştu...");
>     a = 153;
>     writefln("%b BIN 153'e eşitlendi!", a);
>   }
>
>   test.satır[1].b = 35;
>
>   "==========================".writeln;
>   foreach(s; test.satır) {
>     foreach(d; s.data) d.write("\t");
>     writeln;
>   }
>   "==========================".writeln;
> }/*
> 65535<-- HIGH ile kurulmuştu...
> 10011001 BIN 153'e eşitlendi!
> ==========================
> 153      65535  (1.satır)
> 65535    35     (2.satır)
> ==========================
> */
> ```

>
**Not:** Karmaşık gibi göründüğüne bakmayın, açıklayacağım. O yüzden ilk olarak, alias ile modül içinde tanımlanmış takma ismi bir değişkene eşitlemek kadar, kullanmanın kolay olduğu örneğe yer verdim...:)

İşte o modül:

module dersler.advancedstructs;

alias byteX!(ubyte, 2) bitXb32;
alias byteX!(ushort, 2) bitXs64;
alias byteX!(ubyte, 3) bitXb72;
alias byteX!(ubyte, 4) bitX1b28;

alias byteX!(ushort, 3) bitXs144;
alias byteX!(ushort, 4) bitXs256;

alias byteX!(uint, 3) bitXi288;
alias byteX!(uint, 4) bitXi512;

alias byteX!(ulong, 3) bitXl576;
alias byteX!(ulong, 4) bitXl1Kb;

struct byteX(T, size_t adet)
if( ( adet >= 2 ) && ( adet <= 4 ) )
{
static enum size_t boyut = adet * adet;

private alias bitX!(T, adet) Veri;

union {
T hücreler[boyut];
Veri satır[adet];
}

static if( adet == 2 ) { // 2 x 2
public static enum byteX!(T, adet) LOW = byteX!(T, adet)(
[T.min, T.min,
T.min, T.min]);

public static enum byteX!(T, adet) HIGH = byteX!(T, adet)(
[T.max, T.max,
T.max, T.max]);
}
static if( adet == 3 ) { // 3 x 3
public static enum byteX!(T, adet) LOW = byteX!(T, adet)(
[T.min, T.min, T.min,
T.min, T.min, T.min,
T.min, T.min, T.min]);

public static enum byteX!(T, adet) HIGH = byteX!(T, adet)(
[T.max, T.max, T.max,
T.max, T.max, T.max,
T.max, T.max, T.max]);
}
static if( adet == 4 ) { // 4 x 4
public static enum byteX!(T, adet) LOW = byteX!(T, adet)(
[T.min, T.min, T.min, T.min,
T.min, T.min, T.min, T.min,
T.min, T.min, T.min, T.min,
T.min, T.min, T.min, T.min]);

public static enum byteX!(T, adet) HIGH = byteX!(T, adet)(
[T.max, T.max, T.max, T.max,
T.max, T.max, T.max, T.max,
T.max, T.max, T.max, T.max,
T.max, T.max, T.max, T.max]);
}
}

/* Samples:

• (ubyte, 2) => 16 bits
• (ubyte, 3) => 24 bits
• (ubyte, 4) => 32 bits
  */

struct bitX(T, size_t adet) {
union {
T data[adet];
struct {
static if(adet >= 1) T a;
static if(adet >= 2) T b;
static if(adet >= 3) T c;
static if(adet >= 4) T d;
}
}
}

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]