C++ 可变说明符

Question

什么时候可以，什么时候不能调用可变变量？

int/float/bool 值很清楚。 但是，比方说，数组。如果我要向它添加元素，我可以调用原生数组mutable 吗？与std::vector 相同。

还有一个例子。我有对象 A，它保持对另一个对象 B 的引用 (B &b)。对象 B 有本机数组，我将重新分配/std::vector（我认为在这种特殊情况下是相似的）。伪代码：

struct B{
   std::vector<int> arr;
   // int *arr;              //Or this
   void changeArr(){
     arr.push_back(90);
   }
}

struct A{
   A(B &b) : b(b){};
   mutable B &b;     // is it ok to have it "mutable"?
   //mutable B b;    // or even this?
   void fire() const{
      b.arr.push_back(125);
      // Or 
      b.changeArr();
   }
}

我可以打电话给B &b mutable 吗？

---

更新

根据http://en.cppreference.com/w/cpp/language/cv：

mutable - 定义一个类的成员不影响 类的外部可见状态。

这是什么externally visible state of the class？当我增加数组大小，重新分配一些东西时，我会改变它吗？如果没有，什么时候改变？

Answer 1

让我们举两个经典的例子来说明 mutable 的用处：

1。记住计算 (memoization)

class prime_caclulator {
    private:
        mutable std::vector<int> m_primes;

    public:
        get(int n) const {
            // 1. If the nth prime is in m_primes, return it.
            // 2. Otherwise, calculate the nth prime.
            // 3. Store the nth prime in m_primes.
            // 4. Return that prime.
        }
};

这里，我们有一个常量函数get()，它不需要改变这个对象的内部状态来计算第n个素数。但是，跟踪先前计算的素数可能会有所帮助，以提高该对象的性能。

这个内部状态，在这里我们称为m_primes，可能会在调用get() 时发生变化，因此我们需要将其标记为可变。请注意，该对象的不同内容只会改变调用所花费的时间，而不是它最终返回的内容。

2。线程安全

template <typename T>
class thread_safe_queue {
    private:
        mutable std::mutex m_mutex;
        std::queue<T> m_queue;

    public:
        size_t size() const {
            std::lock_guard<std::mutex> lock(m_mutex);
            return m_queue.size();
        }

        void push(T value) {
            std::lock_guard<std::mutex> lock(m_mutex);
            m_queue.push(value);
        }

        T pop() {
            std::lock_guard<std::mutex> lock(m_mutex);
            T top = m_queue.front();
            m_queue.pop();
            return top;
        }
};

在这种情况下，如果我们没有可变互斥体，那么我们将无法让 size() 成为 const，因为我们在该函数的过程中修改了 m_mutex。