Різниця між C # та тернарним оператором Java (? :)

Я новачок на C #, і я просто стикаюся з проблемою. Існує різниця між C # та Java, коли йдеться про тернарний оператор ( ? :).

Чому в наступному сегменті коду 4-й рядок не працює? Компілятор показує повідомлення про помилку there is no implicit conversion between 'int' and 'string'. 5-й рядок також не працює. Обидва Lists є об'єктами, чи не так?

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 # відсутня? Якщо є, чому її не додають?

Переглядаючи розділ 7.14 Специфікація мови C # 5: Умовний оператор, ми можемо побачити наступне:

• Якщо x має тип X, а y - тип Y, тоді

  • Якщо неявне перетворення (§6.1) існує з X на Y, але не з Y на X, тоді Y є типом умовного виразу.

  • Якщо неявне перетворення (§6.1) існує з Y на X, але не з X на Y, тоді X є типом умовного виразу.

  • В іншому випадку неможливо визначити тип виразу, і виникає помилка під час компіляції

Іншими словами: він намагається знайти, чи не можна x і y перетворити на один одного, а якщо ні, то виникає помилка компіляції. У нашому випадку , intі stringне мають ніякого явного або неявного перетворення , тому він не буде компілюватися.

Порівняйте це з розділом 15.25 специфікації мови Java 7: Умовний оператор :

• Якщо другий і третій операнди мають однаковий тип (який може бути нульовим типом), то це тип умовного виразу. ( НІ )
• Якщо один із другого та третього операндів має примітивний тип T, а тип іншого є результатом застосування бокс-перетворення (§5.1.7) до T, то типом умовного виразу є T. ( NO )
• Якщо один із другого та третього операндів має нульовий тип, а тип іншого - тип посилання, то тип умовного виразу є тим типом посилання. ( НІ )
• В іншому випадку, якщо другий і третій операнди мають типи, які можна конвертувати (§5.1.8) у числові типи, то існує кілька випадків: ( НІ )
• В іншому випадку другий та третій операнди мають типи 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 # ніколи не говорить "мій вибір між Кішкою та Собакою, тому я буду робити висновок, що Тварина - найкращий вибір". Це не був вибір, тому C # не може його вибрати.

У випадку з тернарним оператором C # намагається вибрати більш загальний тип int та string, але не є більш загальним типом. Замість того, щоб вибрати тип, який спочатку не був вибором, наприклад, об'єкт, C # вирішує, що жоден тип не можна зробити висновком.

Я також зазначаю, що це відповідає іншому принципу дизайну C #: якщо щось виглядає неправильно, повідомте розробника. Мова не говорить "Я збираюся вгадати, що ти мав на увазі, і поплутати, якщо зможу". Мова говорить: "Я думаю, ви написали тут щось заплутане, і я розповім вам про це".

Крім того, я зауважу, що C # не міркує зі змінної до призначеного значення , а скоріше в іншому напрямку. C # не говорить "ви призначаєте змінну об'єкта, тому вираз повинен бути конвертованим до об'єкта, тому я переконаюсь, що він є". Швидше за все, C # говорить "цей вираз повинен мати тип, і я повинен мати змогу зробити висновок, що тип сумісний з об'єктом". Оскільки вираз не має типу, виникає помилка.

Щодо загальної частини:

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

У C # компілятор намагається перетворити праві частини виразу на якийсь загальний тип; оскільки List<int>і List<string>є двома різними побудованими типами, один не може бути перетворений в інший.

У Java компілятор намагається знайти загальний супертип замість перетворення, тому компіляція коду передбачає неявне використання символів підстановки та стирання типу ;

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

має тип компіляції ArrayList<?>(насправді, це може бути також, ArrayList<? extends Serializable>або ArrayList<? extends Comparable<?>>, залежно від контексту використання, оскільки вони є як загальними загальними супертипами), так і типом середовища виконання ArrayList(оскільки це загальний супертип типу raw).

Наприклад (протестуйте самі) ,

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 # (і в більшості інших мов) результат виразу має тип. У випадку тернарного оператора існує два можливих підвирази, що обчислюються для результату, і обидва повинні мати однаковий тип. У випадку з Java intзмінна може бути перетворена в Integerавто за допомогою автобоксу. Тепер, оскільки обидва Integerта Stringуспадковують від Object, вони можуть бути перетворені в один і той же тип шляхом простого звуження перетворення.

З іншого боку, в C # an intє примітивом, і не існує неявного перетворення stringабо будь-якого іншого object.

Це досить просто. Немає неявного перетворення між рядком та int. тернарному оператору потрібні два останні операнди, щоб мати однаковий тип.

Спробуйте:

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