Static introspection of method argument type in C++

Question

I want to make a templated class which holds an instance of another class and forwards one of its foo methods with the correct argument type. Is there a clever meta-programming way of doing a "perfect forwarding" of the inner method?

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

};

I can see two classic solutions, but is there a better modern one with meta-programming?

• Inheritance with partially protected interface: Outer could publicly inherit from Inner. But Inner also has methods which are only to be called by Outer and not the user. Those can be protected, ok, but it also tightly couples the implementations of Outer and all types of Inner classes. The public interface of Outer can be arbitrarily extended by public methods in Inner, which is not desired.
• Make foo a templated function template <typename T> void foo(T&& arg) { inner.foo(std::forward<T>(arg)); }. This is perfect forwarding of the argument, but if a user calls foo with the wrong argument, the error reports Inner::foo instead of Outer::foo. This breaks the encapsulation provided by the public interface of Outer.

Answer 1

Something along these lines perhaps:

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

Demo

Answer 2

Here's one way which gives almost perfect error messages:

#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");

}

Link here: https://godbolt.org/g/UvsrbP