Question

我想制作一个模板化类，该类包含另一个类的实例，并使用正确的参数类型转发其foo方法之一。有一种巧妙的元编程方法可以对内部方法进行“完美转发”吗？

template <typename Inner>
class Outer {
private:
  Inner inner;

public:

  // To-do: replicate foo method of Inner with identical signature,
  // how to pick correct T?
  void foo(T arg) { inner.foo(arg); }

};

我可以看到两种经典的解决方案，但是有一种更好的现代元编程解决方案吗？

具有部分受保护的接口的继承：Outer可以从Inner公开继承。但是Inner也有只能由Outer而不是用户调用的方法。可以是protected，可以，但是它也将Outer和所有类型的Inner类的实现紧密地结合在一起。 Outer的公共接口可以通过Inner中的公共方法任意扩展，这是不希望的。
为foo创建模板函数template <typename T> void foo(T&& arg) { inner.foo(std::forward<T>(arg)); }。这是参数的完美转发，但是如果用户使用错误的参数调用foo，则错误将报告Inner::foo而不是Outer::foo。这破坏了Outer的公共接口提供的封装。

Answer 1

也许遵循这些思路：

template <typename Inner>
class Outer : private Inner {
public:
  using Inner::foo;
};

Demo

Answer 2

这是给出几乎完美错误消息的一种方法：

#include <string>

// a type which yields the type we gave it
template<class T> struct passer 
{ 
    using type = T; 
};

// an easy-to-use alias
template<class T> using pass_t = typename passer<T>::type;

// example
template <typename Inner>
class Outer {
private:
  Inner inner;

public:

  // To-do: replicate foo method of Inner with identical signature,
  // how to pick correct T?
  // Ans: with a pass_t
    template<class T>
    auto foo(T&& arg) 
    -> pass_t<decltype(this->inner.foo(std::forward<T>(arg)))>
    {
       return inner.foo(std::forward<T>(arg)); 
    }

};


struct Bar
{
    void foo(std::string const& thing);
};

struct Baz
{
    int foo(int thing) { return thing * 2; };
};

int main()
{

    auto o = Outer<Bar>();
    o.foo(std::string("hi"));
    o.foo("hi");

    int i = 1;

    /* - uncomment for error
    o.foo(i);

    note the nice error message on gcc:
        <source>:41:7: error: no matching member function for call to 'foo'
        <source>:19:10: note: candidate template ignored: substitution failure [with T = int]: reference to type 'const std::string' (aka 'const basic_string<char>') could not bind to an lvalue of type 'int'
    */

// same here:
//    o.foo(1);

// but this is fine
    auto o2 = Outer<Baz>();
    auto x = o2.foo(2);

    // and this is not
    // note: candidate template ignored: substitution failure [with T = char const (&)[6]]: cannot initialize a parameter of type 'int' with an lvalue of type 'char const[6]'
//    auto y = o2.foo("dfghj");

}

链接在这里：https://godbolt.org/g/UvsrbP

C ++中方法参数类型的静态自省

2 个答案: