Forum: Ders Arası RSS
Array içerisinde array kullanımı
Sayfa:  1  2  3  sonraki 
Avatar
zekeriyadurmus #1
Kullanıcı başlığı: Talha Zekeriya Durmuş
Üye Eki 2012 tarihinden beri · 701 mesaj · Konum: Samsun/Türkiye
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: Array içerisinde array kullanımı
Arkadaşlar d dilinde array içerisinde array nasıl kullanabiliriz?

Mesela pythonda
dizi =[2]
dizi.append([1])
dizi[1].append(1,2)
dizi.append("yazı")

şeklinde yazdığımızda sonuç olarak [2, [1,1,2], "yazı"] gibi bir sonuç dönüyor.
Yani dizi sonsuz boyutlu ve her tür veriyi içerisinde barındırabiliyor.

Bunu d de nasıl yapabiliriz?
Bilgi meraktan gelir...
Avatar
Salih Dinçer #2
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Aramıza hoş geldin Zekeriya...

Bu konuda Ali hocam daha yetkin cevap verecektir ama D'de bu olayın karşılığı çokuzlu (Tuples) kullanmak olabilir. Örneğin:
    import std.stdio;
 
    /* Önce aşağıdaki gibi bir şablon kuruyoruz...
     * Bu sayede farklı türde tüm verileri bir araya topluyoruz!
     */
    template Çokuzlu(E...)
    {
        alias E Çokuzlu;
    }
 
void main()
{
    /* Kullanmak için ise gayet basit şekilde
     * Tüm verileri şablon için tanımlıyoruz...
     */
    alias Çokuzlu!(2, [1,1,2], "yazı") dizi;
 
    foreach(ç; dizi) ç.writeln;/* ya da aynı çıktıyı veren:
//  ^--- (toggle-on/off) alt satırı açmak için // kullan
    dizi[0].writeln; // 2 yazar
    dizi[1].writeln; // [1,1,2] yazar
    dizi[2].writeln; // yazı yazar
 
//*/
}
Başarılar...
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
acehreli (Moderatör) #3
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Hoşgeldin zekeriyadurmus! :)

Salih'in gösterdiği olur ama ancak bir araya getirilen parçalar baştan (yani derleme zamanında) biliniyorsa olur.

D, strongly statically typed bir dildir. Her değişkenin türü derleme zamanında belirlenmiş olmak zorundadır. Python örneğindeki gibi bir dizinin türünü D'de söyleyemeyiz bile: "int dizisi" olmaz, "int'lerden ve int dizilerinden oluşan dizi" olmaz. İkincisi olsa bile bu sefer Python'da onun içine bambaşka türler bile eklenebiliyor (galiba).

Ek olarak, bir kütüphane olanağı olarak Variant var. O türün arkasına istediğimiz başka türü gizleyebiliriz ve böylece "Variant dizisi" oluşturabiliriz.

Bunun gibi başka yöntemler de var. Probleme göre düşünmek gerek.

Ama sorunun kısa yanıtı: Hayır, D'de yapılamaz. :)

Ali
Avatar
zekeriyadurmus #4
Kullanıcı başlığı: Talha Zekeriya Durmuş
Üye Eki 2012 tarihinden beri · 701 mesaj · Konum: Samsun/Türkiye
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Öncelikle verdiğiniz cevaplar için teşekkür ederim.

Derleme zamanında bu dizi tamamen boş olacak çalışma zamanında buraya sürekli dizi, yazı vs eklenecek. Tabi bu yazılar dizinin içerisine de yazılacak hatta dizinin içindeki dizinin içine kadar yazılabilecek.

Sadece çalışma zamanı esnasında içerisine dizi, string ve pythondaki gibi kitaplık (aynısı d de var) eklensin yeter benim için.

kitaplık derken:
string b[string];
b["key"]="val";

Teşekkür ederim.
Bilgi meraktan gelir...
Avatar
Salih Dinçer #5
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Sanırım Python'da kitaplık, D'de eşleme tablosu (associative arrays)...

Bence bir bağlı liste yapılarak farklı veri türleri bir diziymiş gibi bağlanabilir. Dizideki elemanlar aslında işaretçi olur...
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
acehreli (Moderatör) #6
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj #4
zekeriyadurmus:
çalışma zamanı esnasında içerisine dizi, string ve pythondaki gibi kitaplık (aynısı d de var) eklensin

Tam olarak nasıl bir problem çözmeye çalışıyoruz? Aynı topluluğun elemanlarının o kadar farklı olmaları D'nin mantığına uymuyor. Yine de yapılabilir ama Python'daki kadar kolay olmaz.

Elemanların aralarında bir benzerlik olsa, örneğin hepsine Veri bile diyebilsek, bir Veri arayüzü kullanılabilir. Tabii o arayüzün üye işlevinin ne olacaklarını tahmin edemiyorum.

Ali
acehreli (Moderatör) #7
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bir ekleme yapmam gerektiğini düşündüm. Öncelikle, sözüm meclisten dışarı, çünkü bu gerçekten evrensel bir konu.

Yeni bir dile baktığımızda o dilin belirli bir olanağı sunmadığını farkederek şaşırabiliyoruz. Hemen aklıma gelen bir örnek: D'ciler şablon gibi türden bağımsız programlama (generic programming) olanakları bulunmayan başka dillere şaşırırlar. Geçenlerde Go'nun başındakilerden birisinin bir blog yazısını okumuştum. O kişi de Go için benzer şeyler söylendiğini yazıyordu ve sonunda da "Go'ye eksik bulmadan önce aynı problemlerin Go'da nasıl çözüldüklerine bir bakın" diyordu. Haklı.

Burada da Python'ın olanağı bana hem çok esnek ve kolay, hem de çok çılgınca geliyor. :) Diğer taraftan bakınca da D yetersizmiş gibi görünüyor. En iyisi, daha önce de söylediğim gibi, problemi tam olarak anlarsak D'de ne tür çözümler bulunduğuna bakabiliriz.

Ali
Avatar
zekeriyadurmus #8
Kullanıcı başlığı: Talha Zekeriya Durmuş
Üye Eki 2012 tarihinden beri · 701 mesaj · Konum: Samsun/Türkiye
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Pythonı kullanarak kendi interpreterımı yazdım. Ama gel gör ki python da c ile yazılmış bir interpreter olmasından dolayı oldukça yavaş haliyle bana aşırı hızlı bir dil lazımdı, araştırma ve testler sonucunda d dilinde karar kılındı.
Txt dosyasından okuduğum kodları parse ettikten sonra bunların bir şemasın çıkarmam gerekiyordu. Ama bu şemayı bir türlü oluşturamadım çünkü pythondaki gibi sonsuz boyutlu birşey yoktu ayrıca yazacağımız dilin python gibi bir array yapısına sahip olacağını düşünürsek eğer d de çok basit bir sonsuz boyutlu array oluşturamamak projenin önüne koca bir engel koydu.
İstediğim şey sadece
[{"a": "b", "x": {"c": ["1","2","3"]}}, {"t": "1", 'y': "2"}]
gibi içerisinde associative array, array ve string barındırabilen sonsuza dek genişleyebilen bir yapı.

Teşekkür ederim.
Bilgi meraktan gelir...
acehreli (Moderatör) #9
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
zekeriyadurmus:
Txt dosyasından okuduğum kodları parse ettikten sonra bunların bir şemasın çıkarmam gerekiyordu.

O kadarıyla zor bir iş gibi görünmüyor.

Ama bu şemayı bir türlü oluşturamadım çünkü pythondaki gibi sonsuz boyutlu birşey yoktu

Oysa D'nin dizileri ve eşleme tabloları (associative array) da sonsuza kadar büyüyebilirler. (?) Ayrıca std.container gibi modüllerde bağlı listeler de var. (Ama std.container'ın modern D'ye daha uygun bir modülle değiştirilmesi de bekleniyor.)

Ama kod örneklerinden anladığıma göre burada aslında bir ağaç veri yapısı da gerekiyor olabilir.

Python'dan farklı olan şu: Herhangi bir topluluğun elemanlarının hep aynı türden olmaları gerekir. Bu, verinin işlendiği noktada önem kazanır. Python bize türler konusunda derleme zamanında hiçbir güvence getirmez. Örneğin, dizide bir int bulunsa bile kod o int'i bir dizi gibi kullanmaya çalışabilir. Bu hata ancak çalışma zamanında ve belki de program uzun bir süre çalıştıktan sonra anlaşılabilir. Hatta, bütün testlerden geçmiş bile olsa program bir kaç ay sonra tek kullanıcı için çalışırken göçebilir.

D gibi strongly statically typed dillerde verinin aynı türden olmasının gerekmesini bir kısıtlama olarak görmemek gerekir. Genel olarak "aynı türden" oldukları halde özel olarak bakıldığında "farklı türden" olan nesneler de bir araya gelebilirler.

D'de bu amacı karşılayan çeşitli olanaklar var. Bunlara bakmadan önce verinin nasıl işleneceğine bakmak gerekir. Metin dosyasından okunan bu verilere genel olarak bir isim verebiliyor muyuz? Örneğin hepsi de Komut mu? Ve bu komutların hepsinin de sağlaması gereken bir işlem var mı? O zaman NYP uygulanabilir:

interface Komut
{
    void işlet();
}
 
class KopyalamaKomutu : Komut
{
    string kaynak;
    string hedef;
 
    // ...
 
    void işlet()
    {
        // ... kopyalama işlemi ...
    }
}
 
// Sonsuza kadar büyüyebilen bir Komut dizisi
    Komut[] komutlar;
    komutlar ~= new KopyalamaKomutu("foo.d", "bar.d");
    komutlar ~= new SilmeKomutu("zar.d");

Tahmin ettiğim gibi ağaç gibi dallanabiliyorsa, yani her komutun alt komutları olabiliyorsa o zaman bazı düğümler yalnızca bir Komut[] gibi davranırlar ve böylece ağaç yapısı tamamlanmış olur.

Düşünürsek, böyle bir ağaç yapısında iki tür Komut vardır: ÇokluKomut, TekliKomut. Uyarı: Aşağıdaki program gereğinden karmaşık görünebilir. Daha sonra basitleşecek:
import std.stdio;
 
// Bu yalnızca bir arayüz. Bu sıradüzenin kullanıcıları en azından işlet()
// işlevini bekleyecekler.
interface Komut
{
public:
 
    void işlet();
}
 
class TekliKomut : Komut
{
public:
 
    /* Tekli komut işletmek her komutun özel işleticisini çağırmak kadar
     * basittir.
     *
     * Not: Aslında buna gerek yoktur çünkü alt sınıflar işlet_özel()
     * işlevinin tanımını vermek yerine doğrudan işlet() işlevinin tanımını da
     * verebilirler.
     *
     * Bu yöntem ise bize bütün tekli komutların işletilmesi sırasında araya
     * girebileceğimiz bir olanak sağlar. Örneğin her tekli komut için
     * işletilecek olan bir adımı burada gerçekleştirebiliriz.
     *
     * Bu yönteme 'template method design pattern' denir (ama şablonlarla
     * ilgisi yoktur.) Başka bir adı da "non virtual interface"tir.
     */
    void işlet()
    {
        işlet_özel();
    }
 
protected:
 
    // İşte alt sınıflar bunu tanımlamak zorundadırlar
    abstract void işlet_özel();
}
 
class ÇokluKomut : Komut
{
private:
 
    // Kendisi bir Komut olduğu halde birden fazla komuttan oluşuyor
    Komut[] komutlar;
 
public:
 
    // Kurucu bir veya daha fazla komutla başlayabilir
    this(Komut[] komutlar...)
    {
        /* Not: Burada daha normal olarak şöyle yazabilmek isterdim:
         *
         *     this.komutlar = komutlar;
         *
         * Öyle yapınca program parçalama hatası veriyor çünkü "..." ile
         * işaretlenmiş olan parametre gereğinden erken sonlandırılıyor. Bence
         * öyle olmamalı. Araştıracağım ve gerekirse bir dmd hatası açacağım.
         *
         * Ama ~= işleci çalışıyor:
         */
        this.komutlar ~= komutlar;
    }
 
    // Sonradan da komut eklenebilir
    void ekle(Komut komut)
    {
        komutlar ~= komut;
    }
 
    // Çoklu komutun işletilmesi alt komutlarının sırayla işletilmeleridir
    void işlet()
    {
        foreach (komut; komutlar) {
            komut.işlet();
        }
    }
}
 
// Yukarıdaki temel oluşturulduktan sonra farklı komutların tanımlarına
// geçebiliriz.
 
// Kopyalama komutu tekli bir komut olsun
class Kopyala : TekliKomut
{
private:
 
    string kaynak;
    string hedef;
 
public:
 
    this(string kaynak, string hedef)
    {
        this.kaynak = kaynak;
        this.hedef = hedef;
    }
 
protected:
 
    override void işlet_özel()
    {
        writefln("%s dosyasını %s olarak kopyalıyorum", kaynak, hedef);
    }
}
 
// Silme komutu da tekli bir komut olsun
class Sil : TekliKomut
{
private:
 
    string dosya;
 
public:
 
    this(string dosya)
    {
        this.dosya = dosya;
    }
 
protected:
 
    override void işlet_özel()
    {
        writefln("%s dosyasını siliyorum", dosya);
    }
}
 
// Taşımanın başka yolları olsa da, örnek olsun diye taşıma komutunu diğer
// ikisinin bileşimi olarak gerçekleştirelim. Dolayısıyla bu çoklu bir komut
// olacak
class Taşı : ÇokluKomut
{
public:
 
    this(string kaynak, string hedef)
    {
        // Bunun tek yaptığı, üst sınıfını memnun etmek olacak. O işi de bir
        // kopyalama bir de silme komutu vererek gerçekleştiriyoruz:
        super(new Kopyala(kaynak, hedef), new Sil(kaynak));
    }
 
    // Başka işlem gerekmiyor
}
 
void main()
{
    // Artık sonsuz karmaşıklıkta bir komut ağacı oluşturabiliriz:
    Komut[] komutlar;
 
    // Aşağıdaki işlemleri örneğin çalışma zamanında taradığımız bir metin
    // dosyasından öğrenebiliriz:
    komutlar ~= new Kopyala("bundan_kopyala.txt", "buna_kopyala.txt");
    komutlar ~= new Sil("zararli_dosya.txt");
    komutlar ~= new Taşı("yanlis_isim.txt", "dogru_isim.txt");
 
    foreach (komut; komutlar) {
        komut.işlet();
    }
 
    // Bu kadar çeşit komutla bile istediğimiz kadar derine
    // dallanabileceğimizi görelim:
    auto derinKomut =
        new ÇokluKomut(new Sil("duzey0_dosya0"),
                       new ÇokluKomut(new Sil("duzey1_dosya0"),
                                      new ÇokluKomut(new Sil("duzey2_dosya0"),
                                                     new Sil("duzey2_dosya1"))));
    derinKomut.işlet();
}

Eğer amaç yukarıdaki Komut gibi temel bir tür değilse veya böyle bir temel zorlama gelecekse o zaman std.variant kullanılabilir. Uyarı: Tabii kimse böyle kod yazmaz, yine dosyadan okunan verinin bir Variant[] dizisine yerleştirildiğini düşünebiliriz:
import std.variant;
 
void main()
{
    Variant[] veriler = [
        Variant([ Variant(["a" : Variant("b"),
                           "x" : Variant([ "c": ["1","2","3"] ] )]),
 
                  Variant([ Variant("t") : "1", Variant('y') : "2" ] ) ] )];
}



d de çok basit bir sonsuz boyutlu array oluşturamamak projenin önüne koca bir engel koydu.

Bunun başka yolları da var. Ama o zaman güvenliği ve hızı gözardı etmiş oluruz (her ikisi de D'nin temel amaçlarındandır).

İstediğim şey sadece
[{"a": "b", "x": {"c": ["1","2","3"]}}, {"t": "1", 'y': "2"}]
gibi içerisinde associative array, array ve string barındırabilen sonsuza dek genişleyebilen bir yapı.

O yapıyı nasıl işleyeceksin? Elemanların teker teker hangi türden olduklarına nasıl karar verebiliriz:
struct EsnekYapı
{
    // ...
}
 
void işle(EsnekYapı[] veri)
{
    // Burada ne yapabiliriz? veri[0]'ın asıl türü nedir?
}
 
void main()
{
    EsnekYapı[] veri;
}
Sonsuza kadar büyüyebilen veri yapıları her dilde yapılabilir. Örneğin Python yorumlayıcısının bile C'de yapılabildiğini biliyoruz. C'den daha üstün olan D'de daha da kolay yapılır.

Bizim on sene önce yazılmış bir C kütüphanemiz var. Örneğin orada şöyle bir birlik kullanılıyor. Bu zaten Variant'ın da perde arkasında uyguladığı yöntemdir. (D kodu olarak gösteriyorum):
import std.stdio;
 
enum Tür { intT, doubleT }
 
struct Veri
{
    Tür tür;
 
    union
    {
        int i;
        double d;
        // ... desteklenen diğer türler ...
    }
}
 
void işle(Veri veri)
{
    final switch (veri.tür) with (Tür) {
    case intT:
        writeln("int işliyorum: ", veri.i);
        break;
 
    case doubleT:
        writeln("double işliyorum", veri.d);
        break;
    }
}
 
void main()
{}
Ek olarak, D'nin derleme zamanı olanakları çok üstün olduğundan, tam da o veri dosyasını taramayı bilen bir tür derleme zamanında bile oluşturulabilir. O zaman bir DSL (domain specific language) uygulamış olunur.

Sonuçta çözüm çok. :)

Ali
Avatar
Salih Dinçer #10
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Bu durumda interface{ } önderliğinde türler arası bir köprü oluşturabiliriz:
interface Köprü { }
 
class Değer(T) : Köprü {
  T s;
  
  this(T s) { this.s = s; }
  
  override
  string toString() const {
    return s.format;
  }
}
 
class Dizi(T) : Köprü {
  T[] d;
  
  this(T[] d) { this.d = d; }
  
  override
  string toString() const {
    return d.format;
  }
}
 
import std.stdio, std.string;
 
void main() {
  Köprü[] Topluluk;
  
          Topluluk ~= new Değer!string("Dünya nüfusu:");
          Topluluk ~= new Değer!short(7);
          Topluluk ~= new Değer!string("Milyar ve içinde yaşayanlar: ");
          Topluluk ~= new Dizi!string(["Ali Çehreli",
                                       "Salih Dinçer",
                                       "Zekeriya Durmuş" ]);
          Topluluk.writeln;
}
Çıktısı:
[Dünya nüfusu:, 7, Milyar ve içinde yaşayanlar: , [Ali Çehreli,Salih Dinçer,Zekeriya Durmuş]]
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
Bu mesaj 2 defa değişti; son değiştiren: Salih Dinçer; zaman: 2012-10-29, 13:20.
Avatar
zekeriyadurmus #11
Kullanıcı başlığı: Talha Zekeriya Durmuş
Üye Eki 2012 tarihinden beri · 701 mesaj · Konum: Samsun/Türkiye
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Ali bey ve Salih bey gerçekten çok teşekkür ediyorum.
Söylediklerinizi uygulamaya başladım.

Kolay gelsin iyi çalışmalar dilerim.
Bilgi meraktan gelir...
acehreli (Moderatör) #12
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4527 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj #9
acehreli:
Ek olarak, D'nin derleme zamanı olanakları çok üstün olduğundan, tam da o veri dosyasını taramayı bilen bir tür derleme zamanında bile oluşturulabilir. O zaman bir DSL (domain specific language) uygulamış olunur.

Onun örneğini hatırladım:

  https://github.com/PhilippeSigaud/Pegged

O sayfada biraz aşağıdaki Usage başlığındaki örneğe bakın. Verilen gramer dizgisini derleme zamanında tarayan ve tam da o grameri bilen bir nesne oluşturan bir çözüm. Olağanüstü. :)

Ali
Avatar
Salih Dinçer #13
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Gerçekten çok hoş, bakar mısınız; bir e-posta adresi veri olarak giriyor ortaya adeta adres defteri yapısı çıkıyor!
mixin(grammar("
Email <- Name '@' Domain
Name <- QualifiedIdentifier
Domain <- QualifiedIdentifier
"));

auto p = Email.parse("john.doe@example.org");

writeln(p);
Çıktısı:
Email: ["john.doe", "example.org"]
Name: ["john.doe"]
Domain: ["example.org"]
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
Avatar
Salih Dinçer #14
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Ancak ben, birlikte çıkardığımız şu interface'li yapıya birazcık taktım...:)

Bilmiyorum, D'de aşağıdaki gibi başka bir benzer yapı meydana getirilebilir miydi? Açıkçası benim gördüğüm; test() isminde bir işleve birden fazla parametre (T[] ... olayı) harika bir şekilde giriyor. Üstelik farklı üç (string, char, int) türde. Sizce bu ilgin değil mi!

Belki de çok esprisi yoktur ama JSON ile birlikte veri taşımak için (container) biçimliş kafta olduğunu düşünyorum...
  import std.stdio, std.string;
 
  alias Köprü[] topluluk;
  void test (in topluluk[] Param ...)
  {
    foreach(p; Param)
    {
      p.writeln;
    }
  }
  
void main ()
{
  topluluk A, B, C; // Eşkenar Üçgen
  { 
    A ~= new Değer!string("Eşkenar Üçgen"); // Nesne İsmi
    A ~= new Değer!char('A');               // Nokta Kimliği
    A ~= new Dizi!int([200, 50]);           // X ve Y Noktası
 
    B ~= new Değer!string("Eşkenar Üçgen"); // Nesne İsmi
    B ~= new Değer!char('B');               // Nokta Kimliği
    B ~= new Dizi!int([50, 350]);           // X ve Y Noktası
 
    C ~= new Değer!string("Eşkenar Üçgen"); // Nesne İsmi
    C ~= new Değer!char('C');               // Nokta Kimliği
    C ~= new Dizi!int([350, 350]);          // X ve Y Noktası
  }         
  test(A, B, C);
}
Çıktısı:
[Eşkenar Üçgen, A, [200,50]]
[Eşkenar Üçgen, B, [50,350]]
[Eşkenar Üçgen, C, [350,350]]
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
Avatar
Salih Dinçer #15
Üye Ock 2012 tarihinden beri · 1912 mesaj · Konum: İstanbul
Grup üyelikleri: Üyeler
Profili göster · Bu konuya bağlantı
Tamam, tekrar düşündüm de ...
struct Point {
  string name;
  char id;
  int[] points
} Point A, B, C;
... yapısıyla pekala bir özelleştirilmiş tür tanımlayabiliyoruz. Ancak önemli bir fark var!

Biz sadece iki sınıf ile, D'deki herhangi bir, iki üç ... türü alıp hızlı ve basit bir şekilde bir yapı (taşıyıcı, topluluk) yapabiliyoruz. Bu ilginç değil mi? Yani çok güzel bir şeymiş...:)
Bilgi paylaştıkça bir bakmışız; kar topu olmuş ve çığ gibi üzerimize geliyor...:)
Doğrulama Kodu: VeriCode Lütfen resimde gördüğünüz doğrulama kodunu girin:
İfadeler: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O
Özel Karakterler:
Sayfa:  1  2  3  sonraki 
Forum: Ders Arası RSS
Bağlı değilsiniz. · Şifremi unuttum · ÜYELİK
This board is powered by the Unclassified NewsBoard software, 20100516-dev, © 2003-10 by Yves Goergen
Şu an: 2017-11-18, 22:38:04 (UTC -08:00)