Bilmiyorum, aynı şeyler mi; aşağıdaki kod std.array.append içinden aldım. Burada Unicode'un boyutu tespit ediliyor olmalı.

Unqual!T[T.sizeof == 1 ? 4 : 2] encoded;
auto len = std.utf.encode(encoded, item);
put(encoded[0 .. len]);

Ayrıca inceleme için de çok mutlu oldum, teşekkürler...:)

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

Önceki bir konuda leftJustify'ı incelemeye başlamıştık. Orada mor renkle işaretlenmiş olan sorular açık kalmıştı:

http://ddili.org/forum/post/4848

zafer'in yazısına yanıt yazarak burada devam ediyorum. Çok uzun bir yazı oldu çünkü leftJustify'ın kullandığı ve düşündürdüğü çok konu var. Aşağıda bir sürü başka sayfaya bağlantı verdim. Umarım fazla dağıtmamışımdır.

Öncelikle çok basit bir işlev olan leftJustify'ın kısıtlı da olsa şu kadar basit olabileceğini göstermek istiyorum. leftJustify, verilen dizgiyi, bildirilen genişlikteki bir alanda sola dayalı olacak biçimde ve sonuna da fillChar'lar gelecek şekilde döndürür. Yani "abc"yi 5 genişliğinde bir alana '.' karakteriyle doldurunca "abc.." döndürür.

inout(char)[] leftJustify_basit(inout(char)[] s,
                               size_t width,
                               char fillChar = ' ')
{
   immutable len = s.length;

   if(len >= width) {
       /* Dizginin uzunluğu, içine yazılacağı alandan daha büyükse bütün
        * dizgiyi döndürüyoruz.
        *
        * Not: Aslında bu garip bir hareket, çünkü aslında başlangıç
        *      dizgisinin bir dilimini döndürmüş oluyoruz. Çağıran taraf
        *      döndürülen dizgi içinde otomatik olarak değişiklik yapamaz
        *      çünkü o zaman belki de baştaki dizgiyi değiştirmektedir. Tabii
        *      bunu leftJustify'ı çağırmadan önce dizginin uzunluğuna bakarak
        *      bilebilir. İlginç bir gözlem...
        */
       return s;
   }

   /* Sağ tarafı fillChar ile doldurulmuş olan daha büyük bir dizgi
    * oluşturmamız gerekiyor. */

   auto retval = new char[width];   // Boş dizgi. Bunu inout(char) yapamayız;
                                    // çünkü gelen dizgi örneğin immutable
                                    // ise bu da öyle olur ve o yüzden
                                    // değişiklik yapamayız. Bunun const veya
                                    // immutable olmayan char dizisi olarak
                                    // kurmamız gerekiyor. Sonra aşağıda
                                    // döndürürken doğru türle döndüreceğiz.

   retval[0 .. len] = s;            // Baş tarafına giriş dizgisini kopyala
   retval[len .. $] = fillChar;     // Son tarafını fillChar ile doldur

   return cast(inout(char)[])retval;
}

unittest
{
   /* Nasıl işlediğini gösteren basit bir test */
   assert(leftJustify_basit("abc", 5, '.') == "abc..");
}

Tabii o kadar da basit değil: Değişebilen, const, ve immutable dizgilerle çağrılabilsin diye eleman türünü inout(char) yaptım. inout, gönderilen parametreye bağlı olarak değişebilen, const, veya immutable olur. inout şurada geçiyor:

http://ddili.org/ders/d/islevler_diger.html

O basit işlevle karşılaştırıldığında asıl leftJustify() çok korkutucu: :)

Alıntı (zafer:1328177701):

> S leftJustify(S)(S s, size_t width, dchar fillChar = ' ') @trusted
>     if(isSomeString!S)
> {
>     alias typeof(S[0]) C;
>
>     if(cast(dchar)(cast(C)fillChar) == fillChar)
>     {
>         immutable len = s.walkLength();
>         if(len >= width)
>             return s;
>
>         auto retval = new Unqual!(C)[width - len + s.length];
>         retval[0 .. s.length] = s[];
>         retval[s.length .. $] = cast(C)fillChar;
>         return cast(S)retval;
>     }
>     else
>     {
>         auto dstr = to!dstring(s);
>         if(dstr.length >= width)
>             return s;
>
>         auto retval = new dchar[](width);
>         retval[0 .. dstr.length] = dstr[];
>         retval[dstr.length .. $] = fillChar;
>         return to!S(retval);
>     }
> }
> ```

>
> Ben yani leftJustify bir şablon metoduyum ve S isimle bir tip üzerinde işlemler yaparım. Beni çalıştırmak istersen öncelikle bana S tipinde bir s degeri, size_t tipinde bir width değeri ve dchar tipinde bir fillChar değeri göndermek zorundasın ama senin için küçük bir kolaylık olması açısından ben fillChar değerini varsayılan olarak boşluk ayarlıyorum. Eğer sen bir fillchar değeri göndermezsen bunu kullanacağım, haberin olsun!
>

Çok doğru.

Alıntı:
>
> Alıntı:
> >
> > if(isSomeString!S) bu satırın açıklamasını Ali'ye sor!
> >
>

O bir şablon kısıtlaması (template constraint). O kavram "Şablon kısıtlamaları" başlığında şurada geçiyor:

 http://ddili.org/ders/d/dosyalar.html

Üstelik, kolaylık ve okunaklılık olsun diye o bir *isimli kısıtlama* olarak gerçekleştirilmiş. "İsimli kısıtlama yöntemi" de aynı sayfada bir sonraki başlık olarak var. Aslında isSomeString'in kendisi de şurada "std.traits modülü" başlığı altında:

 http://ddili.org/ders/d/dosyalar.html

Orada görüldüğü gibi, isSomeString, şablon parametresi herhangi bir dizgi türüyse true üretir.

Yani uzun lafın kısası, leftJustify ayrıca şunu söylüyor: "beni ancak S bir dizgi türü ise çağırabilirsiniz."

D reklamı: Şablon kısıtlamalarının eşdeğeri başka dillerde *concepts* olarak geçer. Concepts C++11'e eklenmek istenmiş ama zaman kalmadığı için komite o isteği geri çevirmek zorunda kalmıştır. Bjarne Stroustrup'un hiç istemeden kabul ettiği bir durumdur.

Alıntı:
>
> Alıntı:
> >
> > alias typeof(S[0]) C;
> >
>
> Aslında ben bana gönderilen S tipinin temelde bir karakter katarı olduğunu biliyorum ve bu bilgiden faydalanarak ve katarın ilk elemanından tip bilgisini alıp bu tipin adına C diyorum.
> '-> Burada bir soru S'nin bir string olduğunu biliyorsak neden açıkca string tanımlamıyoruz?'
>

Çünkü char, wchar, veya dchar olabilir. Aslında orada std.range.ElementEncodingType'ı da kullanabilirlermiş. leftJustify() ElementEncodingType kütüphaneye eklenmeden önce yazılmış olmalı, veya belki de o kadar basit bir alias için ElementEncodingType yazmaya gerek görmemişlerdir. ElementType ve ElementEncodingType aynı şey değillerdir. Farkları şurada var:

 http://ddili.org/ders/d/araliklar_baska.html

Oradan kopyalıyorum:

Alıntı:
> ElementType, aralıktaki elemanların türünü bildiren bir şablondur.
> ...
> Dizgiler aralık olarak kullanıldıklarında elemanlarına harf harf erişildiği için dizgi aralıklarının eleman türü her zaman için dchar'dır. Bu yüzden dizgilerin UTF kodlama türü ElementType ile belirlenemez. UTF kodlama türünü belirlemek için ElementEncodingType kullanılır. Örneğin bir wchar dizgisinin ElementType'ı dchar, ElementEncodingType'ı da wchar'dır.

Alıntı:
>
> Alıntı:
> >
> > if(cast(dchar)(cast(C)fillChar) == fillChar)
> >
>
> Şimdi bir sınama yapıyorum. fillChar değişkenimi önce tanımladığım C tipine sonra tekrar dchar tipine çevirip elde ettiğim değerin fillChar'a eşit olup olmadığını kontrol ediyorum.
> '-> Bunu neden yaptık anlamadım. Sanırım fillChar'ın standart char olup olmadığnı test ediyoruz.'

Olabildiğince kullanışlı olması için fillChar'ı dchar olarak tanımlamışlar. Böylece char dizgilerinin sonuna bile dchar yerleştirebilecekler. Yani "abc" gibi bir dizginin sonunu "abcğğğ" diye doldurabilecekler. Ama burada bir eniyileştirme fırsatı var: doldurma karakteri dchar olsa bile, değeri ASCII olabilir. Yani değeri char olarak da aynı olabilir. Örneğin boşluk karakteri öyledir, nokta öyledir, vs.

C'nin char olduğu durumda cast(C) yaptıklarında 4 baytlık dchar'ı tek bayta maskelemiş oluyorlar (yani yalnızca alt 8 bitini alıyorlar). Onu tekrar dchar'a dönüştürdüklerinde de değer aynıysa, elimizde ASCII değerli bir dchar var demektir.

Alıntı:
>
> Alıntı:
> >
> > immutable len = s.walkLength();
> >
>
> Eğer eşitse, kesinlikle değiştirmeyeceğimi kabul ettiğim bir len değişkeni tanımlıyor ve program çalıştığı sürece göstereceği değeri kendisine bildiriyorum. Bunu yaparken bana iletilen s değişkeninin walkLength() niteliğinden yardım alıyorum.!! Sanırım !! bu metot bana s değerimin uzunluğunu veriyor.
> '-> walkLength niteliğine ulaşamadım range modülünde bir walkLength buldum ama bu daha farklı gibi nerededir bu walkLength tanımı ve ne iş yapar acaba?'
>

Ara not: Burada benim tam ısınamadığım ama aslında yararlı olan bir olanak geçiyor: walkLength aslında bir dizgi üye işlevi değildir. walkLength, std.range modülünün bir işlevidir.

D'de dizilere bir ayrıcalık uygulanır: ilk parametresi dizi olan işlevler dizi.foo() yazımıyla da çağrılabilirler. Örneğin, s.front yazabilmemiz de buna bağlıdır. Aslında serbest bir işlev olan std.array.front() normalde front(s) diye çağrılır. Bu ayrıcalık yüzünden s.front yazılabilir. (Bazıları bu olanağın bütün türlere de açılmasını isterler.)

walkLength() aralığın başından sonuna kadar kaç adımda gidilebildiğini verir. Ama bunun için bütün aralığı başından sonuna kadar ilerlemesi gerekmez: Eğer aralığın .length niteliği varsa onu çağırır.

Bu noktada şöyle düşünülebilir: Elimizde dizgi olduğunu bildiğimize göre s.length de yazamaz mıydık? Yazamazdık, çünkü char[] ve wchar[] aralık olarak kullanıldıklarında .length nitelikleri yoktur.

Bu aslında çok ilginç bir durum: aşağıdaki işlevde s.length yazabildiğimiz halde, yani dizginin kendisinin .length niteliği bulunduğu halde, dizgi aralık olarak kullanıldığında o aralığın .length niteliği bulunmayabiliyor.

Bu, char[] ve wchar[]'in RandomAccessRange olmamalarından ileri geliyor. Çünkü bu iki dizgi türünün elemanları dchar'dır. dchar'ları oluşturmak da ancak dizgiler baştan sona ilerlenerek bulunabilirler.

Şu programla deneyebiliyoruz:

import std.stdio;
import std.range;

void foo(S)(S s)
{
writefln("%20s .length niteliği var: %s, .length: %s, walkLength: %s",
S.stringof, hasLength!S, s.length, walkLength(s));
}

void main()
{
foo("abcç?"c);
foo("abcç?"w);
foo("abcç?"d);
}

Çıktısından görüldüğü gibi, yalnızca dchar[] dizgilerinin .length'leri ile eleman sayıları aynıdır. (ç'den sonraki "gothic ahsa" harfi tek wchar ile ifade edilemez; onun için onu da ekledim):

'              string  .length niteliği var: false, .length: 9, walkLength: 5
 immutable(wchar)[]  .length niteliği var: false, .length: 6, walkLength: 5
 immutable(dchar)[]  .length niteliği var: true, .length: 5, walkLength: 5
'

Alıntı:
>
> Alıntı:
> >
> > if(len >= width) return s;
> >
>
> Şimdi bir sınama daha yapmalıyım, eğer bana gönderilen s değerinin uzunluğu olarak bildiğim len değeri bana çalışmam için gönderilen uzunluk olan width değerinden büyükse, yani benim çalışma için belirlenen alan zaten değişkenin tamamı tarafından kapatılmışsa, bu durumda benim yapabileceğim bir iş yok, o zaman işlemi bitirip tatile çıkalım, benden sonuç bekleyenlere de bana gönderdiklerini iade edeyim :)
>

Müthiş bir eniyileştirme bu: dizgiyi olduğu gibi döndürmek çok hızlı çünkü dizgiler referans türleridirler. Bu durumda parametre dizgi ve döndürülen dizgi aynı karakterlere erişim sağlayan dizgilerdir. 32-bitlik ortamda toplam 8 bayt döndürülüyor. (Dizgiler perde arkasında tek gösterge ve tek uzunluk olarak gerçekleştirilirler.)

Not: Dil alışkanlığı olarak dizgi diyorum ama burada *dilim* (veya *dinamik dizgi* (veya *devingen dizgi* ;)) demek gerek tabii ki. Yoksa sabit uzunluklu dizi olsaydı bütün elemanlar kopyalanırlardı, çünkü sabit uzunluklu dizgiler değer türleridirler.

Alıntı:
>
> Alıntı:
> >
> > auto retval = new Unqual!(C)[width - len + s.length];
> >
>
> Off çok tembelim ama ne yapayım çok iş var. Şu retval değişkeninin tipini auto yapayımda birde onla uğraşmayayım. Bu retval ile güzel işler yapacağım en iyisi bellekte bir yer ayarlayıp onu oraya yerleştireyim hemde gözümün önünde olur :) ama bir sorun var C olarak bildirdiğim tip üzerinde ya başka işaretler varsa bana tipin saf, temiz hali gerekiyor o zaman önce şu Unqual şablon metodunu çağırıp şu tipi bir temizleyelim sonrada gerekli hesaplamayı yapıp bellekte bir yer ayarlayıp retval'a vereyim.
> '-> [width - len + s.length] burada len zaten s.length ise fazladan işlem yapılmış gibi?'
>

Yukarıda da konuştuğumuz gibi, len ile s.length'in eşit olmadıkları durumlar var.

Alıntı:
>
> Alıntı:
> >
> > retval[0 .. s.length] = s[];
> >
>
> Hımm. retval değişkenim hazır olduğuna göre şimdi bana gönderilen karakter katarını bu değişkene aktarayım. D'nin kestirme yollarını seviyorum [] işleci sayesinde dizinin tamamını tek bir hamlede aktarabildim.
>

Aslında o durumda sağ taraftaki köşeli parantezlere gerek yok ama zararı da yok. Örneğin ben leftJustify_basit() içinde sağ tarafta yalnızca s yazdım.

Alıntı:
>
> Alıntı:
> >
> > retval[s.length .. $] = cast(C)fillChar;
> > return cast(S)retval;
> >
>
> Şimdi ise retval değişkeninin geriye kalan kısmını doldurayım. Evet artık hazır son olarak retval'ı gelen tipe çevirip geri göndereyim.
> '-> Burada Unqual ile yapılan temizleme işlemini tam anlamadığım için bu kısımda askıda kaldı ?'
>

S örneğin immutable(char)[] idi ise, retval char[] olduğundan uymazlar ve derleme hatası oluşur. Biz işlemlerimizi hep değişebilen char[] türü ile yaptık ama öyle bir durumda immutable(char)[] döndürmemiz gerekir.

Alıntı:
>
> Metodun kendisini tanıttığı tarzda bir yazı hazırlamaya çalıştım, tabi ki amacım D bilgim ile böyle bir metodu anlamaya çalışmaktı. Başlangıçta keyifli ve basit bir iş gibi görünsede ilerleyen satırlarda ve başka metodlara dallandıkça çok zor ve emek isteyen bir iş olduğunu anladım. Bu sebeple else kısmını atladım :) Hikayeye devam etmek isteyenler tamamlayabilir.

Ben de aynı nedenden yanıtımı bu kadar geciktirdim. :) else kısmı daha kolay. else'e fillChar bir S elemanı olamadığı durumda düşüyorduk. Örneğin "abc" gibi bir char dizgisinin sonuna ç doldurmak istediğimizde ç char'a sığamadığı için...

O zaman kolayca bütün işlemleri dchar üzerinde halletmişler. walkLength'e de gerek yok çünkü dchar kullanıldığında .length eşittir, vs.

Alıntı:
>
> Diğer taraftan böyle bir çalışmanın ne kadar öğretici olduğunuda anlama fırsatı buldum. immutable, Unqual, [] gibi daha önce geçmiş tarimleri tekrar hatırladım walkLength gibi yeni niteliklerle tanıştım. Değişik bir tarz olduğunu söylemeliyim belki bir toplulukla daha etkileyici bir deneyim olabilir.
>
> Sorular alttaki mor satırlarda, eksik ve yanlışlarımıda düzeltirseniz memnun olurum.
>

Tek olanak kaldı: @trusted. O da şurada geçiyor:

 http://ddili.org/ders/d/islevler_diger.html

Aktarıyorum:

Alıntı:
> "Güvenilir" anlamına gelen @trusted olarak bildirilmiş olan işlevler, @safe olarak bildirilemeyecek oldukları halde tanımsız davranışa neden olmayan işlevlerdir.
>
> Böyle işlevler, @safe işlevlerin yasakladığı işlemleri yapıyor oldukları halde hatalı olmadıkları programcı tarafından garantilenen işlevlerdir. Programcının derleyiciye "bu işleve güvenebilirsin" demesi gibidir.
>
> Derleyici programcının sözüne güvenir, ve @trusted işlevlerin @safe işlevlerden çağrılmalarına izin verir.

Ali

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

Alıntı (acehreli):

Forum o karakteri idare edemedi. Onun için yerine ? yazdım. Siz Unicode kodu ile deneyebilirsiniz. Örneğin:

   foo("abcç\U00010330"c);

Ali

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

Alıntı (Salih Dinçer):

> Unqual!T[T.sizeof == 1 ? 4 : 2] encoded;
> ```

>

Bakmadan söylüyorum: T herhalde ya char ya da wchar oluyor. char ise UTF-8 kodlamasıdır ve en fazla 4 adet char gerekir. wchar ise UTF-16 kodlamasıdır ve en fazla 2 adet wchar gerekir.

Karakterin UTF gösterimini encoded isimli dizinin içine yerleştirecekler.

Alıntı:
>
>

encode, verilen karaterin yine verilen dizinin içine UTF düzeninde yerleştirir. Ayrıca da kaç adet kod birimi (code unit) kullanıldığını döndürür. UTF-8 kodlaması Unicode karakterine göre 1, 2, 3, veya 4 adet char olabilir; wchar ise 1 veya 2.

Ali

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

Ali öncelikle çok çooook teşekkürler, böyle bir yazının hazırlanmasının ne kadar zor olduğunu anlamış birisi olarak bu teşekkürü ediyorum ;-) ve eline sağlık diyorum, harika bir inceleme olmuş, keyifle okudum.

Alıntı (acehreli:1328385986):

walkLength() niteliğini anladığımı zannediyorum gerçi bu sayede bambaşka bir özellik daha öğrendim. Sınıfın üyesi olmadığı halde üye gibi kullanabileceğimiz niteliklerle tanıştım. Ancak aşağıdaki kodda anlamadığım nokta s.length kullanımı, yukarıdaki bilgilerle göre bu kullanım yanlış olmuyor mu? Benim kaçırdığım bir nokta mı var bu kodda?

if(cast(dchar)(cast(C)fillChar) == fillChar)
   {
       immutable len = s.walkLength();
       if(len >= width)
           return s;

       auto retval = new Unqual!(C)[width - len + s.length];
       retval[0 .. s.length] = s[];
       retval[s.length .. $] = cast(C)fillChar;
       return cast(S)retval;
   }

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

Alıntı (zafer):

leftJustify()'ın 'width' parametresinin hedefte istenen Unicode karakter adedi olduğunu görünce daha iyi anlaşılıyor. Yani hedef bir char[] bile olsa uzunluk olarak 10 char değil, 10 Unicode karakteri istiyoruz.

İşleve yardımcı satırlar ekledim:

import std.stdio;
import std.traits;
import std.range;
import std.conv;

S leftJustify_mesajlı(S)(S s, size_t width, dchar fillChar = ' ') @trusted
   if(isSomeString!S)
{
   alias typeof(S[0]) C;
   writeln("\n-----");
   writefln("tür: %s, dizgi: \"%s\", istenen uzunluk: %s, fillChar: '%s'",
       Unqual!(C).stringof, s, width, fillChar);

   if(cast(dchar)(cast(C)fillChar) == fillChar)
   {
       immutable len = s.walkLength();
       writefln("s.walkLength(): %s, s.length: %s", len, s.length);

       if(len >= width)
           return s;

       writeln("hedef için gereken uzunluk: ", width - len + s.length);
       auto retval = new Unqual!(C)[width - len + s.length];

       writefln("hedefin ilk %s elemanına dizgiyi yerleştiriyoruz", s.length);
       retval[0 .. s.length] = s[];
       writefln("geri kalan %s elemanına da '%s'", retval.length - s.length, fillChar);
       retval[s.length .. $] = cast(C)fillChar;
       return cast(S)retval;
   }
   else
   {
       auto dstr = to!dstring(s);
       if(dstr.length >= width)
           return s;

       auto retval = new dchar[](width);
       retval[0 .. dstr.length] = dstr[];
       retval[dstr.length .. $] = fillChar;
       return to!S(retval);
   }
}

void main()
{
   leftJustify_mesajlı("abc", 10, '.');
   leftJustify_mesajlı("abcçd", 10, '.');
   leftJustify_mesajlı("abcçd\U00010330", 10, '.');

   leftJustify_mesajlı("abc"w, 10, '.');
   leftJustify_mesajlı("abcçd"w, 10, '.');
   leftJustify_mesajlı("abcçd\U00010330"w, 10, '.');

   leftJustify_mesajlı("abc"d, 10, '.');
   leftJustify_mesajlı("abcçd"d, 10, '.');
   leftJustify_mesajlı("abcçd\U00010330"d, 10, '.');
}

Çıktısı (O garip karakteri elimle ? olarak değiştiriyorum. Bizim forum o karakteri halledemiyor.) :

'

tür: char, dizgi: "abc", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 3, s.length: 3
hedef için gereken uzunluk: 10
hedefin ilk 3 elemanına dizgiyi yerleştiriyoruz
geri kalan 7 elemanına da '.'

tür: char, dizgi: "abcçd", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 5, s.length: 6
hedef için gereken uzunluk: 11
hedefin ilk 6 elemanına dizgiyi yerleştiriyoruz
geri kalan 5 elemanına da '.'

tür: char, dizgi: "abcçd?", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 6, s.length: 10
hedef için gereken uzunluk: 14
hedefin ilk 10 elemanına dizgiyi yerleştiriyoruz
geri kalan 4 elemanına da '.'

tür: wchar, dizgi: "abc", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 3, s.length: 3
hedef için gereken uzunluk: 10
hedefin ilk 3 elemanına dizgiyi yerleştiriyoruz
geri kalan 7 elemanına da '.'

tür: wchar, dizgi: "abcçd", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 5, s.length: 5
hedef için gereken uzunluk: 10
hedefin ilk 5 elemanına dizgiyi yerleştiriyoruz
geri kalan 5 elemanına da '.'

tür: wchar, dizgi: "abcçd?", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 6, s.length: 7
hedef için gereken uzunluk: 11
hedefin ilk 7 elemanına dizgiyi yerleştiriyoruz
geri kalan 4 elemanına da '.'

tür: dchar, dizgi: "abc", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 3, s.length: 3
hedef için gereken uzunluk: 10
hedefin ilk 3 elemanına dizgiyi yerleştiriyoruz
geri kalan 7 elemanına da '.'

tür: dchar, dizgi: "abcçd", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 5, s.length: 5
hedef için gereken uzunluk: 10
hedefin ilk 5 elemanına dizgiyi yerleştiriyoruz
geri kalan 5 elemanına da '.'

tür: dchar, dizgi: "abcçd?", istenen uzunluk: 10, fillChar: '.'
s.walkLength(): 6, s.length: 6
hedef için gereken uzunluk: 10
hedefin ilk 6 elemanına dizgiyi yerleştiriyoruz
geri kalan 4 elemanına da '.'
'

Ali

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

Teşekkürler Ali, emek harcayıp yine ortaya güzel işler çıkarmışsın :)

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