在 C++ 中向用户隐藏参数类型

Question

假设我正在编写一个容器类template <typename T> class MyContainer，出于某种原因，我想传递T 类型的对象，并且它们的类型对用户隐藏。特别是我想确保对MyContainer::Foo 的任何输入都首先通过MyContainer::HideType。

template <typename T>
class MyContainer {
 public:
  ... constructors and stuff...

  HidesType& HideType(T&);      
  T& UnhideType(HidesType&);

  void Foo(HideType&);

  ... some other stuff...
};

现在我想知道 HidesType 可以/应该是什么。一些选项是：

struct HidesType { 
  HidesType(T& data) : data_(data) { }
  T& data_; 
};
HidesType HideType(T& data) { return HidesType(data); }

union HidesType { T data_; };
HidesType& HideType(T& data) { return reinterpret_cast<HidesType&>(data); }

class HidesType : public T { };
HidesType& HideType(T& data) { return static_cast<HidesType&>(data); }

第一个问题是用户不能将T对象保留为

MyContainer<T>::HidesType tmp(HideType(t_obj));

因为一旦t_obj 超出范围，tmp 就会失效。另外，我不确定编译器是否会完全优化 HidesType。

第二个的问题是我不知道 reinterpret_cast 是否安全（例如不会有任何对齐问题吗？）。

第三个问题是 T 可能被标记为 final 并且 HidesType& 隐式转换为 T&。

任何想法或建议将不胜感激。

编辑：

隐藏的主要目的是使HidesType抽象并与T区分开来。 解释导致这个问题的所有背景会很麻烦。现在，让我们假设函数MyContainer::Foo 本质上将T 作为输入，但是，我不希望用户知道/使用它，特别是接口可能在未来发生变化。

正确的用例可能是：

MyContainer<T>::HidesType handle = MyContainer<T>::HideType(t_obj);
... do something ...
... perhaps t_obj.~T(); ...
... do something ...
my_container.Foo(handle);

无效的用例：

MyContainer<T>::HidesType handle = MyContainer<T>::HideType(t_obj);
... do something ...
my_container.Foo(some_other_t_obj);

Answer 1

您似乎想要一个类型 H，它只能由 MyContainer<T> 实例化或修改。

实现这一点的简单方法是使用private 构造函数和赋值运算符（移动构造函数除外）并将MyContainer<T> 作为friend 的类类型。

您可以将move 指定的T 对象放入其中，既是为了提高效率，也是为了避免不必要地要求它是可复制的。如果是这样，那么H 将不保证是可复制的。但在我看来，它应该是可移动的。

Answer 2

你可以这样做：

template <typename T>
class MyContainer {
public:
    class HandleType {
    public:
        friend class MyContainer;

        HandleType(const HandleType& rhs) = default;
        HandleType(HandleType&& rhs) = default;
        HandleType& operator =(const HandleType& rhs) = default;
        HandleType& operator =(HandleType&& rhs) = default;
    private:
        // only MyContainer can construct this class
        explicit HandleType(const T& t) : t(t) {}

    private:
        T t;
    };

    HandleType HideType(const T& t) { return HandleType(t); }
    T& UnhideType(HandleType& handle) { return handle.t; }

    void Foo(HandleType&);
};