const构造函数实际上是如何工作的？

Question

我注意到在Dart中可以创建一个const构造函数。在文档中，它说< code>const一词用于表示编译时常数。

我想知道当我使用const构造函数创建对象时会发生什么。这是否像一个不可变对象，它总是相同的并且在编译时可用？const构造函数的概念实际上是如何工作的？const构造函数与常规构造函数有何不同？

Answer 1

详细解释得很好，但对于实际寻找const构造函数用法的用户来说

它用于提高颤振性能，因为它可以帮助Flutter仅重建应更新的小部件。在 StateFulWidgets 中使用 setState（） 时，将仅重建那些非构造函数的组件

可以用例子来解释——

    class _MyWidgetState extends State<MyWidget> {

  String title = "Title";

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(title),
      ),
      body: Column(
        children: <Widget>[
          const Text("Text 1"),
          const Padding(
            padding: const EdgeInsets.all(8.0),
            child: const Text("Another Text widget"),
          ),
          const Text("Text 3"),
        ],
      ),
      floatingActionButton: FloatingActionButton(
        child: const Icon(Icons.add),
        onPressed: () {
          setState(() => title = 'New Title');
        },
      ),
    );
  }
}

在此示例中，只有文本标题应该更改，因此只有此小部件应该重新生成，因此将所有其他小部件设置为 const 构造函数将有助于 flutter 做同样的事情以提高性能。

Answer 2

我发现Lasse在Chris Storms博客上的答案是一个很好的解释。

飞镖常数构造函数

希望他们不介意我抄袭内容。

这是对final字段的一个很好的解释，但它并没有真正解释const构造函数。在这些例子中，实际上没有使用构造函数是常量构造函数。任何类都可以有final字段，不管是不是const构造函数。

Dart中的字段实际上是一个匿名存储位置，结合了自动创建的getter和setter来读取和更新存储，它也可以在构造函数的初始化器列表中初始化。

final字段也是一样的，只是没有设置器，所以设置它的值的唯一方法是在构造函数初始化列表中，之后就没有办法更改值了——因此有了“final”。

const构造函数的目的不是初始化最终字段，任何生成构造函数都可以这样做。关键是创建编译时常量值：在编译时已知所有字段值的对象，而不执行任何语句。

这对类和构造函数施加了一些限制。const构造函数不能有主体（不执行语句！）并且它的类不能有任何非最终字段（我们在编译时“知道”的值以后不能更改）。初始化列表还必须仅将字段初始化为其他编译时常量，因此右侧仅限于“编译时常量表达式”[1]。并且它必须以“const”为前缀——否则您只会得到一个恰好满足这些要求的普通构造函数。这很好，只是不是const构造函数。

为了使用const构造函数实际创建编译时常量对象，您然后在“new”-表达式中将“new”替换为“const”。您仍然可以将“new”与const构造函数一起使用，它仍然会创建一个对象，但它只是一个普通的新对象，而不是编译时常量值。也就是说：const构造函数也可以用作普通构造函数来在运行时创建对象，以及在编译时创建编译时常量对象。

因此，作为一个例子：

class Point { 
  static final Point ORIGIN = const Point(0, 0); 
  final int x; 
  final int y; 
  const Point(this.x, this.y);
  Point.clone(Point other): x = other.x, y = other.y; //[2] 
}

main() { 
  // Assign compile-time constant to p0. 
  Point p0 = Point.ORIGIN; 
  // Create new point using const constructor. 
  Point p1 = new Point(0, 0); 
  // Create new point using non-const constructor.
  Point p2 = new Point.clone(p0); 
  // Assign (the same) compile-time constant to p3. 
  Point p3 = const Point(0, 0); 
  print(identical(p0, p1)); // false 
  print(identical(p0, p2)); // false 
  print(identical(p0, p3)); // true! 
}

编译时常量被规范化。这意味着无论你写多少次“const Point（0，0）”，你只创建一个对象。这可能很有用 - 但并不像看起来那么多，因为你可以创建一个const变量来保存值并使用变量。

那么，编译时间常数有什么好处呢？

• 它们对枚举很有用。
• 您可以在切换情况下使用编译时常量值。
• 它们被用作注释。

在Dart切换到延迟初始化变量之前，编译时常量曾经更加重要。在此之前，您只能声明一个初始化的全局变量，例如“var x=foo；”，如果“foo”是编译时常量。没有这个要求，大多数程序都可以在不使用任何const对象的情况下编写

所以，简而言之:Const构造函数只是用来创建编译时常量值的。

/L

[1]或者真的:“潜在的编译时常量表达式”，因为它也可能引用构造函数参数。[2]所以是的，一个类可以同时有常量和非常量构造函数。

https://github.com/dart-lang/sdk/issues/36079也讨论了这个话题，并有一些有趣的评论。

Answer 3

Const 构造函数创建一个“规范化”实例。

也就是说，所有常量表达式都开始标准化，之后这些“标准化”符号用于识别这些常量的等价性。

规范化:

将具有多个可能表示形式的数据转换为“标准”规范表示的过程。这样做可以比较不同的表示等效性，计算不同数据结构的数量，通过消除重复计算来提高各种算法的效率，或者可以施加有意义的排序顺序。

这意味着像const Foo（1,1）这样的const表达式可以表示任何对虚拟机中的比较有用的可用形式。

VM只需要按照值类型和参数在常量表达式中出现的顺序来考虑它们。当然，它们是为了优化而减少的。

具有相同规范化值的常数:

var foo1 = const Foo(1, 1); // #Foo#int#1#int#1
var foo2 = const Foo(1, 1); // #Foo#int#1#int#1

具有不同规范化值的常数(因为签名不同):

var foo3 = const Foo(1, 2); // $Foo$int$1$int$2
var foo4 = const Foo(1, 3); // $Foo$int$1$int$3

var baz1 = const Baz(const Foo(1, 1), "hello"); // $Baz$Foo$int$1$int$1$String$hello
var baz2 = const Baz(const Foo(1, 2), "hello"); // $Baz$Foo$int$1$int$2$String$hello

常数不会每次都重新创建。它们在编译时被规范化，并存储在特殊的查找表中(在那里它们被规范化签名散列)，以后可以从这些表中重用它们。

附笔。

这些示例中使用的形式< code>#Foo#int#1#int#1仅用于比较目的，它不是Dart VM中规范化(表示)的真实形式；

但真正的规范化形式必须是“标准”的规范表示。