C++方法转发

C++ method forwarding

本文关键字：转发 方法 C++      更新时间：2023-10-16

我需要实现一个类容器，它的作用与包含的模板类完全相同：

template <typename T>
class Container {
public:
      //...
private:
      // T data_;
};

T可以是预定义类型（例如，int）或用户定义的类型。

目的是截获对包含的类型执行的任何读/写操作。

我已经成功实现了大多数运算符，并且它有效。

但是，当我需要访问特定于所包含类 T 的方法时，它不起作用：

Container<myclass> a;
a.myclass_specific_method();

原因是容器显然没有这样的方法。此外，由于T是一个模板，因此无法事先知道其方法。

我想即使使用 C++11 也无法解决这个问题，因为operator .不能超载。因此，唯一可能的方法是始终像智能指针一样依赖operator->。

你能确认吗？

C++委员会目前正在研究"超载operator ."，以便将来对该语言进行修订。

但是，在特定情况下，只需从类型继承即可。

template <typename T>
class Container : private T {
public:
    using T::something_publicly_accessible;
};

对于类类型T，这将很像T：

template<class T, class=void>
struct Container : public T { // inheritance MUST be public
  using T::T;
  Container() = default; // or override
  Container( Container const& ) = default; // or override
  Container( Container && ) = default; // or override
  Container& operator=( Container const& ) = default; // or override
  Container& operator=( Container && ) = default; // or override
  // here, we override any method we want to intercept
  // these are used by operators:
  friend T& get_t(Container& self){return self;}
  friend T const& get_t(Container const& self){return self;}
  friend T&& get_t(Container&& self){return std::move(self);}
  friend T const&& get_t(Container const&& self){return std::move(self);}
};

对于非类T，我们检测它并使用不同的实现：

template<class T>
struct Container<T, typename std::enable_if<!std::is_class<T>{}>::type > {
  T t;
  Container() = default; // or override
  Container( Container const& ) = default; // or override
  Container( Container && ) = default; // or override
  Container& operator=( Container const& ) = default; // or override
  Container& operator=( Container && ) = default; // or override
  // these are used by operators:
  friend T& get_t(Container& self){return self.t;}
  friend T const& get_t(Container const& self){return self.t;}
  friend T&& get_t(Container&& self){return std::move(self).t;}
  friend T const&& get_t(Container const&& self){return std::move(self).t;}
};
最后，我们

以 SFINAE 友好的方式覆盖我们可以找到的每个运算符，其中操作员仅在get_t(Container)可以在运算符中的位置工作时才参与过载解决。 这应该全部在命名空间中完成，因此可以通过 ADL 找到运算符。 返回其参数不变的 get_t 重载可能有助于大幅减少重载的数量。

这可能是另外 100 行或更多行代码。

Container<T>用户可以绕过Container<T>，获取上述系统中的底层T。

您是否反对为内部data成员设置一个getter？如果没有，那么您可以使用这样的东西

#include <iostream>
#include <string>
template <typename T>
class Container
{
public:
    Container(T _data) : data{_data} {}
    T GetData() const { return data; }
private:
    T data;
};
int main()
{
    Container<std::string> c{"foo"};
    std::cout << c.GetData().size();
}

否则，您可以在内部访问该方法，并且仅当存在此方法时，该方法才会编译T 

#include <iostream>
#include <string>
template <typename T>
class Container
{
public:
    Container(T _data) : data{_data} {}
    std::size_t size() const { return data.size(); }
private:
    T data;
};
int main()
{
    Container<std::string> c{"foo"};
    std::cout << c.size();
}

因此，如果T例如 std::string、std::vector、std::list等

相关文章：