Re: Instantiating an abstract class
On Oct 16, 10:25 am, "dasca...@gmail.com" <dasca...@gmail.com> wrote:
Hi,
For a project I'm working on I'm kind-of-hacking my way around
deriving a class from an interface or such to create a mock, but
instead creating the mock directly. It is usable as the interface type
(as the virtual functions match up), but there is a snag. No members
are initialized, which means it can't be used as the original type if
it has anything but virtual functions. It would be possible to make it
work, if I could call the constructor for the original type, but
because the functions are pure virtual that's not allowed. Deriving
from it would work, but requires me to fill in all the pure virtual
functions with some kind of random function only to never use them.
The last solution also requires you to un-pure-virtualize all the
classes you want to mock just for testing, which seems like a really
bad idea since it is a *lot* more to type.
Is there some kind of hackish or at least usable way of calling the
constructor regardless of pure virtual functions?
Thanks in advance,
Peter Bindels
Soory but we don't 'hack' here.
If your AbstractInterface is pure abstract, then why not derive from
that to provide an Interface type. Your project can then use that
Interface and you the original AbstractInterface to derive that mock
type. Makes sense to me since the mock doesn't need the virtual
functions. It remains to be seen whether the following fullfills
requirements.
Both AbstractInterface and Interface are pure:
#include <iostream>
class AbstractInterface
{
public:
virtual ~AbstractInterface() = 0;
};
AbstractInterface::~AbstractInterface()
{
std::cout << "~AbstractInterface()" << std::endl;
}
class MockInterface : public AbstractInterface
{
};
class Interface : public AbstractInterface
{
public:
~Interface()
{
std::cout << "~Interface()" << std::endl;
}
virtual void foo() const = 0;
};
class ConcreteInterface : public Interface
{
public:
~ConcreteInterface()
{
std::cout << "~ConcreteInterface()" << std::endl;
}
void foo() const
{
std::cout << "ConcreteInterface::foo()" << std::endl;
}
};
int main()
{
ConcreteInterface concrete;
concrete.foo();
MockInterface mock;
}