有没有办法摆脱虚拟成员函数的常数性

Question

I need to implement a mock for an interface that is defined something like:

class Foo
{
public:
  void sendEvent(int id) const = 0;
}

My mock class needs to save all event id's sent to the class. This is how I intended to do it.

class FooMock : Foo
{
private: 
  m_vector std::vector<int>;
public:
  void sendEvent(int id) const {m_vector.push_back(id);}

}

But obviously the compiler refuses that construction. Are there any solutions to this (assuming the interface could not be changed)?

I realize that I can use two classes for this. But isn't there a way to shut the compiler up and allow me to to this, similar to const_cast?

Answer 1

You can make the vector mutable so that it can be modified from within const methods, like this:

mutable std::vector<int> m_vector;

Note however that this makes the vector mutable from all methods. If you only want to write to it from a single method, a const_cast is less invasive, in that you cast the constness of this away just for a single call:

FooMock * const that = const_cast<FooMock * const>(this);
that->m_vector.push_back(id);

I'm being a bit pedantic here - inside a const method, this has the type T const * const (so both the object being pointed to as well as the pointer itself are const). The const_cast just casts away the constness of the object, but not of the pointer.

Answer 2

Another method without mutable (when that is not available) and const_cast is using pointer-members. The pointees don't follow the constness.

class FooMock : Foo
{
private: 
  boost::scoped_ptr<std::vector<int> > m_vector;
public:
  FooMock() : m_vector(new std::vector<int>) { }
  void sendEvent(int id) const {m_vector->push_back(id);}
}

When possible, I would use mutable for mocking.

Answer 3

const-ness of a member-function is a part of the function signature. You cannot get rid of it.

However, you can define the member as mutable , which you want to mutate in a const member function. The keyword mutable would make the member mutable/modifiable even in a const-member function and even if the object is const.

Answer 4

You could mark m_vector as mutable :

mutable std::vector<int> m_vector;

mutable generates a bit of controversy similar to const_cast , and it results in a bit of a theoretical discussion about what it really means to be const . Basically it would be justified here as long as the external behavior remains const-like, which I assume is true looking at this example.