How to invoke parameterised constructor in PIMPL design pattern? - c++

Question

How to use PIMPL design for parameterized constructor?
/* ProcessImpl.h */
class ProcessImpl {
public :ProcessImpl();
ProcessImpl(ProcessID thirdParty_pid);
~ProcessImpl();
}
/* Process.h */
class Process {
public:virtual ~Process () {};
Process();
Process(ProcessID thirdParty_pid);
protected:
void createImpl();
private:
ProcessImpl * _impl;
}
/* Process.cpp */
Process::Process():_impl(NULL) {
}
Process::Process(ProcessID thirdParty_pid) {
createImpl();
_impl->ProcessImpl(ldframework::ProcessID thirdParty_pid);
}
void Process::createImpl(){
if(this->_impl == NULL) {
this->_impl = new ProcessImpl();
}
}
When I compile this I am getting error:
Process.cpp: error: invalid use of class ProcessImpl
This is the line throwing error _impl->ProcessImpl(ldframework::ProcessID thirdParty_pid)
Please help

Answer 1

Since your code is not valid C++ I won't jump into conclusions about your actual implementation, so I will start from the beginning:
If a class has a parametrized constructor, the parameters are needed to directly or indirectly initialize class members and base classes. Since a pimpl'd class has no data members of its own (except the pimpl), constructor parameters are needed only for the initialization of the implementation class.
There are two extremes of the pimpl idiom implementation:
All the logic goes into the implementation class, and the outer class is only a dumb fassade, forwarding any calls to the pimpl.
The logic remains in the outer class, the pimpl is only a dumb bundle of data.
Of course, in practice, anything in between is possible.
In case 1, the outer class' constructor signatures should be the same as the signature of the implementation class' constructors and just pass any arguments to the pimpl constructors:
Foo.h
class Foo {
struct FooImpl;
std::unique_ptr<FooImpl> pImpl;
public:
~Foo();
Foo(A const& a);
Foo(B b, C* c, D& d);
};
Foo.cpp
struct Foo::FooImpl {
FooImpl(A const& a);
FooImpl(B b, C* c, D& d);
/* Logic goes here */
};
Foo::~Foo() {} //defined here for correct deletion of the unique_ptr
Foo::Foo(A const& a)
: pImpl(std::make_unique<FooImpl>(a))
{}
Foo::Foo(B b, C* c, D& d)
: pImpl(std::make_unique<FooImpl>(std::move(b), c, d))
{}
Together:
Use the same constructor signatures for the class and the pimpl-class, each class constructor just calls the corresponding pimpl-constructor
Parameters taken by reference or pointer are passed as-is to the pimpl constructor
Parameters taken by value are moved to the pimpl constructor (forwarding)
That is the simplest possible solutution where the constuctor logic is entirely implemented inside the implementation class.
In the other case, where the pimpl class is only a bundle of data, you will have the logic inside the outer class` constructor, like this:
struct Foo::FooImpl {
FooImpl(A const& a, B b, E e, F f);
A a;
};
Foo::Foo(B b, C* c, D& d)
: pImpl(std::make_unique<FooImpl>(A(), std::move(b), calcE(c,d), getSomeF())
{
pImpl->a = someValueForA();
}
You see, the strategy to implement the constructors depends on your strategy to implement the pimpl idiom alltogether. Just make sure you are somewhat consistent in either delegating the logic to the pimpl class or leaving it in the main class.

Answer 2

Just construct the pimpl in the constructor.
Note that you should also implement a copy constructor and assignment operator as copying the object will result in undefined behaviour when both copies are destructed.
Ideally the pimpl should always be valid to avoid checking if it is valid all the time, but going by your code, you could perhaps have the following:
class Process {
public:
virtual ~Process () {
};
Process() {
// Ideally the impl_ pointer should be intialized to avoid
// having to check it in every function that uses it..
}
Process(ProcessID pid) {
impl_.reset(new ProcessImpl(pid));
}
Process(Process const& rhs) {
if (rhs.impl_.get()) {
impl_.reset(new ProcessImpl(*rhs.impl_));
}
}
Process& operator=(Process const& rhs) {
if (this != &rhs) {
if (rhs.impl_.get()) {
impl_.reset(new ProcessImpl(*rhs.impl_));
}
else {
impl_.reset();
}
}
return *this;
}
private:
std::unique_ptr<ProcessImpl> impl_;
};