C ++ 'D'den daha iyi ne yapar?


135

Son zamanlarda D'yi öğrendim ve dili tanımaya başladım . Ne sunduğunu biliyorum, henüz her şeyi nasıl kullanacağımı bilmiyorum ve D deyimleri hakkında pek bir şey bilmiyorum, ama öğreniyorum.

D'yi severim. Bu, bir şekilde C'ye yönelik büyük bir güncelleme olan ve güzel bir şekilde yapılan hoş bir dildir . Özelliklerin hiçbiri "cıvatalı" görünmüyor, ancak aslında oldukça iyi düşünülmüş ve iyi tasarlanmış.

D'nin C ++ 'ın olması gerektiği gibi olduğunu sık sık duyacaksınız (gereksiz alev savaşlarından kaçınmak için herkesin kendileri için karar vermesinin doğru olup olmadığı sorusunu bırakıyorum). Ayrıca bazı C ++ programcılarından D'nin C ++ 'dan çok daha fazla keyif aldıklarını duydum.

Ben C'yi bildiğim halde C ++ bildiğimi söyleyemem. C ++ 'nın bir dil olarak D'den daha iyi bir şey olduğunu düşünürlerse (her zamanki "daha fazla üçüncü taraf kütüphanesi vardır" veya "daha fazla kaynak var" veya "anlamına gelirse) C ++ ve D'yi tanıyan birinden duymak istiyorum. D ++ 'dan daha fazla C ++ gerektiren işler var ").

D, C ++ 'nın sahip olduğu birçok sorunu gidermek için bazı yetenekli C ++ programcıları ( Walter Bright ve Andrei Alexandrescu , D topluluğunun yardımıyla) tarafından tasarlandı, ancak gerçekte daha iyi bir şey olmadı mı? Kaçırdığı bir şey mi? Sence daha iyi bir çözüm değil mi?

Ayrıca, D 1.0 hakkında değil, D 2.0 hakkında konuştuğumu unutmayın .


15
D topluluğunun bunu gördüğünden emin oldum, çünkü buralarda D devlerinden çok daha fazla C ++ dev var. Bu şekilde daha ilginç veya en azından çeşitli cevaplara sahip olacaksınız.
Klaim

7
Ayrıca D2, Walter Bright tarafından tasarlandı ancak Alexandrescu ile birlikte tasarlandı. Sorunuzla bunu düzeltmek isteyebilirsiniz.
Klaim

2
@Klaim: D'de ve standart kütüphanede çok fazla topluluk katılımı vardı (ve hala var).
Michal Minich,

28
@Anto Bir dil olarak, C ++ 'ı, programcı, hayatından nefret etmede D'den çok daha iyidir.
Arlen

6
@jokoon: Aslında, evet, çok az çalışma ile: digitalmars.com/d/2.0/interfaceToC.html
Anto

Yanıtlar:


124

C ++ 'nın "D" den daha iyi yaptığı şeylerin çoğu meta şeylerdir: C ++ daha iyi derleyicilere, daha iyi araçlara, daha olgun kütüphanelere, daha fazla ciltlemeye, daha fazla uzmana, daha fazla öğreticiye vs. sahiptir. daha olgun bir dilden bekleyecektim. Bu tartışılmaz.

Dilin kendisinde, C ++ 'ın D'den daha iyi yaptığını düşünüyorum. Muhtemelen daha fazlası var, ama işte kafamın üstünden listeleyebileceğim birkaç tane:

C ++ daha iyi düşünülmüş
bir tip sisteme sahiptir. D'deki tip sistemde, tasarımda göze çarpmayan görünen birkaç problem vardır. Örneğin, eğer const geçişi ve postblit kurucuların değer türleri üzerinde çalışma şekli nedeniyle sınıf nesne referansları veya işaretçiler içeriyorsa, const yapısını const olmayan bir yapıya kopyalamak imkansızdır. Andrei, bunun nasıl çözüleceğini bildiğini ancak hiçbir ayrıntı vermediğini söyledi. Sorun kesinlikle çözülebilir (C ++ stili kopya kurucuları tanıtmak bir düzeltme olurdu), ancak şu anda dilde büyük bir sorundur.

Beni rahatsız eden diğer bir problem ise mantıksal yapının olmaması (yani mutableC ++ 'da olduğu gibi). İş parçacığı güvenli kod yazmak için bu harika, ancak const nesneleri içinde tembel bir intibalizasyon yapmayı zorlaştırıyor (imkansız mı?) (İlk çağrıda döndürülen değeri oluşturan ve önleyen const 'get' işlevini düşünün).

Son olarak, bu mevcut sorunlar göz önüne alındığında, ben tip sisteminin (geri kalanı nasıl endişeleniyorum pure, sharedkullanmayı yürürlüğe girdiğinde, vs.) dilinde her şey ile etkileşim. Standart kütüphane (Phobos) şu anda D'nin gelişmiş tip sistemini çok az kullanıyor, bu yüzden stres altında tutup durmayacağı sorusunun makul olduğunu düşünüyorum. Şüpheci ama iyimserim.

C ++ 'ın biraz çirkin kılan bazı tip sistem siğilleri (örneğin, geçişsiz konstüzler iteratorgibi const_iterator) olmasına dikkat edin, ancak C ++' nın tip sistemi parçalarda biraz yanlış olsa da, D's gibi bir iş yapmanıza engel olmaz bazen yapar.

Düzenleme: Açıklığa kavuşturmak için, C ++ 'ın daha iyi düşünülmüş tipte bir sisteme sahip olduğunu düşünüyorum - mutlaka daha iyi bir sistem değil - eğer mantıklıysa. Temel olarak, DI'de, tip sisteminin C ++ 'da bulunmayan tüm yönlerini kullanma riskinin olduğunu düşünün.

D bazen biraz fazla rahattır
C ++ 'ı sık sık duyduğunuza dair bir eleştiri, bazı düşük seviyeli sorunları sizden gizlemektir, örneğin, basit görevler a = b;, dönüşüm işleçlerini çağırmak, aşırı yük işleçlerini çağırmak, vb. Gibi birçok şeyi yapabilir. koddan görmek zor. Bazı insanlar böyle, bazıları değil. Her iki şekilde de, D öyle kötü (daha iyi?) Nedeniyle gibi şeylere opDispatch, @property, opApply, lazybeklemediğiniz şeylerin içine masum görünümlü kodunu değiştirmek potansiyeline sahiptir.

Bunun kişisel olarak büyük bir sorun olduğunu sanmıyorum, ancak bazıları bunu telafi edici bulabilir.

D çöp toplama işlemi gerektirir
Bu tartışmalı olarak görülebilir, çünkü GC olmadan D çalıştırmak mümkündür. Ancak, bunun mümkün olması, pratik olduğu anlamına gelmez. GC olmadan, birçok D özelliğini kaybedersiniz ve standart kütüphaneyi kullanmak mayın tarlasında yürümek gibidir (hangi fonksiyonların hafıza tahsis ettiğini kim bilir?). Şahsen, D'yi GC'siz kullanmanın tamamen pratik olmadığını düşünüyorum ve eğer GC'lerin hayranı değilseniz (benim gibi) o zaman bu oldukça zorlayıcı olabilir.

D'deki Naif dizi tanımları hafızayı
ayır Bu benim evcil hayvanlarımdan biri:

int[3] a = [1, 2, 3]; // in D, this allocates then copies
int a[3] = {1, 2, 3}; // in C++, this doesn't allocate

Görünüşe göre, D tahsisini önlemek için yapmanız gerekenler:

static const int[3] staticA = [1, 2, 3]; // in data segment
int[3] a = staticA; // non-allocating copy

Bu küçük 'arkanızdaki' tahsisatlar önceki iki puanımın güzel örnekleridir.

Düzenleme: Bunun üzerinde çalışılmakta olan bilinen bir sorun olduğunu unutmayın.
Düzenleme: Bu şimdi sabittir. Tahsisat yok.

Sonuç
D + C ++ 'nin negatiflerine odaklandım, çünkü sorulan soru buydu, ancak lütfen bu yazıyı C ++' ın D 'den daha iyi olduğunu söyleyen bir ifade olarak görmeyin. C ++ 'dan. Hangisini kullanacağınıza karar vermek size kalmış.


Birkaç yıl önce D'ye baktım (2.0'dan önce). Çöp toplama işlemi o zamanlar gerçekten gerekli değildi - varsayılan olarak oradaydı, ancak düşük seviye kodu seçmeyi tercih edebilirsiniz. Bu konuda yanıldığımı düşündüğüm şey, geri dönmenin bir yolunu bulamamamdı. Örneğin, ağaç tabanlı bir kapta, kitaplık kodu ağaç düğümlerinin belleğini yönetebilir. Bir bütün olarak ağaç hala toplanabilir, IIRC tüm bu düğümleri toplayan bir yıkıcı. Ancak bu kaptaki veriler tarafından başvurulan nesneler de tahsil edilmelidir - ağaçtaki tüm veri öğelerini GC için işaretleyecek bir kanca olmalıdır.
Steve314

3
GC'yi düşük seviye kod için hala devre dışı bırakabilirsiniz - Peter, dilin şu anda ona çok bağlı olduğunu söylüyor. Ayrıca, GC'ye, API: GC.addRange'den core.memory'den yönetilen öbek dışındaki aralıkları taramasını söyleyebilirsiniz .
Vladimir Panteleev

D standart kütüphanesinin çöp toplandığını ve GC-off kodunun kesintisiz bir birlikte çalışma olmadığını belirtmek için +1. Bu düşündüğüm bir şey değil, ama üstesinden gelmek için büyük bir engel gibi görünüyor.
maskon

132

D gelişimine katıldığımda, C ++ hakkında en çok şey bilen insanlardan biri olma özelliğindeydim. Şimdi D hakkında daha fazla şey bilecek insanlardan biri olmak için daha da tuhaf bir pozisyondayım. Bunu merakla merak ettiğim kadarıyla uygun krediye veya palavra haklarına söylemiyorum. bu soruya cevap vermek için avantajlı pozisyon. Aynısı Walter için de geçerlidir.

Genel olarak, C ++ 'dan (ve C ++ 2011'i kastettiğimden) D'den daha iyisini yaptığını sormak, "Evinizi temizlemek için bir profesyonel ödüyorsanız, bırakacakları yerler nedir? öncekinden daha mı kirli? " C ++ 'nın D'nin yapamayacağı değer ne olursa olsun, her zaman bana ve Walter'a hüzünlü bir parmak gibi duruyordu, bu yüzden neredeyse tanımı gereği C ++' ın D'nin ulaşamayacağı hiçbir şeyi yapamazdı.

Dil tasarımında nadiren anlaşılan bir şey (çünkü az sayıda insan gerçekte bazılarını yapma şansına sahiptir), göründüğünden çok daha az zorlanmamış hata olduğu anlamına gelir. Birçoğumuz dil kullanıcısı bazı yapılara veya başkalarına bakıyor ve "Ew! Bu çok yanlış! Ne düşünüyorlardı?" Diyorlar. Meselenin gerçeği, bir dildeki en tuhaf örneklerin hepsi sağlam ve arzu edilen, ancak temel olarak rekabet eden veya birbiriyle çelişen (örneğin modülerlik ve verimlilik, zıtlık ve kontrol vb.) Birkaç temel karardan sonra olmasıdır.

Tüm bunları aklımda tutabileceğim birkaç şeyi sıralayacağım ve her biri için D'nin seçiminin başka bir üst düzey anlaşmayı yerine getirme arzusundan nasıl kaynaklandığını açıklayacağım.

  1. D, tüm nesnelerin biti kopyalanarak kopyalanabileceğini varsayar. Bu, azınlık tasarımları C ++ 'a, özellikle de iç işaretçileri kullananlara, yani kendi içinde işaretçiler içeren bir sınıfa bırakır. (Bu tür bir tasarım, hiçbir verimlilikte veya hiç ihmal edilebilecek maliyette D'ye çevrilebilir, ancak bunun için bir çeviri çabası olacaktır.) Bu kararı, dili büyük ölçüde basitleştirmek, nesne kopyalamayı hiç veya az kullanıcı müdahalesi olmadan daha verimli hale getirmek ve önlemek için karar verdik. tüm kopya inşaat taciri ve değer referansları tamamen bir arada.

  2. D, belirsiz cinsiyet tiplerine (değer veya referans türü olmadığına karar veremeyen) izin vermez. Bu tür tasarımlar oybirliğiyle C ++ 'a çevrilmiş ve hemen hemen her zaman yanlış, ancak bazıları teknik olarak doğru. Bu seçimi yaptık, çünkü çoğunlukla yanlış kodu ve yeniden tasarlanabilecek küçük bir kesir doğru kodunu geçersiz kılıyor. İyi bir takas olduğuna inanıyoruz.

  3. D çoklu kök hiyerarşisine izin vermez. Buradaki bir önceki poster bu özel konu için çok heyecanlandı, ancak bu çok iyi bir temel oluşturuyor ve hepsinin ortak bir kökü olan hiyerarşilere göre köksüz hiyerarşilerin aşikar bir avantajı yok.

  4. D'de örneğin bir int atamazsınız. Atılabilir miras olan bir nesne atmanız gerekir. Hiçbir yarışma D'deki ilişkilerin durumu daha iyi değildir, ama, C ++ 'ın yapabileceği tek şey budur.

  5. C ++ 'da kapsülleme birimi bir sınıftır. D'de bir modül (yani dosya) var. Walter bu kararı iki nedenden dolayı verdi: doğal olarak kapsüllemeyi dosya sistemi koruma anlambilimiyle eşleştirmek ve "arkadaş" ihtiyacını ortadan kaldırmak. Bu seçim D'nin genel modülerlik tasarımına çok iyi entegre olur. Bir şeyleri C ++ 'a benzeyecek şekilde değiştirmek mümkün olabilirdi, ama bu bir şeyleri zorlardı; C ++ 'ın kapsülleme kapsamı seçenekleri, yalnızca C ++' ın fiziksel tasarımı için iyidir.

Bir veya iki küçük şey olabilir, ama genel olarak bu olmalı.


6
@DeadMG: Bunun için C ++ 'da çalışmak için, taşınan nesnenin kendisine işaret eden nesneye bir geri işaretçisi gerekir (böylece kopya oluşturma sırasında güncellenebilir). Durum buysa, D'de işaretçiyi yine de güncellemek için postblit yapıcısını kullanabilirsiniz. Sadece D hakkında bir tartışma yoksa, lütfen D'ye karşı çıkma.
Peter Alexander

13
@Peter: Ömrü kesin olarak kapsama dayalı olsa bile referans olmalı? Dinamik olarak tahsis etmenin yükünü, dolaylı olarak önbellek ve toplama ek yüklerini ziyan etmeliyim çünkü takma adımı vermek istiyorum? Ayrıca, koleksiyonerin eş anlamlı anlambilim için belirleyici bir biçimde toplayabileceğini umuyorum. Bu açıkça kontrol altında değil.
DeadMG

3
@sbi: Bir üst sınıfın varlığı, seçimlerinizi hiç etkilemez. Sınıf tipi kafesde, her zaman bir üst ve bir alt vardır. Alt kısım sadece birkaç dilde açık . Üst kısım (yani Nesne vb.) Daha fazla dilde açıktır. Bu türler her zaman kavramda mevcuttur; Ayrıca erişilebilir olduklarında, dilin kullanıcısına sorun yaşamadan birkaç ekstra olanak sunarlar.
Andrei Alexandrescu

6
@quant_dev: BLAS kullanarak yüksek performanslı doğrusal cebir odaklı iyi durumda bir GSoC projesi olduğunu duymaktan memnun olacaksınız. Ayrıca, test ve kıyaslama amaçları için uygun ilkellerin "saf" uygulamalarını sağlar. İkinci sorunuza cevap vermek için Java, sayısal kütüphaneleri karşılaştırırken çıtayı oldukça düşük tutar. Her zaman yüksek performanslı cebir kitaplarına erişmek için bir JNI bariyerini aşmakta zorlanacak ve Java, operatörün aşırı yüklenmesinden yoksun olduğundan sözdizimi kötü olacaktır.
Andrei Alexandrescu

4
@PeterAlexander: DeadMG tam burada. “Türleri işaretlemek için işaretçiler kullanmamalısınız” açık bir şekilde herhangi bir dilde işaretçilerin genellikle değer türleriyle kullanıldığından (gerçekten Object*geniş çapta kullanılan bir görmeyi bekliyor int*musunuz?) Ve D tamamen görmezden geliyor gibi görünüyor. performans cezası ya da var olmadığını iddia etmek. Bu tabii ki yanlış var - önbellek bayan birçok durumda oldukça dikkat çekicidir, C ++ hep D. üzerinde esneklik avantajına sahip olacak, böylece
Mehrdad

65

D içinde çok nesnel olan bir şey bulmakta zorlanacağınızı düşünüyorum.C ++ 'dan daha kötü. D ile nesnel olarak daha kötü olduğunu söyleyebileceğiniz konuların çoğu, ya uygulama kalitesi kalitesidir (genellikle dilin ve uygulamanın ne kadar genç olduğu ve en geç bir hızda tespit edildiğinden dolayı) ya da bunlar 3. parti kütüphanelerinin eksikliği ile (ki bunlar zamanla gelecek). Dilin kendisi genellikle C ++ 'dan daha iyidir ve bir dil olarak C ++' ın daha iyi olduğu durumlar genellikle ya C ++ 'ın bir yoldan gittiği, D' nin başka bir yoldan gittiği ya da birinin nedenlerinin öznel nedenleri olduğu yerlerde olur. birinin diğerinden daha iyi olduğunu düşünüyorum. Ancak, C ++ 'nın bir dil olarak daha iyi olmasının kesin amaç nedenlerinin sayısının çok az olması muhtemeldir.

Aslında, beynimi gerçekten bir dil olarak C ++ 'nın D'den daha iyi olmasının nedenleriyle ortaya çıkarmak için beynimi sarmak zorundayım.

  1. D'nin Çünkü const geçişli olduğunu ve dil çünkü değişmez , bu çok daha güçlü garantiler vardır C ++ 'ın constGe değil ve anlamı, olamaz var mutable. Mantıksal yapıya sahip olamaz . Yani, D'nin const sistemi ile büyük bir kazanç elde edersiniz, ancak bazı durumlarda, constC ++ 'ta kullanacağınız gibi kullanamazsınız .

  2. D'nin yalnızca bir yayın operatörü var, C ++ ise 4 (C cast operatörünü sayarsanız 5). Bu, genel durumda D'deki yayınlarla uğraşmayı kolaylaştırır, ancak gerçekte ve kardeşlerinin sağladığı ilave komplikasyonları / yararları gerçekten istediğinizde sorunludur const_cast. Ancak D aslında C ++ 'ın yayınlarını uygulamak için şablonlar kullanabilecek kadar güçlüdür, bu yüzden gerçekten onları istiyorsanız, onları alabilir (hatta D'nin standart kütüphanesinde bir noktada bile olabilirler).

  3. D, C ++ 'dan çok daha az sayıda örtülü seçeneğe sahiptir ve iki işlevin birbiriyle çakıştığını bildirme olasılığı çok daha yüksektir (sizi, işlevlerin hangisini kastediyorsanız ya da tam modül yolunu vererek) ). Bazen, bu can sıkıcı olabilir, ancak her türlü işlevi kaçırma sorunlarını önler . Gerçekten demek istediğin işlevi çağırdığını biliyorsun.

  4. D'nin modül sistemi (saymıyorum C ++ 'ın #includes çok temizleyici yolu daha hızlı derleme de), ama bu modüllerin kendileri ötesine Namespacing her türlü yoksun. Bu nedenle, bir modülde bir ad alanı istiyorsanız, Java yoluna gitmeniz ve bir sınıf veya yapı üzerinde statik işlevleri kullanmanız gerekir. Çalışıyor, ancak gerçekten ad alanını istiyorsanız, açıkçası gerçek ad alanından daha temiz değil. Bununla birlikte, çoğu durumda, modüllerin kendilerinin size sağladığı ad alanları bol miktarda bulunur (ve aslında çatışmalar gibi şeyler söz konusu olduğunda oldukça karmaşıktır).

  5. Java ve C # gibi, D çoklu miras yerine tek bir miras var ama Java ve C # aksine, C ++ o sorunların hepsi olmadan aynı etkiyi elde etmek için bazı fantastik yollar sunar 'in çoklu kalıtım sahiptir (ve C ++' ın çoklu kalıtım alabilirsiniz çok dağınık zaman zaman). D'nin sadece arayüzleri yoktur , fakat string karışımlarına , şablon karışımlarına ve diğer adlara sahiptir . Bu nedenle, nihai sonuç tartışmalı olarak daha güçlü ve C ++ 'ın çoklu kalıtımının yaptığı tüm sorunlara sahip değil.

  6. C # 'ya benzer şekilde, D yapıları ve sınıfları ayırır . Sınıflar, kalıtımsal olan ve türetilen referans türlerdir Object, oysa yapılar, kalıtım içermeyen değer türleridir. Bu ayrılık hem iyi hem de kötü olabilir. C ++ 'daki klasik dilimleme probleminden kurtulur ve gerçekten değer tipi olan tiplerin polimorfik olması gerekenlerden ayrılmasına yardımcı olur, ancak ilk önce, en azından, ayrım bir C ++ programcısına rahatsız edici olabilir. Sonuçta, bunun birçok faydası vardır, ancak türlerinizle biraz farklı şekilde başa çıkmanıza zorlar.

  7. Üye fonksiyonları arasında sınıflar varsayılan olarak polimorfik bulunmaktadır. Sanal olmadığını ilan edemezsin . Olabilecek olup olmadığına karar vermek derleyiciye kalmıştır (bu, yalnızca final olmaları ve bir temel sınıftan bir işlevi geçersiz kılmamaları durumunda geçerlidir ). Yani, bu bazı durumlarda bir performans problemi olabilir. Bununla birlikte, polimorfizme gerçekten ihtiyacınız yoksa, tek yapmanız gereken yapıları kullanmaktır ve bu bir sorun değildir.

  8. D yerleşik bir çöp toplayıcısına sahiptir . C ++ 'dan birçoğu ciddi bir olumsuz taraf olarak değerlendirirdi ve şu anda uygulamanın bazı ciddi çalışmalar yapabileceği gerçeği söylenecek. İyileştirildi, ancak henüz Java'nın çöp toplayıcısı ile kesinlikle aynı değil. Ancak, bu iki faktörle azaltılabilir. Birincisi, öncelikle yığın üzerinde yapı ve diğer veri türlerini kullanıyorsanız , o zaman büyük bir sorun değil. Programınız sürekli olarak öbek üzerinde bir şey tahsis etmiyorsa ve tahsis etmiyorsa, iyi olacaktır. Ve ikincisi, sen atlayabilirsiniz çöp toplayıcı isterseniz sadece C'ler kullanmak mallocve free. Bazı dil özellikleri vardır ( dizi dilimleme gibi) Hangi önlemek veya dikkatli olmak gerekir, ve standart kütüphanede bazılarının en azından bazı kullanmadan gerçekten kullanışlı değildir GC (özellikle dize işleme), ancak olabilir çöp toplamayı eğer kullanmadan D'de yazma gerçekten istiyorsun. Yapılması gereken en akıllı şey muhtemelen onu kullanmak ve daha sonra profillemenin performans kritik kod için sorunlara neden olduğunu gösterdiği yerde kullanmaktan kaçınmaktır, ancak isterseniz tamamen tamamen önleyebilirsiniz. Ve GC'nin uygulamasının kalitesi zaman içerisinde artacaktır ve bir GC kullanmanın neden olabileceği endişelerinin çoğunu ortadan kaldıracaktır . Dolayısıyla, sonuçta, GC bu kadar büyük bir problem olmayacak ve Java'nın aksine, isterseniz önleyebilirsiniz.

Muhtemelen başkaları da var, ama şu anda bulabildiğim şey bu. Ve eğer farkedecekseniz, hepsi haindir. Bazı şeyleri C ++ 'dan farklı şekilde yapmayı seçti, C ++' ın bunları nasıl yaptığıyla ilgili kesin avantajları var ama aynı zamanda bazı dezavantajları da var. Hangisi daha iyi yaptığınıza bağlıdır ve çoğu durumda muhtemelen sadece ilk başta daha kötü görünecek ve daha sonra alıştığınızda bir sorun yaşamayacaksınız. Herhangi bir şey varsa, D'deki problemler genellikle diğer dillerin daha önce yapmadığı veya D'nin yaptığı gibi yapmadığı yeni şeylerin neden olduğu yeniler olacaktır. Genel olarak, D, C ++ 'in hatalarından çok iyi öğrendi.

Ve D, bir dil olarak C ++ 'ı o kadar geliştirir ki, genellikle D'nin objektif olarak daha iyi olduğu durumunun böyle olduğunu düşünüyorum.

  1. D şartlı derlemeye sahiptir . Bu, C ++ 'da programlama yaparken çok özlediğim özelliklerden biri. C ++ eklerse, C ++ şablonlara benzer şeyler söz konusu olduğunda sıçramalar ve sınırlamalar ile gelişir.

  2. D derleme zamanı yansımasına sahiptir .

  3. Değişkenler varsayılan olarak iş parçacığı yereldir, ancak olmasını sharedistiyorsanız olabilir. Bu, C ++ 'dan çok daha temiz dişlerle başa çıkmayı sağlar. Tamamen kontrol sende. İş parçacığı arasında iletişim kurmak için iletiyi kullanabilir immutableve mesaj kullanabilir veya değişkenler yapabilir sharedve bunu muteksler ve koşul değişkenleri ile C ++ yöntemiyle yapabilirsiniz. Bu bile, C ++ 'a senkronize edilmiş (C # ve Java'ya benzer) tanıtılmasıyla geliştirilmiştir . D'nin diş açma durumu C ++ 'dan çok daha iyi.

  4. D'nin şablonları C ++ 'ın şablonlarından çok daha güçlüdür ve çok daha kolay, çok daha fazla şey yapmanıza olanak sağlar. Ve şablon kısıtlamaları eklenmesiyle, hata mesajlarıdır yolu onlar C ++ olduklarından daha iyi. D, şablonları çok güçlü ve kullanışlı kılar. Modern C ++ Design'ın yazarının D'nin ana işbirlikçilerinden biri olması tesadüf değil . C ++ şablonlarını D şablonlarına kıyasla ciddiye almayan buluyorum ve C ++ 'da programlama zaman zaman çok sinir bozucu olabiliyor.

  5. D yerleşik sözleşme programlamasına sahiptir .

  6. D dahili bir birim test çerçevesine sahiptir.

  7. D, string(UTF-8), wstring(UTF-16) ve dstring(UTF-32) ile birlikte unicode desteği sağlar . Unicode ile uğraşmayı kolaylaştırır. Ve sadece kullanmak stringve genel olarak unicode hakkında endişelenmek istemiyorsanız , yapabilecekleriniz - unicode'un temellerini biraz anlamak, bazı standart kütüphane fonksiyonlarında yardımcı olabilir.

  8. D'nin operatör aşırı yüklemesi , C ++ 'tan çok daha iyidir, aynı anda birden fazla operatörü aşırı yüklemek için bir fonksiyon kullanmanıza izin verir. Bunun en önemli örneği, temel aritmetik operatörleri aşırı yüklemeniz gerektiğinde ve bunların uygulamaları operatör için aynıdır. String mixins bir esinti yapar ve hepsi için bir tane basit fonksiyon tanımına sahip olmanızı sağlar.

  9. D dizileri C ++ dizilerinden çok daha iyi. Sadece uzunluğu uygun bir tip değiller, eklenebilirler ve yeniden boyutlandırılabilirler. Onları birleştirmek kolaydır. Ve hepsinden önemlisi, dilimleme var . Ve bu verimli dizi işleme için büyük bir nimet. Dizeler, D'deki karakter dizileridir ve bir sorun değildir (aslında harika!) Çünkü D'nin dizileri çok güçlü.

Devamlı gidebilirim. D'nin sağladığı iyileştirmelerin çoğu küçük şeylerdir ( thisbir noktalı virgenin tüm gövdesi olduğu durumlarda ifadeler veya döngü gövdeleri varsa izin vermemek için yapıcı adları için kullanmak gibi ), ancak bazıları oldukça büyüktür ve hepsini bir araya getirdiğinizde çok daha iyi bir programlama deneyimi için yapar . C ++ 0x, D'nin C ++ 'nın (örneğin autove lambdas) eksik olan özelliklerinden bazılarını ekler , ancak tüm geliştirmelerde bile, hala D'den daha nesnel olarak daha iyi bir dil olmayacak.

Birini diğerinden sevmek için pek çok öznel neden olduğu konusunda hiçbir soru yoktur ve D'nin uygulamasının nispi olgunlaşmamışlığı zaman zaman bir sorun olabilir (geç depoları taşındığından beri çok hızlı bir şekilde gelişmiştir ). ve 3. parti kitaplıkların eksikliği kesinlikle bir sorun olabilir (D'nin C işlevlerini kolayca ve daha az ölçüde C ++ işlevlerini çağırabildiği gerçeği , sorunu kesinlikle azaltabilir). Ancak bunlar, dilin kendisiyle ilgili sorunlardan ziyade uygulama sorunlarının kalitesidir. Ve uygulama konularının kalitesi sabitlendiğinden, D kullanımı çok daha keyifli hale gelecektir.

Dolayısıyla, bu sorunun kısa cevabının "çok az" olduğunu varsayalım. D, bir dil olarak, genellikle C ++ 'dan daha üstündür.


2
Çöp toplama dilleri GC olmayan dillere göre 2-5x daha fazla bellek kullanır (Alexandrescu'nun YT konusundaki konuşmasına göre), bu yüzden (mem kullanımı) darboğaz ise kesinlikle bir problemdir.
NoSenseEtAl

9

RAII ve yığın bellek kullanımı

D 2.0, RAII'nin yığında olmasına izin vermez, çünkü yığına scopesınıf örnekleri tahsis edilmesinde anahtar kelimenin değerini kaldırır .

D'de değer türü mirasını yapamazsınız, böylece etkili bir şekilde sizi herhangi bir RAII formu için bir yığın tahsisi yapmaya zorlar.
Yani, kullanmadığınız sürece emplace, ancak bu kullanımı çok acı vericidir çünkü hafızayı elle ayırmanız gerekir. (Henüz emplaceD ' de kullanmayı pratik buldum .)


6

C ++ sizi ayrıntılı olmaya zorlamakta çok daha iyidir. Bu, çıkarımı veya ayrıntılandırmayı sevmenize bağlı olarak, gözlerinizde daha iyi veya daha kötü olabilir.

C ++ ile çalışma zamanı belleğini karşılaştırın :

template <typename ReturnType, typename... Args>
function<ReturnType (Args...)> memoize(function<ReturnType (Args...)> func)
{
    map<tuple<Args...>, ReturnType> cache;
    return ([=](Args... args) mutable {
            tuple<Args...> t(args...);
            return cache.find(t) == cache.end()
                ? cache[t] : cache[t] = func(args...);
    });
}

D de aynı şeyle:

auto memoize(F)(F func)
{
    alias ParameterTypeTuple!F Args;
    ReturnType!F[Tuple!Args] cache;
    return (Args args)
    {
        auto key = tuple(args);
        return key in cache ? cache[key] : (cache[key] = func(args));
    };
}

Örneğin, template <typename ReturnType, typename... Args>versus (F), Args...versus Args, args...versus args, vb. İle ilgili ekstra ayrıntılara dikkat edin .
Daha iyi veya daha kötü için, C ++ daha ayrıntılıdır.

Tabii ki, bunu D de yapabilirsiniz:

template memoize(Return, Args...)
{
    Return delegate(Args) memoize(Return delegate(Args) func)
    {
        Return[Tuple!Args] cache;
        return delegate(Args args)
        {
            auto key = tuple(args);
            return key in cache ? cache[key] : (cache[key] = func(args));
        };
    }
}

ve neredeyse aynı gözükeceklerdi, ama o zaman bu bir gerektirirdi delegate, oysa orijinal çağrılabilir herhangi bir nesneyi kabul etti . (C ++ 0x sürümü birstd::function nesneyi gerektirir , bu nedenle, girişlerinde daha ayrıntılı ve kısıtlayıcı olabilir ... bu da ayrıntılardan hoşlanıyorsanız iyi, eğer istemiyorsanız kötü.


2

D hakkında fazla bir şey bilmiyorum, ama pek çok, birçok C ++ programcısı bundan çok hoşlanmadığımı biliyorum ve şahsen kabul etmek zorundayım - D'nin görünüşünü sevmiyorum ve daha yakından yaklaşmayacağım.

D'nin neden daha fazla çekiş kazanmadığını anlamak için, insanları C ++ 'a çeken şeyi anlayarak başlamanız gerekir. Bir kelimeyle, bir numaralı sebep kontrol. C ++ 'da programladığınızda, programınız üzerinde tam kontrol sahibi olursunuz. Standart kütüphaneyi değiştirmek ister misiniz? Yapabilirsin. Güvenli olmayan işaretçi atmalarını yapmak ister misiniz? Yapabilirsin. Const doğruluğunu ihlal etmek ister misiniz? Yapabilirsin. Bellek ayırıcısını değiştirmek ister misiniz? Yapabilirsin. Ham belleğin türüne bakmadan kopyalamak ister misiniz? Eğer gerçekten istiyorsan. Birden fazla uygulamadan miras almak mı istiyorsunuz? Bu senin cenazen. Kahretsin, Boehm koleksiyoncusu gibi çöp toplama kütüphanelerini bile alabilirsin. O zaman, performansı yakından takip eden, problemleri kontrol eden bir problem var - bir programcının kontrolü ne kadar fazla kontrol ederse, programı o kadar optimize eder.

İşte küçük bir araştırma yaparken ve bunu deneyen birkaç kişiyle konuşurken gördüğüm birkaç şey:

Birleştirilmiş tip hiyerarşi. C ++ kullanıcıları kalıtımı çok nadir kullanır, çoğu C ++ programcısı kompozisyonu tercih eder ve bunu yapmak için çok iyi bir neden varsa, türler yalnızca kalıtım yoluyla bağlanmalıdır. Nesne kavramı, her türü birbirine bağlayarak bu prensibi şiddetle ihlal ediyor. Ayrıca, C ++ 'nın en temel ilkelerinden birini ihlal ediyor - sadece istediğinizi kullanıyorsunuz. Object'ten miras alma konusunda bir seçenek verilmemesi ve bununla birlikte gelen maliyetler, C ++ 'nın programcıya programı üzerinde kontrolü sağlaması açısından bir dil olarak ifade ettiği şeye karşı çok güçlüdür.

Fonksiyon ve delegelerin problemlerini duydum. Görünüşe göre, D hem işlevlere sahiptir ve çalışma zamanı çağrılabilir işlev türleri olarak delege ve aynı değiller ama değiştirilebilir vardır ya ... öyle bir şey? Arkadaşım onlarla epeyce problem yaşadı. Bu kesinlikle C ++ 'dan düşük olan std::functionve sadece sizin yaptığınız gibi.

O zaman uyumluluğun var. D, özellikle C ++ ile uyumlu değildir. Demek istediğim, hiçbir dil C ++ ile uyumlu değildir, bununla yüzleşelim, hile yapan C ++ / CLI hariç, ancak giriş engelleri olarak belirtilmelidir.

O zaman başka şeyler de var. Örneğin, Wikipedia girişini okuyun.

import std.metastrings;
pragma(msg, Format!("7! = %s", fact_7));
pragma(msg, Format!("9! = %s", fact_9));

printfgetsEski C Standart kütüphanesindeki gibi büyük problemlerle aynı ailede, şimdiye kadar tasarlanan en güvenli olmayan fonksiyonlardan biridir . Yığın Taşması ile ilgili arama yaparsanız, yanlış kullanımıyla ilgili birçok soru bulacaksınız. Temel olarak, printfbir DRY ihlalidir- biçim dizesindeki yazıyı veriyorsunuz ve sonra bir argüman verdiğinizde tekrar veriyorsunuz. Eğer yanlış yaparsanız bir DRY ihlali, o zaman çok kötü şeyler oluyor, eğer bir typedef'i bir 16-bit tamsayıdan 32-bit'e değiştirdiyseniz. Ayrıca herkes kendi format belirleyicilerini icat ederse ne olacağını hayal bile edemez. C ++ 'ın akışları yavaş olabilir ve operatör tercihleri ​​en yüksek olmayabilir ve ara yüzleri işi kullanabilir, ancak temel olarak güvenli oldukları garanti edilir ve DRY ihlal edilmez ve kolayca genişletilebilir. Bu söylenebilecek bir şey değil printf.

Çoklu miras yok. Bu çok var değil C ++ yol. C ++ programcıları programları üzerinde tam bir kontrol sahibi olmayı ve miras alamayacağınızı zorlayan dili bu ilkenin ihlali anlamına gelir. Buna ek olarak, kalıtımsallığı (daha da fazla) kırılganlaştırır, çünkü bir türden bir arabirimden bir sınıfa değiştirirseniz, çünkü varsayılan bir uygulama veya bir şey sağlamak istediğinizde, aniden tüm kullanıcı kodunuz bozulur. Bu iyi bir şey değil.

Başka bir örnek stringve wstring. C ++ 'da aralarında dönüşüm yapmak zaten çok acı verici ve bu kütüphane Unicode'u destekliyor mu ve bu eski C kütüphanesi sadece kullanıyor const char*ve istediğiniz dizge argüman türüne bağlı olarak aynı işlevin farklı sürümlerini yazmak zorunda kalıyor . Özellikle, Windows başlıkları, genellikle kendi kodunuzu etkileyebilecek sorunla başa çıkmak için aşırı derecede tahriş edici makrolara sahiptir. dstringKarışıma eklemek , işleri daha da kötüleştirecek, iki dize türü yerine şimdi üçünü yönetmeniz gerekiyor. Birden fazla string tipine sahip olmak bakım ağrılarını artıracak ve stringlerle ilgili tekrarlayan kodlar ortaya çıkaracaktır.

Scott Meyers şöyle yazıyor:

D, programcıların modern yazılım geliştirmenin zorluklarını aşmasına yardımcı olmak için oluşturulmuş bir programlama dilidir. Bunu, hassas arayüzler, birbirine sıkı sıkıya entegre programlama paradigmaları federasyonu, dilin uyguladığı iplik yalıtımı, modüler tip güvenliği, verimli bir bellek modeli ve daha fazlasıyla birbirine bağlanan modülleri teşvik ederek yapar.

Dil tarafından zorlanan iplik yalıtımı bir artı değildir. C ++ programcıları programları üzerinde tam kontrol beklerler ve bir şeyi zorlayan dil doktorun emrettiği gibi değildir.

Ayrıca derleme zamanı string manipülasyonundan da bahsedeceğim. D derleme zamanında D kodunu yorumlama yeteneğine sahiptir. Bu bir artı değil. C'nin tüm deneyimli C ++ programcıları tarafından iyi bilinen, nispeten sınırlı önişlemcisinin neden olduğu büyük baş ağrıları düşünün ve ardından bu özelliğin ne kadar kötüye kullanılacağını hayal edin. Derleme zamanında D kodu oluşturma yeteneği harikadır, ancak sözdizimsel değil, anlamsal olması gerekir .

Ayrıca, belirli bir refleks bekleyebilirsiniz. D, C ++ programcılarının felsefelerde doğrudan karşıt olan Java ve C # gibi dillerle ilişkilendirecekleri çöp koleksiyonuna sahiptir ve sözdizimsel benzerlikleri de bunları akla getirecektir. Bu mutlaka nesnel olarak haklı değildir, ancak kesinlikle belirtilmesi gereken bir şeydir.

Temel olarak, C ++ programcılarının yapamayacağı kadar fazla bir şey sunmuyor. Belki D'de bir faktöryel metaprogram yazmak daha kolay, ama biz olabilir C ++ faktöryel metaprograms zaten yazın. Belki D'de sen yapabilirsiniz derleme zamanı ışın-izleyici yazmak, ama kimse gerçekten Zaten bunu yapmak istiyor. C ++ felsefesinin temel ihlalleriyle karşılaştırıldığında, D'de yapabilecekleriniz özellikle dikkate değer değildir.

Bu şeyler sadece yüzeyde sorun olsa bile, o zaman yüzeydeki D'nin aslında C ++ 'ya hiç bakmadığı gerçeğinden eminim, pek çok C ++ programcının D'ye geçmemesi için iyi bir sebep. Belki de D, kendisini daha iyi tanıtan bir iş ilanına ihtiyaç duyar.


9
@DeadMG: % 100 hatalı ve söyleme noktasını kaçırıyor Bu kesinlikle C ++ 'danstd::function düşmüş , sadece sahip olduğunuzu ve bitirdiniz. Neden? Çünkü ayrıca, örneğin, işlev işaretçilerine de sahipsiniz. Bu var aynen D'nin "işlevleri" fonksiyonu noktalar şunlardır ve D'nin "delegeler" aynıdır C ++ 'ın: D aynı şey std::function(hariç onlar olduğunu dahili). Herhangi bir yerde "düşürme" yoktur - ve aralarında 1: 1 yazışma vardır, bu yüzden C ++ ile aşina iseniz kafa karıştırıcı olmamalıdır.
Mehrdad

10
@Mark Trapp: Konuyla ilgili tavrınızı tam olarak anlamadığımı itiraf etmeliyim - yorumlar bir cevap üzerine yorum yapmak için kullanılmaz.
klickverbot

6
@Mark Trapp: Amacım, buradaki yorumların çoğunun eski olmadığı (özellikle bağladığınız meta tartışma, orijinal gönderiye dahil edilmiş olan önerilere özel olarak uygulanır), ancak halen mevcut olan gönderideki gerçek yanlışlıkları işaret etti. .
klickverbot

7
Formatla ilgili bir not: D'nin format işlevi typesafe'dir (güvenlik / taşma sorunlarını çözer) ve DRY'yi ihlal etmez, çünkü format dizesi, bağımsız değişkenlerin türlerini değil, nasıl biçimlendirilmesi gerektiğini belirtir. Bu D'nin typesafe variadi'leri sayesinde mümkün. Bu nedenle, bu itiraz en azından tamamen geçersizdir.
Justin W

17
@Mark: Onlarla ilgili mevcut politika ne olursa olsun, aptalca buluyorum ve yorum tartışmalarının silinmesini engelliyorum . Sanırım bu cevabın (şimdi ilgilendiğim) geniş tartışmaları oldu, fakat emin değilim ve öğrenecek bir yolum yok. Bağlantılı olduğunuz o odada 10 binin üzerinde mesaj var ve hiçbir şekilde bir tartışma bulma şansım olmadı ama gerçekleştiğini hatırlıyorum ama içeriğini hatırlayamıyorum. Bu cevapla ilgili tartışmalar burada, bu cevapta ve cinsiyet, uyuşturucu ve rock'n'roll tartışmalarında karışabilecekleri bazı sohbet odalarına değil.
sbi

1

C ++ 'da takdir ettiğim bir şey, bir işlev argümanını belgeleme yeteneği ya da bir işaretçi yerine C ++ referansı olarak dönen değeri ifade etmektir, bu nedenle nulldeğer almamak anlamına gelir .

D versiyonu:

class A { int i; }

int foo(A a) {
    return a.i; // Will crash if a is null
}

int main() {
    A bar = null;
    // Do something, forgetting to set bar in all
    // branches until finally ending up at:
    return foo(bar);
}

C ++ sürümü:

class A { int i; };

int foo(A& a) {
    return a.i; // Will probably not crash since
                // C++ references are less likely
                // to be null.
}

int main() {
    A* bar = null;
    // Do something, forgetting to set bar in all
    // branches until finally ending up at:
    // Hm.. I have to dereference the bar-pointer
    // here, otherwise it wont compile.  Lets add
    // a check for null before.
    if (bar)
        return foo(*bar);
    return 0;
}

Dürüst olmak gerekirse, C ++ ' Aa çok D structile girip foo()-argument' i işaretleyerek çok yakın olabilirsiniz ref(sınıflar referans türleridir ve yapılar D'deki değer türleridir, C # 'ya benzer).

Bunun NonNullableyerine D standart kütüphane yapısı olarak sınıflar için bir şablon oluşturma planının olduğuna inanıyorum . Öyle olsa bile, sadece Type&karşılaştırmanın kısayeti hoşuma gidiyor ve NonNullable(Type)varsayılan olarak null edilemez olanı tercih ediyorum ( Typeve gibi bir şey oluştururken Nullable(Type)). Ama bunu değiştirmek için çok geç D ve şimdi konu dışı kalıyorum.


3
Hem fonksiyon argümanları hem de D'deki dönüş değerleri, refC ++ 'nınkilerle aynı efekti vermek için ile işaretlenebilir &. En büyük fark, bunun refolsa bile geçici olmayacağıdır const.
Jonathan M Davis

Referansları yerel değişkenlere döndürmenin D'de yasaklanması hoşuma gidiyor, yorumunuzu okuyana kadar bunun farkında değildim. Ancak, C dereference operatörünün sizi düşündüreceği şekilde düşünmeden yerel olmayan boş bir referansı yine de geri gönderebilirsiniz.
Ağustos'ta

İşleri karıştırıyorsun. Sınıflar daima referanstır ve ref'den ayrıdır. D'deki referanslar Java'daki referanslara benzer. İşaretçiler yönetiliyor. Ref ile geçmek veya geri dönmek, C ++ ile & ile dönmek gibidir. Bir sınıf referansını ref ile geçmek, C ++ 'da bir işaretçiyi & (örn. A * &) ile geçirmek gibidir. Sınıflar yığına girmez. Evet, Nullable olmayan, boş olmadığı garanti edilen bir sınıf referansına sahip olmayı mümkün kılar, ancak bu, ref'den tamamen ayrıdır. C ++ kodunda yapmaya çalıştığınız şey D'de çalışmaz çünkü sınıflar yığına girmez. Yapıları yapar.
Jonathan M Davis,

1
Bu yüzden evet, nullabe olmayan bir sınıf referansına sahip olmak güzel olurdu, ama C ++ gösterdiğiniz şeyi yapmayı başarır çünkü sınıfların yığında olmasına izin verir ve işaretçilerin kuralsızlaştırılmasına izin verir. Ve size ederken olabilir D'de işaretçiler KQUEUE, sınıflar referanslar, değil işaretçiler, bu yüzden onları inceleyebilirsiniz olamaz. Onları yığına koyamayacağınız ve onları haklarından çıkaramayacağınız için, D'ye yerleşik olan ve boş olamayacak bir sınıfa sahip olmanız mümkün değildir. Bu ise bir kayıp, ama nonnullable bunu çözecektir ve yapılar ve sınıflar ayrı ayrı yapılması kazançları zaten genellikle büyüktür.
Jonathan M Davis

2
C ++ referansları dil standardına göre boş olamaz ("muhtemelen boş olmayacaktır" diyerek yanlış olamaz). Keşke boş bir sınıf için geçerli bir değer olarak geçersiz kılmanın bir yolu olsaydı.
jsternberg

1

C ++ 'ın D'den daha iyi yaptığı en önemli şey, eski kütüphanelerle etkileşime girmektir . Çeşitli 3D motorlar, OpenCL ve benzerleri. D yeni olduğu için, aralarından seçim yapabileceğiniz çok az sayıda farklı kitaplık vardır.

C ++ ve D arasındaki bir diğer önemli fark, C ++ 'ın birden fazla finansal olarak bağımsız satıcısına sahip olmasıdır, ancak 2014 itibariyle D , kendisini oluşturan 2 kişilik bir ekipten sadece bir tanesine sahiptir . Projelerin hiçbir zaman teknolojiye bağlı kalmaması gerektiğini söyleyen "ikinci kaynak prensibi" nin ilginç olması ilginçtir, yalnızca bir, tek, satıcıya sahip olan yazılımlara bile sahip görünüyor.

Karşılaştırma için, Ruby tercümanın ilk versiyonu Ruby'nin mucidi, Yukihiro Matsumoto tarafından yazılmıştı, ancak 2014 dönemi ana Ruby tercümanı diğer insanlar tarafından sıfırdan yazılmış. Bu nedenle, Ruby birden fazla finansal olarak bağımsız satıcıya sahip bir dil olarak görülebilir. Diğer yandan D, harika bir teknoloji olabilir, ancak onu geliştiren birkaç geliştiriciye bağlıdır.

Java'nın geçmişi, bir teknoloji, bu durumda, Java'nın iyi fakat bekar bir finansöre sahip olmasına rağmen, büyük kurumsal kullanıcı tabanına bakılmaksızın, teknolojinin esasen atılma riskinin büyük olduğunu gösterir. AK'nin "Yürütme Komitesi" anlamına geldiği Apache Yazılım Vakfı'nın bir alıntı :

Oracle, EC'ye kendi kendine çelişkili, şartnamenin bağımsız uygulamalarının dağıtımını ciddi şekilde kısıtlayan ve en önemlisi şartnamenin bağımsız açık kaynak uygulamalarının dağıtımını yasaklayan Java SE 7 şartname talebini ve lisansını sağlamıştır.

Tarihsel bir not olarak, Java uygulamalarının, HTML5 WebGL'nin geliştirilmesinden yıllar önce 3D tuvalde donanım hızlandırması olduğu söylenebilir. Java bir topluluk projesi olsaydı Java uygulamaları başlangıç ​​hızı sorunu çözülebilirdi, ancak Java'nın tek finansörü Sun Microsystems'ın yöneticileri, Java uygulamasının düzeltilmesi için yeterince önemli bulmadılar. Sonuç: HTML5 tuval, birden çok satıcı tarafından Java GUI çerçevelerinin (Swing, vb.) "Fakir bir adamın kopyası" olduğu anlamına gelir. İlginç bir şekilde, sunucu tarafında Python programlama dili, Java'nın vaat ettiği avantajlarla aynıdır: Python uygulamasının makine koduna derlenmemesi şartıyla, donanımdan bağımsız olarak her sunucuda bir kez yaz. Python, Java kadar yaşlı / genç, ancak Java'nın aksine

Özet:

Üretim kullanımı için teknolojiyi değerlendirirken, teknolojilerin en önemli özellikleri, onu geliştiren insanlar, geliştirmenin gerçekleştiği sosyal süreç ve finansal olarak bağımsız geliştirme ekiplerinin sayısıdır.

T1 teknolojisinin T2 üzerinden kullanılmasının daha avantajlı olup olmadığı, teknolojilerin tedarikçilerine ve T1 teknolojisinin proje ile ilgili sorunları T2'den daha ucuza çözmesine izin verip vermediğine bağlıdır. Örneğin, tek tedarikçi sorunu göz ardı edildiyse, bilgi sistemleri için Java, C ++ 'dan daha iyi bir teknoloji olacaktır, çünkü Java ikili dosyalarının dağıtımda yeni donanıma ve bellek yönetimi ile ilgili yazılım geliştirme çalışmalarına yeniden derlenmesi gerekmez Java için C ++ 'dan daha küçüktür. Sıfırdan geliştirilen projeler, örneğin diğer kütüphanelere bağlı olmayan projeler, D + 'da geliştirilmeleri C ++' dan daha ucuz olabilir, ancak öte yandan, C ++ 'ın birden fazla satıcısı vardır ve bu nedenle uzun vadede daha az risklidir. . (Sun Microsystems'in neredeyse tamam olduğu Java örneği,

Bazı C ++ sınırlamaları için olası bir geçici çözüm

C ++ 'nın bazı sınırlamalarına yönelik olası çözümlerden biri, ilk görevin parçalara ayrıldığı ve parçaların "sıralandığı" (sınıflandırılmış, kümelenmiş, bölünmüş, diğer güzel kelimeler için) tasarlandığı bir tasarım deseni kullanmaktır. Aynı şey) 2 sınıfa: kontrol mantığı ile ilgili görevleri kontrol edin , burada hafıza erişim düzenleri yerelliklere izin vermiyor; yerellik kolayca elde edilebiliyorsa, işaret işleme benzeri görevler . Sinyal işleme "benzeri" görevleri, nispeten basit konsol programları kümesi olarak uygulanabilir. Kontrol mantığıyla ilgili görevlerin tümü, Ruby veya Python ile yazılmış tek bir komut dosyasına veya yazılım geliştirme rahatlığının hızdan daha yüksek önceliğe sahip olduğu bir şeye yerleştirilir.

Pahalı işletim sistemi işlem başlatma ve işletim sistemi işlemleri arasında veri kopyalanmasını önlemek için, küçük C ++ konsol uygulamaları kümesi Ruby / Python / etc tarafından "servlet" olarak başlatılan tek bir C ++ programı olarak uygulanabilir. senaryo. Ruby / Python / etc. komut dosyası çıkıştan önce sunucu uygulamasını kapatır. "Servlet" ve Ruby / Python / etc arasındaki iletişim. komut dosyası, pipe veya benzeri bir mekanizma adlı bir Linux üzerinde gerçekleşiyor.

İlk görev, yukarıda bahsedilen 2 sınıfa sınıflandırılabilecek parçalara kolayca bölünmesi için kendisini ödünç vermezse, denenecek bir şey sorunu yeniden ifade etmek ve ilk görevin değişmesi olabilir.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.