ความแตกต่างระหว่าง C # และตัวดำเนินการ ternary ของ Java (? :)

ฉันเป็นมือใหม่ C # และฉันเพิ่งพบปัญหา มีความแตกต่างระหว่าง C # และ Java เมื่อจัดการกับตัวดำเนินการ ternary ( ? :)

ในส่วนรหัสต่อไปนี้เหตุใดบรรทัดที่ 4 จึงไม่ทำงาน คอมไพเลอร์แสดงข้อความแสดงข้อผิดพลาดของthere is no implicit conversion between 'int' and 'string'. บรรทัดที่ 5 ก็ใช้ไม่ได้เช่นกัน ทั้งสองListเป็นวัตถุไม่ใช่เหรอ?

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

อย่างไรก็ตามรหัสเดียวกันทำงานใน Java:

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 # หายไป ถ้ามีทำไมถึงไม่เพิ่ม?

เมื่อพิจารณาถึงข้อกำหนดภาษา C # 5 ส่วน 7.14: ตัวดำเนินการตามเงื่อนไขเราจะเห็นสิ่งต่อไปนี้:

• ถ้า x มีประเภท X และ y มีประเภท Y แล้ว

  • หากการแปลงโดยนัย (§6.1) มีอยู่จาก X เป็น Y แต่ไม่ใช่จาก Y ถึง X ดังนั้น Y จะเป็นประเภทของนิพจน์เงื่อนไข

  • หากการแปลงโดยปริยาย (§6.1) มีอยู่จาก Y เป็น X แต่ไม่ใช่จาก X เป็น Y ดังนั้น X คือประเภทของนิพจน์เงื่อนไข

  • มิฉะนั้นจะไม่สามารถกำหนดประเภทนิพจน์ได้และเกิดข้อผิดพลาดเวลาคอมไพล์

กล่าวอีกนัยหนึ่ง: มันพยายามค้นหาว่า x และ y สามารถแปลงเป็นกันและกันได้หรือไม่และถ้าไม่เกิดข้อผิดพลาดในการคอมไพล์ ในกรณีของเราintและstringไม่มีการแปลงอย่างชัดเจนหรือโดยปริยายดังนั้นจะไม่รวบรวม

ตรงกันข้ามกับข้อกำหนดภาษา Java 7 ส่วนที่ 15.25: Conditional Operator :

• ถ้าตัวถูกดำเนินการที่สองและสามมีชนิดเดียวกัน (ซึ่งอาจเป็นประเภทว่าง) นั่นคือชนิดของนิพจน์เงื่อนไข ( ไม่ )
• ถ้าตัวถูกดำเนินการตัวที่สองและตัวที่สามเป็นแบบดั้งเดิม T และอีกประเภทหนึ่งเป็นผลมาจากการใช้การแปลงมวย (§5.1.7) เป็น T ประเภทของนิพจน์เงื่อนไขคือ T. ( NO )
• ถ้าตัวถูกดำเนินการตัวที่สองและตัวที่สามเป็นประเภท null และอีกประเภทหนึ่งเป็นประเภทการอ้างอิงประเภทของนิพจน์เงื่อนไขคือประเภทอ้างอิงนั้น ( ไม่ )
• มิฉะนั้นหากตัวถูกดำเนินการที่สองและสามมีประเภทที่สามารถแปลงได้ (§5.1.8) เป็นประเภทตัวเลขจะมีหลายกรณี: ( NO )
• มิฉะนั้นตัวถูกดำเนินการที่สองและสามเป็นประเภท S1 และ S2 ตามลำดับ ให้ T1 เป็นประเภทที่เกิดจากการใช้การแปลงมวยเป็น S1 และให้ T2 เป็นประเภทที่เป็นผลมาจากการใช้การแปลงมวยเป็น S2
  ประเภทของนิพจน์เงื่อนไขเป็นผลมาจากการใช้การแปลงการดักจับ (§5.1.10) กับ lub (T1, T2) (§15.12.2.7) ( ใช่ )

และดูที่หัวข้อ 15.12.2.7 อาร์กิวเมนต์ประเภทที่อ้างอิงจากอาร์กิวเมนต์จริงเราจะเห็นได้ว่ามันพยายามค้นหาบรรพบุรุษร่วมกันซึ่งจะใช้เป็นประเภทที่ใช้สำหรับการเรียกที่เข้าObjectมา Object เป็นอาร์กิวเมนต์ที่ยอมรับได้ดังนั้นการโทรจึงทำงานได้

คำตอบที่ได้รับนั้นดี ฉันจะเพิ่มให้พวกเขาว่ากฎของ C # นี้เป็นผลมาจากแนวทางการออกแบบทั่วไป เมื่อถามว่าจะสรุปประเภทของการแสดงออกจากหนึ่งในตัวเลือกหลายC # เลือกที่ไม่ซ้ำกันที่ดีที่สุดของพวกเขา นั่นคือถ้าคุณให้ C # ตัวเลือกบางอย่างเช่น "ยีราฟสัตว์เลี้ยงลูกด้วยนมสัตว์" ก็อาจเลือกสัตว์ที่มีลักษณะทั่วไปที่สุดหรืออาจเลือกยีราฟที่เฉพาะเจาะจงที่สุดขึ้นอยู่กับสถานการณ์ แต่ก็ต้องเลือกหนึ่งในตัวเลือกที่ได้รับจริง C # ไม่เคยพูดว่า "ทางเลือกของฉันอยู่ระหว่างแมวกับสุนัขดังนั้นฉันจะสรุปว่า Animal เป็นตัวเลือกที่ดีที่สุด" นั่นไม่ใช่ตัวเลือกที่กำหนดดังนั้น C # จึงไม่สามารถเลือกได้

ในกรณีของตัวดำเนินการ ternary C # พยายามเลือกประเภท int และ string ที่กว้างกว่า แต่ไม่ใช่ประเภททั่วไปมากกว่า แทนที่จะเลือกประเภทที่ไม่ใช่ตัวเลือกในตอนแรกเช่นอ็อบเจกต์ C # ตัดสินใจว่าไม่มีประเภทใดที่สามารถอนุมานได้

ฉันทราบด้วยว่านี่เป็นไปตามหลักการออกแบบอื่นของ C #: หากมีบางอย่างผิดปกติโปรดแจ้งให้ผู้พัฒนาทราบ ภาษานี้ไม่ได้บอกว่า "ฉันจะเดาว่าคุณหมายถึงอะไรและสับสนไปหมดถ้าฉันทำได้" ภาษากล่าวว่า "ฉันคิดว่าคุณเขียนบางอย่างที่น่าสับสนที่นี่และฉันจะบอกคุณเกี่ยวกับเรื่องนั้น"

นอกจากนี้ฉันทราบว่า C # ไม่ได้ให้เหตุผลจากตัวแปรถึงค่าที่กำหนดแต่เป็นทิศทางอื่น C # ไม่ได้ระบุว่า "คุณกำลังกำหนดให้กับตัวแปรออบเจ็กต์ดังนั้นนิพจน์ต้องแปลงเป็นอ็อบเจ็กต์ได้ดังนั้นฉันจะตรวจสอบให้แน่ใจว่าเป็น" แต่ C # บอกว่า "นิพจน์นี้ต้องมีประเภทและฉันต้องสามารถอนุมานได้ว่าประเภทนั้นเข้ากันได้กับวัตถุ" เนื่องจากนิพจน์ไม่มีชนิดจึงเกิดข้อผิดพลาด

เกี่ยวกับส่วนยาสามัญ:

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

ใน C # คอมไพลเลอร์พยายามแปลงส่วนนิพจน์ทางขวามือเป็นประเภททั่วไป เนื่องจากList<int>และList<string>เป็นประเภทที่สร้างขึ้นสองประเภทที่แตกต่างกันประเภทหนึ่งไม่สามารถแปลงเป็นประเภทอื่นได้

ใน Java คอมไพเลอร์พยายามที่จะหา supertype ทั่วไปแทนการแปลงเพื่อรวบรวมของรหัสที่เกี่ยวข้องกับการใช้งานโดยนัยของสัญลักษณ์และลบออกประเภท ;

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

มีประเภทการคอมไพล์เป็นArrayList<?>(อันที่จริงอาจเป็นได้เช่นกันArrayList<? extends Serializable>หรือArrayList<? extends Comparable<?>>ขึ้นอยู่กับบริบทการใช้งานเนื่องจากทั้งสองเป็นซูเปอร์ไทป์ทั่วไปทั่วไป) และประเภทรันไทม์ของดิบArrayList(เนื่องจากเป็นซุปเปอร์ไทป์ดิบทั่วไป)

ยกตัวอย่างเช่น(ทดสอบด้วยตัวคุณเอง) ,

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

ทั้งใน Java และ C # (และภาษาอื่น ๆ ส่วนใหญ่) ผลลัพธ์ของนิพจน์จะมีประเภท ในกรณีของตัวดำเนินการ ternary จะมีนิพจน์ย่อยที่เป็นไปได้สองรายการที่ประเมินสำหรับผลลัพธ์และทั้งสองต้องมีชนิดเดียวกัน ในกรณีของ Java intสามารถแปลงตัวแปรเป็นออIntegerโต้บ็อกซ์ได้ ตอนนี้เนื่องจากทั้งสองIntegerและStringสืบทอดจากObjectพวกเขาสามารถแปลงเป็นประเภทเดียวกันได้โดยการ จำกัด การแปลงอย่างง่าย

บนมืออื่น ๆ , ใน C # ความintเป็นดั้งเดิมและไม่มีการแปลงส่อไปหรืออื่นstring ๆobject

นี่ค่อนข้างตรงไปตรงมา ไม่มีการแปลงโดยนัยระหว่างสตริงและ int ตัวดำเนินการ ternary ต้องการตัวถูกดำเนินการสองตัวสุดท้ายเพื่อให้มีชนิดเดียวกัน

ลอง:

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