Różnica między C # a operatorem trójargumentowym Javy (? :)

Jestem nowicjuszem w C # i właśnie napotykam problem. Istnieje różnica między językiem C # a Javą, gdy mamy do czynienia z operatorem trójargumentowym ( ? :).

W następującym segmencie kodu, dlaczego czwarta linia nie działa? Kompilator wyświetla komunikat o błędzie there is no implicit conversion between 'int' and 'string'. Piąta linia również nie działa. Oba Listsą obiektami, prawda?

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

Jednak ten sam kod działa w Javie:

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

Jakiej funkcji języka w C # brakuje? Jeśli tak, dlaczego nie jest dodany?

Przeglądając specyfikację języka C # 5 w sekcji 7.14: Operator warunkowy , widzimy:

• Jeśli x ma typ X, a y ma typ Y, to

  • Jeśli niejawna konwersja (§6.1) istnieje od X do Y, ale nie od Y do X, wtedy Y jest typem wyrażenia warunkowego.

  • Jeśli niejawna konwersja (§6.1) istnieje od Y do X, ale nie od X do Y, wtedy X jest typem wyrażenia warunkowego.

  • W przeciwnym razie nie można określić żadnego typu wyrażenia i wystąpi błąd w czasie kompilacji

Innymi słowy: próbuje znaleźć, czy x i y mogą zostać zamienione na siebie nawzajem, a jeśli nie, wystąpi błąd kompilacji. W naszym przypadku inti stringnie ma wyraźnej lub dorozumianej konwersji, więc nie będzie skompilować.

Porównaj to ze specyfikacją języka Java 7 w sekcji 15.25: Operator warunkowy :

• Jeśli drugi i trzeci operand mają ten sam typ (który może być typem zerowym), to jest to typ wyrażenia warunkowego. ( NIE )
• Jeśli jeden z drugiego i trzeciego operandu jest typu pierwotnego T, a typ drugiego jest wynikiem zastosowania konwersji pudełkowej (§5.1.7) do T, to typ wyrażenia warunkowego to T. ( NIE )
• Jeśli jeden z drugiego i trzeciego operandu jest typu null, a drugi jest typem referencyjnym, to typ wyrażenia warunkowego jest typem referencyjnym. ( NIE )
• W przeciwnym razie, jeśli drugi i trzeci operand mają typy, które można zamienić (§5.1.8) na typy liczbowe, istnieje kilka przypadków: ( NIE )
• W przeciwnym razie drugi i trzeci operand są odpowiednio typu S1 i S2. Niech T1 będzie typem wynikającym z zastosowania konwersji pudełkowej do S1 i niech T2 będzie typem, który wynika z zastosowania konwersji pudełkowej do S2.
  Typ wyrażenia warunkowego jest wynikiem zastosowania konwersji przechwytywania (§5.1.10) do lub (T1, T2) (§15.12.2.7). ( TAK )

Patrząc na sekcję 15.12.2.7. Wnioskowanie o argumentach typu Na podstawie rzeczywistych argumentów widzimy, że próbuje znaleźć wspólnego przodka, który posłuży jako typ użyty do wywołania, z którym się kończy Object. Object jest dopuszczalnym argumentem, więc wywołanie będzie działać.

Podane odpowiedzi są dobre; Dodam do nich, że ta reguła języka C # jest konsekwencją bardziej ogólnych wytycznych projektowych. Gdy C # poprosi o wywnioskowanie typu wyrażenia na podstawie jednej z kilku opcji, wybiera najlepszą z nich . Oznacza to, że jeśli dasz C # kilka opcji, takich jak „Żyrafa, ssak, zwierzę”, może wybrać najbardziej ogólny - Zwierzę - lub może wybrać najbardziej szczegółowy - Żyrafa - w zależności od okoliczności. Ale musi wybrać jeden z wyborów, które mu faktycznie dano . C # nigdy nie mówi „moje wybory są między kotem a psem, dlatego wnioskuję, że najlepszym wyborem jest Animal”. To nie był dany wybór, więc C # nie może go wybrać.

W przypadku operatora trójskładnikowego C # próbuje wybrać bardziej ogólny typ int i string, ale żaden z nich nie jest typem bardziej ogólnym. Zamiast wybierać typ, który nie był wyborem w pierwszej kolejności, na przykład obiekt, C # decyduje, że nie można wywnioskować typu.

Zwracam również uwagę, że jest to zgodne z inną zasadą projektowania języka C #: jeśli coś wygląda nie tak, poinformuj o tym dewelopera. Język nie mówi: „Zgadnę, co miałeś na myśli i będę się przez to gmatwał, jeśli będę mógł”. Język mówi: „Myślę, że napisałeś tu coś zagmatwanego i powiem ci o tym”.

Zwracam również uwagę, że C # nie prowadzi rozumowania ze zmiennej do przypisanej wartości , ale raczej w przeciwnym kierunku. C # nie mówi „przypisujesz do zmiennej obiektu, dlatego wyrażenie musi być konwertowalne na obiekt, dlatego upewnię się, że tak jest”. Zamiast tego C # mówi „to wyrażenie musi mieć typ i muszę być w stanie wywnioskować, że typ jest zgodny z obiektem”. Ponieważ wyrażenie nie ma typu, generowany jest błąd.

Odnośnie części ogólnej:

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

W języku C # kompilator próbuje przekonwertować prawostronne części wyrażenia na typowy typ; od List<int>iList<string> są dwoma różnymi skonstruowanymi typami, jednego nie można przekonwertować na drugi.

W Javie kompilator próbuje znaleźć wspólny typ nadrzędny zamiast dokonywać konwersji, więc kompilacja kodu obejmuje niejawne użycie symboli wieloznacznych i wymazywanie typów ;

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

ma typ kompilacji ArrayList<?>(w rzeczywistości może to być również ArrayList<? extends Serializable>lub ArrayList<? extends Comparable<?>>, w zależności od kontekstu użycia, ponieważ oba są typowymi rodzajami nadrzędnymi) i typ czasu wykonywania surowegoArrayList uruchomieniowego (ponieważ jest to wspólny nadtyp surowy).

Na przykład (sprawdź to sam) ,

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

Zarówno w Javie, jak i C # (i większości innych języków) wynik wyrażenia ma typ. W przypadku operatora trójskładnikowego istnieją dwa możliwe wyrażenia podrzędne obliczane dla wyniku i oba muszą mieć ten sam typ. W przypadku Javy intzmienna może zostać przekonwertowana na Integerzmienną poprzez autoboxing. Ponieważ zarówno Integeri Stringdziedziczą z Object, można je przekonwertować na ten sam typ przez prostą konwersję zawężającą.

Z drugiej strony, w C #, an intjest prymitywem i nie ma niejawnej konwersji do stringani żadnej innej object.

To jest całkiem proste. Nie ma niejawnej konwersji między ciągiem a int. operator trójskładnikowy wymaga, aby ostatnie dwa operandy miały ten sam typ.

Próbować:

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