这对 const 来说太不可变了吗？

Question

基本上，我有以下情况。注意：void* 用于表示任意数据，在实际应用中是强类型的。

class A
{
public:
   //uses intermediate buffer but doesn't change outward behavior
   //intermediate buffer is expensive to fill
   void foo(void* input_data);

   //uses intermediate buffer and DOES explicitly change something internally
   //intermediate buffer is expensive to fill
   void bar(void* input_data);

   //if input_data hasn't changed since foo, we can totally reuse what happened in foo
   //I cannot check if the data is equal quickly, so I allow the user to pass in the
   //assertion (put the honerous on them, explicitly tell them in the comments
   //that this is dangerous to do, ect)
   void bar(void* input_data, bool reuse_intermediate);
private:
   void* intermediate_buffer_;
   void* something_;
};

因此，为了 const 的正确性，intermediate_buffer_ 永远不会暴露，因此它符合使用 mutable 变量的定义。如果我从未重用过这个缓冲区，或者我在使用缓存值之前检查了相等的 input_data，那将是故事的结尾，但由于重用_中间体，我觉得我暴露了一半，所以我不确定是否或者以下是否有意义。

class A
{
public:
   //uses intermediate buffer but doesn't change something
   //intermediate buffer is expensive to fill
   void foo(void* input_data) const;

   //uses intermediate buffer and DOES explicitly change something internally
   //intermediate buffer is expensive to fill
   void bar(void* input_data);

   //if input_data hasn't changed since foo, we can totally reuse what happened in foo
   //I cannot check if the data is equal quickly, so I allow the user to pass in the
   //assertion (put the honerous on them, explicitly tell them in the comments
   //that this is dangerous to do, ect)
   void bar(void* input_data, bool reuse_intermediate);

   //an example of where this would save a bunch of computation, though
   //cases outside the class can also happen
   void foobar(void* input_data)
   {
      foo(input_data);
      bar(input_data,true);
   }
private:
   mutable void* intermediate_buffer_;
   void* something_;
};

想法？

Answer 1

我认为这是对mutable 的不当使用。根据我的经验，mutable 用于辅助私有成员变量，其本质上不能声明为 const，但不要修改公共接口的“概念常量”。

以 Mutex 成员变量和“线程安全的 getter”为例：

class Getter { 
public: 

    Getter( int d, Mutex & m ) : guard_( m ), data_( d ) { };

    int get( ) const { Lock l(guard_); return data_; };

private:

    mutable Mutex guard_;
    const int data_;
};

这里的要点是声明的数据mutable（在这种情况下是守卫）确实发生了变化（它被锁定和解锁）但是从用户的角度来看这对常量没有影响。 最终，尽管 Mutex 是可变的，但您仍然无法更改 const data_ 成员变量并且编译器会强制执行此操作。

在您的情况下，您确实希望intermediate_buffer 为const，但您通过声明它是可变的来明确告诉编译器它不是。结果是您可以更改数据而编译器对此无能为力。

看到区别了吗？

如果您真的希望接口符合 const 协议，请通过以下方式使其明确：

    class A { 
    public:    

        A( void* input_data );// I assume this deep copies.

        void foo() const;

        void bar();

        private:    
            const void* intermediate_buffer_;   
            void* something_; 
    };

现在责任真正由用户承担，并由编译器强制执行，而不管 cmets 说什么，也无需使用 mutable。如果他们知道 input_data 已更改，他们将不得不创建一个新的，最好是 const。

Answer 2

与其将中间对象隐藏在 const 对象中，不如将其公开并让foo 和bar 返回一个副本。您正在非常明确地表明正在共享中间对象，并提供了一种新的功能来保持手头上的多个对象。如果你想隐藏实现细节，你可以暴露一个空类，并使中间对象成为这个基类的子类。

class A
{
public:
   class Intermediate
   {
      //empty
   };

   //uses intermediate buffer but doesn't change outward behavior
   //intermediate buffer is expensive to fill
   //if cache_ptr is NULL the intermediate buffer is discarded
   void foo(void* input_data, Intermediate** cache_ptr = NULL) const;

   //uses intermediate buffer and DOES explicitly change something internally
   //intermediate buffer is expensive to fill
   void bar(void* input_data, Intermediate** cache_ptr = NULL);
private:
   class IntermediateImpl : public Intermediate
   {
      //...
   };
   void* something_;
};

Answer 3

直接回答您的问题。 如果函数 foo 是 const，在任何时候调用它都不应该改变下一个操作的结果。

例如：

A a(some_big_data);
a.bar(some_big_data, true);

应该给出完全相同的结果（不包括性能差异）

A a(some_big_data);
a.foo(some_different_big_data);
a.bar(some_big_data, true);

由于 foo 是 const，用户会期望结果相同。 如果是这种情况，那么制作缓冲区mutable 是合理的。 否则，很可能是错误的。

希望对你有帮助

Answer 4

免责声明：我的回答并不提倡使用void*，我希望这只是为了演示目的，您实际上不需要自己使用它。

如果重复使用相同的输入数据时可以节省大量计算，则将input_data设为成员变量。

    class A
    {
      public:
        A(void * input_data)
        {
            set_input_data(input_data);
        }

        //Note, expensive operation
        void set_input_data(void* input_data)
        {
            this->input_data = input_data;
            fill_intermediate_buffer();
        }

        void foo() const;
        void bar() const;
      private:
        void * input_data;
        void * intermediate_buffer;
        void * something;
    };

这显然只是一个大纲，没有更多关于input_data、intermediate_buffer 和something 是什么或它们如何被使用或共享的详细信息将会丢失很多细节。我肯定会从实现中删除指针并使用std::vector。对于input_data 尤其如此，您可能希望在其中存储传入缓冲区的副本。考虑：

    A a(input);
    //modifiy input
    a.foo();

使用不匹配的input_data/intermediate_buffer 对可能会得到错误的结果。

还请注意，如果您实际上不需要 input_data 用于 foo 和 bar，那么您可以从类中删除 void* input_data，但仍保留引用它的构造函数和设置器。

Answer 5

我想说您对mutable 的使用确实有一定的意义——但它是不正确的，而且可能很危险。如果你创建一个函数const，它就必须是这样。

想象一下，如果您在多线程程序中使用您的类，多个线程在该类的同一个实例上运行 - 例如：

thread1:

while(1) {
    (...) //do some work
    sharedA->foo(thread1Data);
    sharedA->bar(thread1Data, true);
    (...) //do some more work
    sharedA->bar(thread1Data, true);
    (...) //do even more work
}

thread2:

while(1) {
    (...) //do some different work, maybe wait for an event
    sharedA->foo(thread2Data);
    (...) //sleep for a bit
}

由于 thread2 正在调用一个 const 函数，它不应该对从 thread1 调用 bar 的输出产生任何影响 - 但如果时机正确（或错误！）它会 - 并且由于这些原因我会说在这种情况下使用mutable 来生成foo const 是错误的，即使您只使用单个线程中的类。

Answer 6

鉴于您无法检查 input_data 的等价性，您或许可以对其进行加密哈希并将其用于比较。这将消除对reuse_intermediate 标志的需要。

Answer 7

mutable 用于覆盖变量或数据成员的 const-ness。 示例：

 Class A
  {
    public:
        int m;
  }

  void foo(const A& a);

在上面的例子中，函数 foo 将被允许修改 a.m，即使你传递了一个 const 引用。 在您的示例中，我认为您不需要使用 mutable - 它可能导致非常糟糕的设计 - 因为您将写入该缓冲区。