Чрезмерное использование mutable для повышения безопасности?

Предположим, у меня есть класс, который имеет массив указателей, и у меня есть метод, который разыгрывает указатель и возвращает его в качестве ссылки. Я хочу, чтобы вызывающий метод вызывал неконстантные методы объекта, на который указывает указатель, но также хочет защитить себя от вызывающего, изменяющего то, на что указывает указатель. Если я верну ссылку на const, я должен отметить многие из методов объекта указателя как const, и, следовательно, многие из его переменных-членов класса являются изменяемыми.

1. Это плохая практика? Если да, то как мне обойти это?
2. Есть ли ограничение производительности для чрезмерного использования mutable?

Пример:

#include <iostream>
#include <array>
#include <memory>

class Counter
{
public:
  Counter();
  void hit() const;
  void reset();
  unsigned count() const;
private:
  mutable unsigned count_;
};

Counter::Counter() : count_(0) {}

void Counter::hit() const { ++count_; }

void Counter::reset() { count_ = 0; } 

unsigned Counter::count() const { return count_; }

class CircularArray
{
public:
  CircularArray();
  const Counter& next() const;
private:
  mutable unsigned i_;
  std::array<std::unique_ptr<Counter>, 3> arr_;
};

CircularArray::CircularArray() : i_(2)
{
  arr_[0] = std::unique_ptr<Counter>(new Counter);
  arr_[1] = std::unique_ptr<Counter>(new Counter);
  arr_[2] = std::unique_ptr<Counter>(new Counter);
}

const Counter& CircularArray::next() const { return *arr_[(i_ = (i_ + 1) % 3)]; }

int main()
{
  CircularArray circular;
  const Counter* p;
  p = &circular.next();

  p->hit();
  p->hit();

  Counter c;
  //*p = c; // <-- Want to prevent this
}