Merhaba,

Önceki başlıktan devam...

D'de kolaylık olsun diye gerek binary (0b000_1111: bu kalkabilir!), gerekse hexadecima(0x0000_FFFF: bunu konuşcaz) hazır değerler (literal) kullanabiliyoruz. Hatta daha ileri gidip bellek tahsis etmeden, (belki katma ve şablonlarınızda kullanmak üzere) string karşılığını üretmek mümkün:

  import core.internal.string;
  char[20] buf;

  auto neBu = 123456789.unsignedToTempString(buf[]);
  assert(neBu == "123456789");
  assert(is(typeof(neBu) == char[]));
  assert(neBu.length == 9);

  auto aynısı = 0x075bcd15.unsignedToTempString(buf[]);
  assert(neBu == aynısı);
  assert(0x075bcd15 == 123456789);

Sayı tabanını unsignedToTempString!16 şeklinde değiştirip farklı sonuçlar almak da mümkün. Başka örnekler için buraya bakabilrsiniz:

https://github.com/dlang/dmd/blob/master/druntime/src/core/internal/string.d

Konumuz dışı ama D hakkında soru işaret kalmasın. Octal sayılar ise karışıklık olabileceği için std.conv.octal'daki şablonu şu şekilde üzerine bastırarak kullanılıyor:

  import std.conv : octal;
  assert(octal!100 == 0x40);

Dip Not: Başlıktaki -literal için "hazır bilgi" gibi bir Türkçe çeviri yapabiliriz ya da kısaca kelimesi kelimesine diyebiliriz.

On Monday, 31 October 2022 at 07:47:47 UTC, Salih Dincer wrote:

Şimdi dikkat lütfen, burda çok ders var! Çok farklı sonuçlar alabileceğiniz olasılıklar var. Yani şu an biz basit bir dönüştürme işlemi yapmıyoruz. Bellek tahsis ve temsil yetenekleri açısında üzeriden geçilmesi gereken konular var. Basitten başlayıp sırayla gidelim:

Önce modüller arası alanda şöyle bir başlangıç kodumuz olsun:

module main;

auto hexToString(T)(T n) {
  import core.internal.string;
  char[32] buff;
  char[] result = n.unsignedToTempString!16(buff[]);
  return result;
}

enum veri = 0x07_5b_cd_15;
auto test = veri.hexToString;

İşlenen hazır değer (literal: enum veri) D derleyicisinin anlayabileyeceği ve özel bir şeye ihtiyaç bırakmadan size_t sayısına çevirebileceği bir şey. Yani önek (prefix) ve ayraçlar (alt çizgilerin sayılar daha fazla da olabilir) görmezden gelinir. Bu basit bir şey...

Ancak dikkat, aşağıda (1.bölümde) kanıtlandığı gibi bunun çiftlerden oluşan hexadecimal bir metin verisi olmadığına dikkat edin. Çünkü sayı 0 ile başlıyor ve chunks(2) gibi bir yöntem kullanıp da .length % 2 == 0 kontrolü yapmazsanız çuvallarsınız!

void main()
{
/************************* 1.BÖLÜM: */
  assert(test.length == 7);
  string metin = "0" ~
                 cast(string)test;
  import std.stdio;
  metin.writeln;

/************************* 2.BÖLÜM: */
  union Convert {
    uint data;
    ubyte[4] cell;
  }
  Convert convert;

  import std.algorithm,
         std.conv,
         std.range;

  metin.chunks(2)
       .map!(bin => bin
       .to!ubyte(16))
       .copy(convert.cell[].retro);

  assert(convert.data == veri);
}

Bunu görmek için isterseniz, ilgili bölümdeki satırı string metin = //"0" ~ şeklinde kısmen yorum satırına dönüştürün.

Diğer bölüm ise bu konu kadar basit! Çünkü aynı bellek bölgesini paylaşan (union ile overlapping yapılan) veri parçalara bölünerek kopyalanıyor ve ekstra işlem yapılmadan tekrar başladığımız noktaya (123456789 sayısına) dönülüyor.

On Tuesday, 1 November 2022 at 05:01:06 UTC, Salih Dincer wrote:

Örneğin, bir önbellek (buffer) belirtmezseniz modülün 76. satırındaki işleve uğrar ve alias get this'in istendiği gibi çalışmadığını görürsünüz:

import std.stdio;
import core.internal.string;

auto foo(ubyte n = 171)
{
  return n.unsignedToTempString!16;
}

void main()
{
  typeof(foo()).stringof.writeln(": ",
         ubyte.max.foo().get);
  assert(ubyte.max.foo[0] == 'f');
  assert(ubyte.max.foo[1] == 'f');
}

-ref. https://github.com/dlang/dmd/blob/master/druntime/src/core/internal/string.d#L76

Bu da bizi private olan bir yapının get()'ni kullanma zorunluluğuna sokuyor! (*bu önemli duruma değincez...)

Ya da bir başkası istediğimiz olan zaten 31. satırda durmaktayken, ubyte için sadece 2 elemanlı bir önbellek kullanabilirsiniz. Ama dikkat, derleme hatası almamak için dönüş değerlerine bir bakın, o bile güven vermiyor!

void main()
{
  auto bar(ubyte n = 171)
  {
    char[2] yerel;
    auto result = n.unsignedToTempString!16(yerel);
    return result;
  }

  //UnsignedStringBuf/*
  char[2]//*/
  harici;
  auto zar(ubyte n = 171)
  {
    auto result = n.unsignedToTempString!16(harici);
    return result;
  }
  writefln("%s", bar());/*
  bar().writeln;//*/
  zar().writeln(" (zar)");
  assert(cast(string)zar() == "ab");
}

-ref. https://github.com/dlang/dmd/blob/master/druntime/src/core/internal/string.d#L31

Çiftli örneğimiz (bar/zar) gerçekten ilginç. Mesela bar() yerel bir önbelleğe sahip olduğundan mı; -bilmiyorum, nedir?- %s kullanmadığınızda konsol çıktısı alamıyorsunuz!

(*) Yıldızlı konumuza dönersek; sanırım private olma ve/veya @property kullanılmama nedeniyle böyle bir sorun yaşamaktayız. Çünkü başka modülde olduğumuz için, modüle özel bir get() özelliğine nasıl erişebiliyoruz ki?

Belki de en iyisi 31. satırı alıp doğrudan kendi yapınıza koymak olabilir. Alternatifler de var...

(DEVAMI GELECEK)

On Tuesday, 1 November 2022 at 14:44:58 UTC, Ali Çehreli wrote:

Evet hocam, denemeleri run.dlang.io üzerinde yaparken, bazen "Server error: " hatası alıyor ve anlam veremiyordum. Orada herhangi bir bilgilendirme yapılmadığı gibi derleyici de yakalamadı. En son iota'nın olduğu satırı eklemeyince şu ikili denemede hiçbir hata almadım:

import std.stdio, std.range;
import core.internal.string;

enum n = 123456789;

char[32] harici;
char[] foo;

static this()
{
  foo = n.unsignedToTempString(harici[]);
}

void main()
{
  writeln("harici.ptr  : ", harici.ptr);
  auto bar()(size_t n)
  {
    char[32] yerel;
    writeln("yerel.ptr   : ", yerel.ptr);
    char[] result = n.unsignedToTempString!16(yerel[]);
    return result;
  }
  auto b = bar(n);

  //writeln("stack'i bozuyoruz... ", iota(3));
  foo.writeln;
  b.writeln;
} /* ÇIKTISI:
harici.ptr  : 7F7A0E3C8070
yerel.ptr   : 7FFC4EC69950
123456789
75bcd15
*/

Yorum satırını açınca eski sürüm bir derleyici ile derlendiğini görürken son satırdaki 75bcd15 çıktısı kayboluyor. Öte taraftan bar()'a erişim sağlamayınca hiçbir sorun olmuyor. Aradaki fark nedir?

Teşekkürler...

On Tuesday, 1 November 2022 at 17:30:25 UTC, Ali Çehreli wrote:

Anlamış mıyım hocam :)

import std.array : appender;
import core.internal.string;
import std.stdio, std.range;

enum n = 123456789; // 0x75bcd15

// safe method:
  auto foo(T)(T n)
  if(__traits(isUnsigned, T))
  {
    char[T.sizeof << 1] buffer;
    auto result = appender!(char[]);

    result.put(n.unsignedToTempString!16(buffer));
    return cast(string)result.data;
  }

// poor method:
  auto bar(T)(T n)
  {
    char[T.sizeof << 1] buffer;
    auto result = n.unsignedToTempString!16(buffer);

    return cast(string)result;
  }

void main()
{
  ubyte ab = 171;

  foo(ab).writeln;/*
  n.bar.writeln;//*/

  iota(4).retro.writeln(" hoopp stack'i bozuyoruz :)");
}

On Wednesday, 2 November 2022 at 06:14:04 UTC, Ali Çehreli wrote:

Tabii ki büyük usta Steven'dan :)

https://forum.dlang.org/post/rhufca$16n7$1@digitalmars.com

Şöyle bir şeye ne dersin hocam? Bir taşla 2 kuşu, string girer ve 6 char'lık buffer'ı kullanıp string çıkartır:

//*  sharing method of buffer:
auto hex(string  s) @safe
{
  import core.internal.string;
  import std.format, std.range;
	
  char[6] buffer;
  string result;
  foreach(c; s.chunks(2))
  {
    auto str = buffer[4..$];
         str.put(c);
    uint n = buffer[4];
         n |= buffer[5] << 4;
    result ~= n.unsignedToTempString!16(buffer).format!"0%s";	
  }
  return result;
}//*/

unittest
{
  // D Lang => 244, 65c 67e
  assert("D Lang".hex == "0244065c067e");
}

Bu kodun önbelleğinin (char[6] buffer) ilk 4 baytını çevirme, son 2 baytını birleştirme için kullandım. Neticede @safe içinde ve hiçbir bellek taşması ve benzeri yok öyle değil mi? Yani kendi kümesinde öten bir horoz misali kimseyi rahatsız etmiyor olmalı :)

Sevgiler, saygılar...