Unterschied zwischen C # und Javas ternärem Operator (? :)

Ich bin ein C # -Neuling und habe gerade ein Problem. Beim Umgang mit dem ternären Operator ( ? :) gibt es einen Unterschied zwischen C # und Java .

Warum funktioniert die 4. Zeile im folgenden Codesegment nicht? Der Compiler zeigt eine Fehlermeldung von an there is no implicit conversion between 'int' and 'string'. Die 5. Zeile funktioniert nicht so gut. Beide Listsind Objekte, nicht wahr?

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

Der gleiche Code funktioniert jedoch in 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

Welche Sprachfunktion in C # fehlt? Wenn überhaupt, warum wird es nicht hinzugefügt?

Wenn Sie sich den Abschnitt 7.14 der C # 5-Sprachspezifikation ansehen : Bedingter Operator , sehen Sie Folgendes:

• Wenn x Typ X und y Typ Y hat, dann

  • Wenn eine implizite Konvertierung (§6.1) von X nach Y, aber nicht von Y nach X existiert, ist Y der Typ des bedingten Ausdrucks.

  • Wenn eine implizite Konvertierung (§6.1) von Y nach X existiert, aber nicht von X nach Y, dann ist X der Typ des bedingten Ausdrucks.

  • Andernfalls kann kein Ausdruckstyp ermittelt werden, und es tritt ein Fehler bei der Kompilierung auf

Mit anderen Worten: Es wird versucht herauszufinden, ob x und y ineinander konvertiert werden können. Andernfalls tritt ein Kompilierungsfehler auf. In unserem Fall intund stringhaben keine explizite oder implizite Konvertierung, so dass es nicht kompiliert wird.

Vergleichen Sie dies mit der Java 7-Sprachspezifikation in Abschnitt 15.25: Bedingter Operator :

• Wenn der zweite und der dritte Operand denselben Typ haben (der der Nulltyp sein kann), ist dies der Typ des bedingten Ausdrucks. ( NEIN )
• Wenn einer der zweiten und dritten Operanden vom primitiven Typ T ist und der Typ des anderen das Ergebnis der Anwendung der Boxkonvertierung (§5.1.7) auf T ist, ist der Typ des bedingten Ausdrucks T. ( NO )
• Wenn einer der zweiten und dritten Operanden vom Typ Null ist und der Typ des anderen ein Referenztyp ist, ist der Typ des bedingten Ausdrucks dieser Referenztyp. ( NEIN )
• Andernfalls gibt es mehrere Fälle, wenn der zweite und dritte Operand Typen haben, die in numerische Typen konvertierbar sind (§5.1.8): ( NO )
• Ansonsten sind der zweite und der dritte Operand vom Typ S1 bzw. S2. Sei T1 der Typ, der sich aus der Anwendung der Boxkonvertierung auf S1 ergibt, und sei T2 der Typ, der sich aus der Anwendung der Boxkonvertierung auf S2 ergibt.
  Der Typ des bedingten Ausdrucks ergibt sich aus der Anwendung der Capture-Konvertierung (§5.1.10) auf lub (T1, T2) (§15.12.2.7). ( JA )

Und siehe Abschnitt 15.12.2.7. Ableiten von Typargumenten Basierend auf tatsächlichen Argumenten können wir sehen, dass versucht wird, einen gemeinsamen Vorfahren zu finden, der als Typ für den Aufruf dient, mit dem er landet Object. Object ist ein akzeptables Argument, damit der Aufruf funktioniert.

Die gegebenen Antworten sind gut; Ich möchte ihnen hinzufügen, dass diese Regel von C # eine Folge einer allgemeineren Konstruktionsrichtlinie ist. Wenn C # aufgefordert wird, den Typ eines Ausdrucks aus einer von mehreren Auswahlmöglichkeiten abzuleiten, wählt er das eindeutig beste aus . Das heißt, wenn Sie C # einige Optionen wie "Giraffe, Säugetier, Tier" geben, wählt es je nach den Umständen die allgemeinste - Tier - oder die spezifischste - Giraffe. Aber es muss eine der Entscheidungen treffen, die es tatsächlich gegeben hat . C # sagt nie "Ich habe die Wahl zwischen Katze und Hund, daher werde ich daraus schließen, dass Tier die beste Wahl ist". Das war keine Wahl, also kann C # sie nicht wählen.

Im Fall des ternären Operators versucht C #, den allgemeineren Typ von int und string zu wählen, aber auch nicht den allgemeineren Typ. Anstatt einen Typ auszuwählen, der überhaupt keine Wahl war, wie z. B. ein Objekt, entscheidet C #, dass kein Typ abgeleitet werden kann.

Ich stelle auch fest, dass dies im Einklang mit einem anderen Designprinzip von C # steht: Wenn etwas falsch aussieht, informieren Sie den Entwickler. Die Sprache sagt nicht "Ich werde raten, was du gemeint hast und durchwühlen, wenn ich kann". Die Sprache sagt: "Ich denke, Sie haben hier etwas Verwirrendes geschrieben, und ich werde Ihnen davon erzählen."

Außerdem stelle ich fest, dass C # nicht aus dem Variablen zum zugewiesenen Wert führt , sondern in die andere Richtung. C # sagt nicht "Sie weisen einer Objektvariablen zu, daher muss der Ausdruck in ein Objekt konvertierbar sein, daher werde ich sicherstellen, dass dies der Fall ist". Vielmehr sagt C #: "Dieser Ausdruck muss einen Typ haben, und ich muss ableiten können, dass der Typ mit dem Objekt kompatibel ist." Da der Ausdruck keinen Typ hat, wird ein Fehler erzeugt.

In Bezug auf den Generika-Teil:

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

In C # versucht der Compiler , die rechten Ausdrucksteile in einen allgemeinen Typ zu konvertieren . Da List<int>und List<string>zwei verschiedene konstruierte Typen sind, kann einer nicht in den anderen konvertiert werden.

In Java versucht der Compiler , einen gemeinsamen Supertyp zu finden, anstatt ihn zu konvertieren. Daher umfasst die Kompilierung des Codes die implizite Verwendung von Platzhaltern und das Löschen von Typen .

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

hat den Kompilierungstyp ArrayList<?>(tatsächlich kann es auch sein ArrayList<? extends Serializable>oder ArrayList<? extends Comparable<?>>, abhängig vom Verwendungskontext, da beide gängige generische Supertypen sind) und den Laufzeittyp von rawArrayList (da es sich um den gemeinsamen rohen Supertyp handelt).

Zum Beispiel (testen Sie es selbst) ,

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

Sowohl in Java als auch in C # (und den meisten anderen Sprachen) hat das Ergebnis eines Ausdrucks einen Typ. Im Fall des ternären Operators werden zwei mögliche Unterausdrücke für das Ergebnis ausgewertet, und beide müssen denselben Typ haben. Im Fall von Java kann eine intVariable Integerdurch Autoboxing in eine Variable konvertiert werden. Da nun beide Integerund von Stringerben Object, können sie durch eine einfache Verengungskonvertierung in denselben Typ konvertiert werden.

Andererseits ist an in C # intein Primitiv und es gibt keine implizite Konvertierung zu stringoder einem anderen object.

Das ist ziemlich einfach. Es gibt keine implizite Konvertierung zwischen string und int. Der ternäre Operator benötigt die letzten beiden Operanden, um denselben Typ zu haben.

Versuchen:

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