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

Question

Suppose the following class exists (which I cannot change).

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

I would like to use it in my class like so.

class MyClass {
 private:
  const TheirClass their_class_;
}

If the copy and move constructors were not deleted, I could do something like this.

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

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

Currently my solution is to use pointers.

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

But this seems to add unnecessary complexity and a needless performance hit (storing the object on the heap rather than the stack).

How can I have a const TheirClass as member in my class while still being able to call TheirClass::FinishInitialization (once, upon initialization of my class)?

Answer 1

You can make a wrapper class that calls FinishInitialization in its constructor, but only exposes the instance as a 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_;
};

Use the wrapper instead:

class MyClass
{
public:
    MyClass();

    // ...

private:
    const TheirClassWrapper their_class_;
}

You then use their_class_->whatever() or *their_class_ to access things. It looks like a pointer, but it will get trivially inlined by your compiler.

---

A potentially more generic solution to this is:

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

This allows you to run some arbitrary function in the InitWrapper constructor, while still only exposing the const T view of things.

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