c# - 以下数字赋值是否会导致 C# 中的隐式强制转换？

Question

这个问题主要是出于好奇，因为我在官方 C# 文档中找不到任何内容，而且性能成本可能完全可以忽略不计。

基本上，我想知道之间是否存在任何运行时成本差异:

float i = 0;

和

float i = 0.0f;

我假设编译器足够聪明，可以在编译时将 0 转换为 0.0f 并直接分配它而无需强制转换。这个假设是否正确？

Answer 1

在您的代码示例中，两者之间没有什么不同。您已将类型声明为 float因此，无论末尾是否有 f，它都将是一个 float 。 f 只是被忽略了。

f 在执行方程式或分配通用变量时发挥作用，例如使用 var关键字。

例如:

var value = 0; // this is assigned as integer.

var value = 0.0f // this is assigned as float.

var value = 0.0; // this is assigned as double.

这是一个计算示例:

注意: 要全面理解 float 是完全不同的一课，但要知道根据整数、 float (f)、 double (d) 等类型执行不同的计算, 或小数 (m) 最重要。

注意不同类型的数学有何不同。

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(1 / 3);
        Console.WriteLine(1f / 3);
        Console.WriteLine(1d / 3);
        Console.WriteLine(1m / 3);

        Console.ReadKey();
    }
    // OUTPUT
    // 0
    // 0.3333333
    // 0.333333333333333
    // 0.3333333333333333333333333333
}

另请注意，当您在计算中设置类型时，只有该部分计算会获得该类型的结果。考虑这个计算中混合类型的例子:

class Program
{
    static void Main(string[] args)
    {
        //float + integer
        Console.WriteLine(1f / 3 + 1 / 3);

        //double + integer
        Console.WriteLine(1d / 3 + 1 / 3);

        //double + float
        Console.WriteLine(1d / 3 + 1 / 3f);

        //decimal + integer
        Console.WriteLine(1m / 3 + 1 / 3);

        //decimal + decimal
        Console.WriteLine(1m / 3 + 1 / 3m);

        Console.ReadKey();
    }
    // OUTPUT
    // 0.3333333
    // 0.333333333333333
    // 0.666666676600774
    // 0.3333333333333333333333333333
    // 0.6666666666666666666666666666
}

---

已更新以包含基于以下评论的信息

根据下面的评论和对象的编译与运行时生成更新我的答案。

所有已知类型都是在编译时生成的。所以在你的问题中，是的，编译器会将 0 分配给 float 因为它是已知的。

所有泛型类型都有在编译时生成的元数据；因此编译器可以回答针对类型和标记错误的问题。但是，直到运行时才生成类型本身；如果该类型是值类型或引用类型，则会更改其生成方式。考虑这个签名:

public void MyMethod<T>(T myType)

由于此方法是通用的，因此会在运行时为每个不同的值类型创建一个新方法，仅当使用该类型时，并且每个值类型仅创建一次(相同的值类型重用相同的生成类型)。看看下面的代码。

MyMethod(12);           // new type method built at runtime taking integer
MyMethod(12d);          // new type method built at runtime taking double
MyMethod(12);           // ** resuses already built type method taking integer
MyMethod(new Person()); // new type method built at runtime taking Person
MyMethod(new object()); // ** resuses type method built taking Person but uses object pointer.

所以你可以看到编译器可以帮助我们解决类型冲突，但是使用泛型类型的类型直到运行时才存在；了解它们何时存在以及如何在值和引用类型之间使用它们很重要。

最后我们有 dynamic .这在编译时永远不会得到解决，实际上直到运行时才会被忽略。你可以在这里做任何你想做的事；这有点像编写 JavaScript；那个叛逆的小恶魔。考虑这段代码:

static void Main(string[] args)
{
    dynamic value = 1;
    Console.WriteLine(value);

    int integer = value;
    Console.WriteLine(integer);

    value = "Hello World";
    Console.WriteLine(value);

    string text = value;
    Console.WriteLine(text);

    Console.ReadKey();
}
// OUTPUT
// 1
// 1
// Hello World
// Hello World

请注意，在这里我不仅采用未知类型，而且将其分配给已知类型……然后我将该类型完全更改为另一种类型，然后将其分配给另一种类型。编译器不在乎并且一切正常......问题是如果我修改它使得事情不匹配然后我得到一个运行时异常而不是编译时间。根据您使用动态的方式，这可能是一个大问题。

希望这一切有助于澄清一些事情。记住;已知类型(编译时)、泛型(编译时元数据、运行时类型)和动态(运行时)。