Skip to main content
 首页 » 编程设计

c++之为什么PIMPL中不能访问实现类的常量函数

2024年04月12日20TianFang

我想尝试一下 C++ 中的 PIMPL。

就我而言,我正在使用 operator()访问私有(private)成员。

接口(interface)类A并实现类AImpl都有operator() constoperator() .

代码如下:

#include <iostream> 
class AImpl 
{ 
public: 
    explicit AImpl() 
    { 
        x = 0; 
    } 
    const int &operator()() const 
    { 
        std::cout << "const access in AImpl" << std::endl; 
        return x; 
    } 
    int &operator()() 
    { 
        std::cout << "not const access in AImpl" << std::endl; 
        return x; 
    } 
 
private: 
    int x; 
}; 
 
class A 
{ 
public: 
    A() 
    { 
        impl = new AImpl; 
    } 
    ~A() 
    { 
        delete impl; 
    } 
    const int &operator()() const 
    { 
        std::cout << "const access in A" << std::endl; 
        return impl->operator()(); 
    } 
    int &operator()() 
    { 
        std::cout << "not const access in A" << std::endl; 
        return impl->operator()(); 
    } 
 
private: 
    AImpl *impl; 
}; 
 
int main() 
{ 
    A non_const_a; 
    std::cout << non_const_a() << std::endl; 
 
    const A const_a; 
    std::cout << const_a() << std::endl; 
} 
 

我用以下命令编译程序

g++ Main.cpp 

结果表明:

# ./a.out 
not const access in A 
not const access in AImpl 
0 
const access in A 
not const access in AImpl 
0 

从结果可以看出:

A的 const 成员函数 const int &A::operator()() const调用int &AImpl::operator()() ,但不调用const int &AImpl::operator()() const .

为什么会发生这种情况?

在PIMPL情况下,我希望A中的成员函数和AImpl是一一对应的。

我想让 const int &A::operator()() const调用const int &AImpl::operator()() const .

如何修改我的代码来实现这一目标?修改是否会降低性能?

上面提到的是一个简单的案例。在实际情况中,A是一个容器,将在我的代码中广泛使用,因此我不希望修改降低性能。

如果这是一个愚蠢的问题,我深表歉意。感谢您抽出时间。

请您参考如下方法:

您正在寻找不同的常量行为。

AImpl const*AImpl* const 不同。

A为const时,您得到的impl ptr为AImpl* const类型。 当 A 不是 const 时,您将获得 AImpl* 类型的 impl ptr。

在这两种情况下,指针指向的数据始终是AImpl*(非常量)。指针本身可能是也可能不是 const,因此允许您更改它指向或不指向的位置。 但它指向的数据始终是非常量的。

为了解决这个问题,您确实需要获取 AImpl*AImpl const* 的指针(或者更好, AImpl const * const,表示指针及其指向的数据都是常量) 1。您有多种方法可以做到这一点:

您只需向指针添加一些访问器即可:

AImpl* getImpl() { return impl.get(); } 
AImpl const *getImpl() const { return impl.get(); } 

这种方法有一个不便之处,您必须记住始终使用访问器来获取正确的 const 版本,而直接使用 impl 指针可能会导致错误的行为。

另一种方法是添加一个容器模板类,它保存指针并声明不同的operator()访问器,为每个访问类型返回正确的类型。一个基本的例子是:

template <typename _Tp> 
class pimpl_ptr 
{ 
public: 
    pimpl_ptr(_Tp *q, U&&... u): fPtr(q) { } 
 
    _Tp const* operator->() const noexcept 
    { 
        return fPtr; 
    } 
    _Tp* operator->() noexcept 
    { 
        return fPtr; 
    } 
private: 
    _Tp *fPtr; 
}; 

还有一个额外的好处,该类还可以实现 RAII,管理指针本身的销毁。

<小时 />

1 这并不是真正需要的。
由于类通过函数返回指针,因此指针本身是通过value返回的,这意味着调用者获得了指针的拷贝。因此对此指针的任何更改都只会影响返回的拷贝,而不影响类内的拷贝。
如果函数通过引用返回指针 (AImpl*&),则必须将指针声明为 const,但这种情况几乎不会发生。在这种情况下,const 版本必须实际返回 AImpl const* const&,以防止对类内部的指针和指向的数据进行修改。