为什么在PIMPL中无法访问实现类的常量函数?

why constant function of implement class not be accessed in PIMPL?

本文关键字：常量 函数 实现 访问 PIMPL 为什么      更新时间：2023-10-16

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

就我而言，我正在使用operator()访问私人会员。

接口类A和实现类AImpl都有operator() const和operator()。

代码如下所示：

#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 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是常量时，你会得到 impl ptr 的类型为AImpl* const。 当A不是常量时，你会得到 impl ptr 的类型为AImpl*。

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

为了解决这个问题，你真的需要得到一个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，管理指针本身的销毁。

<br/>由于类通过函数返回指针，因此指针本身由value返回，这意味着调用者获得指针的副本。因此，对此指针的任何更改都将仅影响返回的副本，而不会影响类内的副本。
如果函数通过引用(AImpl*&返回指针，则声明指针也是必要的const，这几乎从未发生过。在这种情况下，const版本必须实际返回AImpl const* const&，以防止对类内的指针和指向的数据进行修改。

因为在 const 方法中，您在 const 指针(而不是指向 const 的指针)上调用运算符，因此它调用非 const 成员。

我也不明白你的结果。在我看来，指针impl应该const在const方法的范围内，因此应该调用AImpl的const方法。

在任何情况下，将A实现更改为此实现都会为您提供所需的行为：

const int &operator()() const
{
std::cout << "const access in A" << std::endl;
return const_cast<const AImpl* const>(impl)->operator()();
}
相关文章：