C ++方法转发

Question

我需要实现一个类Container，其行为与包含的模板类完全相同：

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

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

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

我已成功实现了大多数运算符，并且它可以工作。

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

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

原因是Container显然没有这样的方法。 此外，由于T是模板，因此无法预先知道其方法。

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

你确定吗 ？

Answer 1

C ++委员会目前正在调查“重载operator . ”，以便将来修订该语言。

但是，在您的特定情况下，您可以简单地从类型继承。

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

Answer 2

对于类类型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)在运算符中的位置运行，则运算符仅参与重载get_t(Container) 。 这应该都在命名空间中完成，因此可以通过ADL找到运算符。 get_t的重载返回其参数不变可能有助于大量减少重载次数。

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

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

Answer 3

您是否反对为内部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等，后一种方法就可以工作。