Wie viele Typumwandlungen gibt es im Code?

Question

Wie viele Typ-Konvertierung gibt es in den folgenden Code:

#include<stdio.h> 
int f(int x) 
{ 
    return (float)x; 
} 
int main() 
{ 
    float x = f(5L); 
    return 0; 
} 

In Funktion f(), wird der Rückgabewert von int zu float gefördert. In main() wird das Argument f() von int zu long befördert, und int wird wieder zu float befördert.

Ist es richtig, dass es drei Typkonvertierungen (Aktionen) sind?

Answer 1

Ich sehe insgesamt 4 Typkonvertierungen (von denen keine „Aktionen“).

Innen f(), wird der Wert von x ausdrücklich von int zu float durch den Cast-Operator umgewandelt, Das Ergebnis dieser Umwandlung implizit von float zu int durch die return Anweisung umgewandelt wird.

Innen main(), der Wert der Konstanten 5L wird implizit von long int zu int umgewandelt, wenn es als ein Argument an f übergeben wird. Das Ergebnis des Aufrufs zu f wird implizit von int zu float durch die Initialisierung von x umgewandelt.

Das sind vier Conversions. (Die return 0; geht es nicht um eine Umwandlung, da die 0 bereits vom Typ int, das ist der Rückgabetyp für main.)

Bei einem einigermaßen klug Compiler, ist es wahrscheinlich, dass keines dieser Umwandlungen in jedem nicht führen - generisch generierter Code Da keiner der Werte verwendet werden, könnte das gesamte Programm auf das Äquivalent von

int main(void) { return 0; } 

reduziert werden aber alle vier Umwandlungen in der „abstrakte Maschine“ auftreten, die durch C Semantik.

(übrigens ist int main(void) zu int main() bevorzugt.)

Answer 2

In f:

int (Argument) ->float (cast) ->int (Rückgabewert)

In main:

long (wörtliche) ->int (Argument)

int (Rückgabewert von f) ->float (Variable x)

Das sind vier Conversions.

Answer 3

Es gibt keine einzige richtige Antwort auf diese Frage - es hängt alles von dem Compiler und dem System verwendet.

Ein guter Compiler wird durch alles außer dem return 0; Weg und es wird überhaupt keine Konvertierungen geben.

Auch wenn der Compiler die Funktion weiterhin ausführt, ist die Anzahl der Konvertierungen immer noch nicht vorhersehbar. Die 5L bis int Konvertierung wird zur Kompilierzeit aufgelöst. Es sollte also nicht als Konversion gelten. Auch auf vielen Systemen gibt es keinen Unterschied zwischen long und int, da sie beide 32 Bit (auf vielen Systemen) sind, was wiederum darauf hinweist, dass dies keine Konvertierung ist.

Auf den meisten Systemen die hässliche (float) Guss int->float->int verursacht wird als float bleiben können alle Werte eines int nicht darstellen. Wenn das System jedoch ein Float-Format verwendet, das alle int Werte darstellen kann, kann der Compiler durch die Konvertierungen weg. Die int->float in main müsste bleiben.

Also würde ich sagen, entweder 0, 1 oder 3 Konvertierungen. Am wahrscheinlichsten ist 0, wenn mit Optimierung kompiliert wird.

Aber die wirkliche Antwort ist - es ist System und Compiler abhängig.