D 中的逻辑常量

Question

D 有两种类型的常量：不可变变量是被声明为不可变的变量，并且始终是不可变的，而const变量只是对象的只读版本。

逻辑const是指一个函数被标记为const，但允许对一个或多个成员变量进行写访问。它的典型用途是惰性求值，例如（在 C++ 中）

struct Matrix
{
  double determinant() const
  {
    if ( m_dirty )
    {
      m_determinant = /* expensive calculation */;
      m_dirty = false;
    }
    return m_determinant;
  }

  void set(int i, int j, double x) { m_dirty = true; ...; }

  mutable bool m_dirty;
  mutable double m_determinant;
};

这里，determinant() 是 const，但仍然可以修改 m_dirty 和m_determinant 因为它们被标记为mutable。

D const(FAQ) 表示 D2 不支持逻辑 const因为它提供的保证很弱，这阻碍了并发程序的编写，并使某些优化变得更加困难。

我完全理解这个问题，但是如果我们需要逻辑常量怎么办？

考虑上面使用 Matrix 类的情况，但没有缓存（并且不需要逻辑 const）。还想象一下，这个类在我的代码库中到处使用，并且主要通过 const 引用进行访问。

现在考虑一下，分析表明，确定性（）函数是代码中的瓶颈，而且它通常被重复访问，其值很少改变，即缓存，如上所述，将是一个完美的优化。

如果没有逻辑常量，我该如何做到这一点？在我的代码库中将 const 引用更改为非 const 引用并不是一个选择（出于明显的原因）。

我有哪些选择（如果有）？

Answer 1

我认为发布 的基本结论是适当的最近在 D 新闻组 上讨论了这个主题，以便那些不跟踪该列表的人仍然可以获得适当的答案。

D 的 const 不是逻辑 const。它是传递性的并且完全是常量的。该语言在技术上不支持逻辑常量。该语言没有定义任何改变 const 对象的方法。

实际上，C++ 也没有逻辑 const。使用 mutable 并抛弃 const 性可以让你完全规避 const，这样，从技术上讲，const 实际上并不能保证任何东西，除了你不会调用任何非常量函数一个常量变量。 const 函数实际上是 const 并且不会与变量发生冲突，这一事实完全按照惯例结合在一起。现在，大多数程序员不会四处抛弃左右常量并使所有内容都可变，因此在实践中，它非常有用，但它不仅可以完全规避，而且语言还专门为您提供了这样做的定义方法。在 C++ 中，mutable 和抛弃 const 是明确定义的，并且受到该语言的支持。

D 不这样做。 D 的 const 实际上是 const。将变量上的 const 强制转换然后更改它是未定义的。没有可变的。 D 的 const 具有真正的保证（只要你不做任何未定义的事情，比如丢弃某些东西上的 const 然后改变它）。这很重要，不仅因为 D 的编译器保证比 C++ 的编译器保证强得多，而且因为不可变变量不能以任何方式改变形状或形式。它们可能位于只读内存中，如果您尝试放弃不变性并更改这样的变量，谁知道会发生什么可怕的事情（段错误可能是可能发生的最好的事情）。而且由于 const 变量实际上可以引用不可变数据，因此放弃 const 来更改变量或允许 const 变量以某种方式更改至少可以说是坏。所以，语言不允许。

现在，正如 BCS 指出的那样，D 是一种实用语言。您可以放弃const，此时您可以更改变量。因此，例如，您可以有一个变量用于缓存 const 函数的返回值（如果对象的状态发生更改，该缓存可能会失效）并丢弃 const 来更改它。只要所讨论的变量实际上不是不可变的，它就可以工作。然而，这是未定义的行为。一旦你这样做了，你就只能靠自己了。您正在绕过类型系统和编译器的保证。 您负责确保您不会在不可变对象上执行此操作，否则会破坏编译器通常保证的内容。因此，如果您需要这样做，您可以这样做，但是您正在踏入狂野的西部，并且您需要确保自己没有改变不应该改变的东西。

鉴于只要变量实际上并不引用不可变数据，抛弃 const 就可以工作，因此可以创建一个 Mutable 模板来本质上获得 mutable 为您提供的内容在 C++ 中（因此，它将为您消除常量性）。 he_the_great 在他的回答中给出了此类模板的示例。但使用这样的模板仍然是未定义的行为。在实际上不可变的对象上使用它会导致问题。 您，程序员，必须确保它的使用正确。

因此，D 在技术上可以通过抛弃 const 来获得逻辑 const，但为了做到这一点，您必须通过绕过类型系统来超越编译器所保证的范围，并且您必须确保不会误用它和变异不应该/不能变异的变量，否则你的代码将会出现问题 - 段错误很可能是其中最少的。

编辑：我忘记提及一个建议的解决方案，它不会破坏类型系统。只要您愿意放弃纯粹性，您就可以使用某种全局变量（无论是在模块范围、类变量还是结构变量）来保存缓存的值。 const 函数可以自由地使用和改变全局变量，因此可以用它来代替缺失的mutable。然而，这确实意味着该函数不能是纯函数，这也可能是一个大问题。然而，这是一种让 const 函数仍然能够在不破坏类型系统的情况下改变它所需的数据的方法。

Answer 2

我已经很久没有接触过 D2 了，所以你可能需要仔细检查我所说的。 :)

我不确定你是否真的有什么好的选择。 D 的 const 和 immutable 明显比 C/C++ 强，因此放弃它们不是一个选择。您已明确排除在代码中更改 const 的使用。

您可以将运算结果缓存在以矩阵值本身为键的全局哈希表中。这适用于 const/immutable 的任何组合。当然，问题在于 D 没有世界上最快的哈希表，并且计算哈希可能会很慢。也许在创建矩阵时预先计算哈希。

另一种选择是当值发生变化时立即计算行列式。

除此之外，我想不到其他的了。实际上，问题在于您要求编译器使用 const 保护您，然后试图摆脱它。 “正确的”解决方案可能就是不使用 const。 ：P

Answer 3

作为一种实用语言，如果您确实需要的话，D 有能力抛弃 const。我认为以下应该有效：

class M {
  bool set;
  real val;

  real D() const {
    if(!set) {
      M m = cast(M)this;
      m.val = this.some_fn();
      m.set = true;
    }
    return this.val;
  }
}

Answer 4

我强烈建议 BCS 的答案，因为只要不创建不可变/常量矩阵，它就简单且安全。

另一个有助于使不可变/常量对象保持有效的选项是这个可变模板。或者至少这是意图。对于这些担忧，有一些评论。

使用此模板，需要对引用类型进行修改，而不是对 const 函数中的值进行修改。这意味着使用指针并需要为每个矩阵分配空间。这也使得创建一个不会出现段错误的不可变/常量矩阵变得更加困难，也许有一种方法可以很好地做到这一点，但我只知道一种用于类的方法。

struct Matrix
{
    double determinant() const
    {
        if ( *m_dirty )
        {
            *m_determinant = 646.363; /* expensive calculation */;
            *m_dirty = false;
        }
        return *m_determinant;
    }

    void set(int i, int j, double x) { *m_dirty = true; }

    Mutable!(bool*) m_dirty;
    Mutable!(double*) m_determinant;
};

Answer 5

要在 D 中模拟 C++ 中的逻辑 const，您可以使用类的继承：

class ConstMatrix
{
public:
    double det() { // not marked as const!
        /* ... caching code ... */
    }
    /* ... the rest of the logically const interface ... */
}

class Matrix : ConstMatrix
{
public:
    void set( int row, int col, double val ) {
        /* ... */
    }
    /* ... the non-logically const interface ... */
}

在 ConstMatrix 类实现中，除非您放置 const<，否则您不会进行任何编译器检查。 /code> 限定符到函数签名上。但是，如果您将 ConstMatrix 用于逻辑常量矩阵，您将获得客户端代码的 const 正确性。

对于结构，您可以使用alias技术来完成相同的任务：

struct ConstMatrix 
{
    /* logically const bla bla blub */
}

struct Matrix
{
public:
    alias m this;

    /* non-const bla bla blub */
private:
    ConstMatrix m;
}

对于类类型，您可以构建具有逻辑常量正确性的其他class或struct通过以下方式：

class ConstBiggerClass
{
private:
    ConstMatrix m;
}

class BiggerClass : ConstBiggerClass
{
private:
    Matrix m;
}

这样编译器将为您检查 const 的正确性。但是，您将需要一个额外的数据成员。对于 class 类型中的 class 类型成员，另一种方法是提供一个成员函数，该函数返回具有正确常量的数据成员：

class ConstBiggerClass
{
public:
    void someLogicallyConstFunction( /*...*/ ) { /* ... */ }
protected:
    abstract ConstMatrix getMatrix();
}

class BiggerClass : ConstBiggerClass
{
public:
    void someMutableFunction( /*...*/ ) { /*...*/ }
protected:
    Matrix getMatrix() { return m; }
private:
    Matrix m;
}