C++ 使用 mutator 方法初始化 const 成员

Question

假设存在以下类(我无法更改)。

class TheirClass {
 public:
  TheirClass();
  TheirClass(const TheirClass&) = delete;
  TheirClass& operator=(const TheirClass&) = delete;
  TheirClass(TheirClass&&) = delete;
  void FinishInitialization();
}

我想像这样在我的类里面使用它。

class MyClass {
 private:
  const TheirClass their_class_;
}

如果复制和移动构造函数没有被删除，我可以做这样的事情。

TheirClass CreateTheirClass() {
  TheirClass their_class;
  their_class.FinishInitialization();
  return their_class;
}

MyClass::MyClass() : their_class_(CreateTheirClass()) {}

目前我的解决方案是使用指针。

class MyClass {
 private:
  const std::unique_ptr<const TheirClass> their_class_;
}

std::unique_ptr<TheirClass> CreateTheirClass() {
  auto their_class = std::make_unique<TheirClass>();
  their_class->FinishInitialization();
  return their_class;
}

MyClass::MyClass() : their_class_(CreateTheirClass()) {}

但这似乎增加了不必要的复杂性和不必要的性能损失(将对象存储在堆而不是堆栈上)。

如何让一个 const TheirClass 作为我的类中的成员，同时仍然能够调用 TheirClass::FinishInitialization (一次，在我的类初始化时)？

Answer 1

您可以创建一个包装类，在其构造函数中调用FinishInitialization，但仅将实例公开为const。

class TheirClassWrapper final
{
public:
    /// The question didn't specify `args`, but I assume you want them here
    template <typename... Args>
    explicit TheirClassWrapper(Args&&... args)
            : impl_()
    {
        impl_.FinishInitialization(std::forward<Args>(args)...);
    }

    const TheirClass& operator*() const noexcept { return impl_; }

    const TheirClass* operator->() const noexcept { return &impl_; }

private:
    TheirClass impl_;
};

改用包装器:

class MyClass
{
public:
    MyClass();

    // ...

private:
    const TheirClassWrapper their_class_;
}

然后，您可以使用 their_class_->whatever() 或 *their_class_ 来访问内容。它看起来像一个指针，但它会被编译器简单地内联。

<小时/>

一个可能更通用的解决方案是:

template <typename T>
class InitWrapper final
{
public:
    template <typename FInit>
    explicit InitWrapper(FInit&& init)
    {
        init(impl_);
    }

    const T& operator*()  const noexcept { return impl_; }
    const T* operator->() const noexcept { return impl_; }

private:
    T impl_;
};

这允许您在 InitWrapper 构造函数中运行一些任意函数，同时仍然只公开事物的 const T View 。

MyClass::MyClass()
        : their_class_([](TheirClass& x) { x.FinishInitialization(); })
{ }