如何调用PIMPL设计模式中的参数化构造函数？

  • Z时代
  • 2024-01-10
  • 分类：问答

如何将PIMPL设计用于参数化构造函数？如何调用PIMPL设计模式中的参数化构造函数？

/* 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(); 
    } 
}

当我编译这个我得到错误： Process.cpp：错误：非法使用类ProcessImpl
这是抛出错误的行_impl-> ProcessImpl（ldframework ::的ProcessID thirdParty_pid）

Please help

回答：

只是在构造函数中构造pimpl。

请注意，您还应该实现复制构造函数和赋值运算符，因为当两个副本都被破坏时，复制对象将导致未定义的行为。

理想情况下，平普尔应始终有效，以避免检查它是否有效的时候，但你的代码去，你也许可以有以下几种：

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_; 
};

回答：

因为你的代码是无效的C++我因此我将从头开始：

如果某个类具有参数化构造函数，则需要参数来直接或间接地初始化类成员和基类。由于pimpl类没有自己的数据成员（pimpl除外），因此构造函数参数仅用于实现类的初始化。
有PIMPL方法实现的两个极端：

  1. 所有逻辑进入实现类和外部类只是一个哑巴fassade，转发到平普尔任何电话。

  2. 该逻辑保留在外部类中，pimpl只是一个无用的数据包。

当然，在实践中，任何介于两者之间都是可能的。

在案例1中，在外部类的构造函数签名应该是一样的实现类的签名构造，只是传递任何参数的构造函数平普尔：

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)) 
{}

一起：

  1. 使用的类相同的构造特征及平普尔类，每一类的构造函数只是调用相应的平普尔构造函数采取引用或指针

  2. 参数原样传递给pimpl构造函数

  3. 将值取值的参数移至pimpl构造函数（转发）

这是最简单的可能解决方案，其中构造函数逻辑完全在实现类中实现。

在其他情况下，这里的平普尔类只是数据包，您将有逻辑外class`构造函数中，像这样：

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(); 
}

你看，战略实施构造函数取决于你实施pimpl习语的策略。只要确保在将该逻辑委派给pimpl类或将其留在主类中时有点一致。

以上是 如何调用PIMPL设计模式中的参数化构造函数？ 的全部内容， 来源链接： utcz.com/qa/261920.html

回到顶部