C # ile Java'nın üçlü operatörü (? :) arasındaki fark

Ben bir C # acemiyim ve sadece bir sorunla karşılaşıyorum. Üçlü operatör ( ? :) ile çalışırken C # ve Java arasında bir fark vardır .

Aşağıdaki kod segmentinde, 4. satır neden çalışmıyor? Derleyici bir hata mesajı gösteriyor there is no implicit conversion between 'int' and 'string'. 5. satır da çalışmıyor. İkisi Listde nesne, değil mi?

int two = 2;
double six = 6.0;
Write(two > six ? two : six); //param: double
Write(two > six ? two : "6"); //param: not object
Write(two > six ? new List<int>() : new List<string>()); //param: not object

Ancak, aynı kod Java'da çalışır:

int two = 2;
double six = 6.0;
System.out.println(two > six ? two : six); //param: double
System.out.println(two > six ? two : "6"); //param: Object
System.out.println(two > six ? new ArrayList<Integer>()
                   : new ArrayList<String>()); //param: Object

C # 'da hangi dil özelliği eksik? Varsa neden eklenmedi?

İçinden bakıldığında C 5. Dil Şartname bölüm 7.14: Koşullu Operatör şu görebiliriz:

• X tipi X ve y tipi Y ise

  • X'ten Y'ye örtük bir dönüşüm (§6.1) varsa, ancak Y'den X'e değilse, o zaman Y koşullu ifadenin türüdür.

  • Y'den X'e örtük bir dönüştürme (§6.1) varsa, ancak X'ten Y'ye değilse, X, koşullu ifadenin türüdür.

  • Aksi takdirde, hiçbir ifade türü belirlenemez ve derleme zamanı hatası oluşur

Başka bir deyişle: x ve y'nin birbirine dönüştürülüp dönüştürülemeyeceğini bulmaya çalışır ve değilse bir derleme hatası oluşur. Bizim durumumuzda intve stringaçık veya örtük bir dönüşüme sahip olmadığımız için derlenmeyecek.

Bunu Java 7 Dil Spesifikasyonu bölüm 15.25: Koşullu Operatör ile karşılaştırın :

• İkinci ve üçüncü işlenenler aynı türe sahipse (boş tip olabilir), o zaman bu koşullu ifadenin türüdür. ( HAYIR )
• İkinci ve üçüncü işlenenlerden biri T ilkel tipindeyse ve diğerinin türü, T'ye kutu dönüşümü (§5.1.7) uygulamanın sonucuysa, koşullu ifadenin türü T'dir ( NO ).
• İkinci ve üçüncü işlenenlerden biri boş türdeyse ve diğerinin türü başvuru türündeyse, koşullu ifadenin türü bu başvuru türüdür. ( HAYIR )
• Aksi takdirde, ikinci ve üçüncü işlenenler sayısal türlere dönüştürülebilir (§5.1.8) türlere sahipse, birkaç durum söz konusudur: ( NO )
• Aksi takdirde, ikinci ve üçüncü operandlar sırasıyla S1 ve S2 tiplerindedir. T1'in S1'e boks dönüşümünün uygulanmasından kaynaklanan tür olmasına izin verin ve T2, S2'ye boks dönüşümü uygulamasından kaynaklanan tür olsun.
  Koşullu ifadenin türü, yakalama dönüşümünün (§5.1.10) lub (T1, T2) (§15.12.2.7) 'e uygulanmasının sonucudur. ( EVET )

Ve bölüm 15.12.2.7'ye bakın. Gerçek Argümanlara Dayalı Çıkarsama Tür Argümanları, onunla birlikte gelen çağrı için kullanılan tür olarak hizmet verecek ortak bir ata bulmaya çalıştığını görebiliriz Object. Object olan çağrı işe yarar böylece kabul edilebilir bir argüman.

Verilen cevaplar iyi; Onlara, bu C # kuralının daha genel bir tasarım kılavuzunun sonucu olduğunu ekleyeceğim. Birkaç seçenekten birinden bir ifadenin türünü çıkarması istendiğinde, C # bunların en iyi benzersizini seçer . Yani, C # "Zürafa, Memeli, Hayvan" gibi bazı seçenekler verirseniz, o zaman koşullara bağlı olarak en genel olanı - Hayvan - veya en spesifik olanı - Zürafayı - seçebilir. Ama aslında kendisine verilen seçeneklerden birini seçmesi gerekiyor . C # asla "seçimlerim Kedi ve Köpek arasındadır, bu nedenle Hayvanın en iyi seçim olduğu sonucuna varacağım" demez. Bu verilen bir seçim değildi, bu yüzden C # onu seçemez.

Üçlü operatör durumunda C # daha genel bir int ve string türünü seçmeye çalışır, ancak ikisi de daha genel olanı seçmez. Nesne gibi ilk etapta tercih edilmeyen bir türü seçmek yerine, C # hiçbir türün çıkarılamayacağına karar verir.

Ayrıca bunun C # 'ın başka bir tasarım ilkesine uygun olduğunu da not ediyorum: bir şey yanlış görünüyorsa, geliştiriciye söyleyin. Dil "Ne demek istediğini tahmin edeceğim ve yapabiliyorsam karıştıracağım" demiyor. Dil, "Burada kafa karıştırıcı bir şey yazdığınızı düşünüyorum ve size bundan bahsedeceğim" diyor.

Ayrıca, C # dan nedeni olmadığına dikkat değişkene göre atanan değerin , onun yerine başka yönü. C # "bir nesne değişkenine atıyorsunuz, bu nedenle ifade nesneye dönüştürülebilir olmalıdır, bu nedenle öyle olduğundan emin olacağım" demez. Bunun yerine, C #, "bu ifadenin bir türü olmalı ve türün nesneyle uyumlu olduğu sonucuna varabilmeliyim" diyor. İfadenin tipi olmadığı için hata üretilir.

Jenerik kısımla ilgili olarak:

two > six ? new List<int>() : new List<string>()

C # 'da, derleyici sağ taraftaki ifade parçalarını bazı yaygın tiplere dönüştürmeye çalışır ; çünkü List<int>ve List<string>iki farklı inşa türleri vardır, biri diğerine dönüştürülemez.

Java'da, derleyici dönüştürmek yerine ortak bir süper tip bulmaya çalışır , bu nedenle kodun derlenmesi, joker karakterlerin ve tür silmenin örtük kullanımını içerir ;

two > six ? new ArrayList<Integer>() : new ArrayList<String>()

derleme türüne sahiptir ArrayList<?>(aslında, aynı zamanda olabilir ArrayList<? extends Serializable>veya ArrayList<? extends Comparable<?>>kullanım bağlamına bağlı olarak, her ikisi de ortak jenerik süper tiplerdir) ve çalışma zamanı türü raw ArrayList(ortak ham süper tip olduğu için).

Örneğin (kendiniz test edin) ,

void test( List<?> list ) {
    System.out.println("foo");
}

void test( ArrayList<Integer> list ) { // note: can't use List<Integer> here
                                 // since both test() methods would clash after the erasure
    System.out.println("bar");
}

void test() {
    test( true ? new ArrayList<Object>() : new ArrayList<Object>() ); // foo
    test( true ? new ArrayList<Integer>() : new ArrayList<Object>() ); // foo 
    test( true ? new ArrayList<Integer>() : new ArrayList<Integer>() ); // bar
} // compiler automagically binds the correct generic QED

Hem Java hem de C # (ve diğer birçok dilde), bir ifadenin sonucunun bir türü vardır. Üçlü operatör durumunda, sonuç için değerlendirilen iki olası alt ifade vardır ve her ikisi de aynı türe sahip olmalıdır. Java söz konusu olduğunda, bir intdeğişken Integerotomatik kutulama ile dönüştürülebilir . Şimdi hem beri Integerve Stringgelen inherit Object, bunlar basit daralması dönüşüm ile aynı türe dönüştürülebilir.

Öte yandan, C # 'da an intilkeldir ve örtük stringveya başka bir dönüştürme yoktur object.

Bu oldukça basittir. String ve int arasında örtük bir dönüşüm yoktur. üçlü operatörün son iki işlenenin aynı türe sahip olması gerekir.

Deneyin:

Write(two > six ? two.ToString() : "6");