C++ 如何编写一个包装器来不断敲打输出？

基本上，我想做的是在某个抽象类上有一个包装器，然后在该类的任何成员函数的输出上有相同的包装器类。继续这样做，以便始终包裹所有对象

Like（预编码）

---

我之所以使用wrap L而不是wrap T，是因为返回类型可能并不总是T。

似乎错误在您的

testclass

定义中。请检查下面的示例

此外，可以将wrap in运算符（）作为引用返回。我认为没有必要创建用于（）链接的临时表

template<class T>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};

  template<class L, class...R>
  wrap<T>& operator() (L(T::*f)(R...),R...r){
    a.f(r...);
    return *this; //returning reference to current wrap object.
  }
  T a;
};

模板
结构包裹{
模板
换行（Args&&…Args）：一个{std:：forward（Args）…}{}；
模板
换行符和运算符（）{
a、 f（r…）；
return*this；//返回对当前包裹对象的引用。
}
Tα；
};

累积数字的测试类

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int f(int x) {
        m += x;
        std::cout << ' ' << m;
        return m;
    }
};

class测试类{
int m；
公众：
testClass（int_m）：m{{u m}{}
整数f（整数x）{
m+=x；
std:：cout您可以尝试以下方法：

#include <iostream>
#include <type_traits>

template<class T, bool = false>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(T::*f)(R...),R...r){
    return wrap<L,std::is_fundamental<L>::value > {(a.*f)(r...)};
  }
  T a;
};

template<class T>
struct wrap <T,true>{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {}
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(*f)(T a, R...), R...r){
      return wrap<L,std::is_fundamental<L>::value > {f(a, r...)};
  }
  T a;
};

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int multiAdd(int x, char y) {
        m += x + y;
        return m;
    }
};

int add(int a, char b)
{
    return a+b;
}

int main(){
  wrap<testClass> a{0};
  std::cout << a(&testClass::multiAdd,0,'d')(add,'a').a<<std::endl;

  wrap<int, true> b{3};
  std::cout << b(add,'a').a<<std::endl;
}

#包括
#包括
模板
结构包裹{
模板
换行（Args&&…Args）：a{std:：forward
你不需要a.*f而不是a.f吗？@JerryJeremiah我记得函数指针将被视为与函数和工作代码中的a.f一样。你的
testclass
定义如何？你能给我们一个片段吗？我试图模拟你的wrap。这似乎有效。我认为错误在于你对
testclass的定义
返回包装（a.f（r…）
对我来说非常好。问题是当你想创建
wrap
ex.
wrap
时，因为没有指向
int
方法的指针。
t::*f
将扩展到
int::*f
或者编译器这么认为；）。可能你错误地假设结果类型与基类具有相同的类型。@Logman否。你能arify你是什么意思？Ther
operato（）
返回一个
wrap&
，这样我们就可以再次调用返回类型上的
operator（）
。testClass:：f返回int，这意味着他希望像这样包装结果，而不是包装。实际上，他在问题中指出：“它正在工作（gcc，c++0x）”但是当我用以下内容替换6,7行时（实际包装结果）…”。在他的代码中，L参数很重要，而不是T
wrap<L> operator() (L(T::*f)(R...),R...r){
  return wrap<L>(a.f(r...));

struct testClass{
  int f(int a,char b){
    return a+b;
  }
};

template<class T>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};

  template<class L, class...R>
  wrap<T>& operator() (L(T::*f)(R...),R...r){
    a.f(r...);
    return *this; //returning reference to current wrap object.
  }
  T a;
};

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int f(int x) {
        m += x;
        std::cout << ' ' << m;
        return m;
    }
};

int main(){
  wrap<testClass> a{0};
  a(&testClass::f,13)(&testClass::f, 11)(&testClass::f,3)(&testClass::f, 21);
}

#include <iostream>
#include <type_traits>

template<class T, bool = false>
struct wrap{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {};
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(T::*f)(R...),R...r){
    return wrap<L,std::is_fundamental<L>::value > {(a.*f)(r...)};
  }
  T a;
};

template<class T>
struct wrap <T,true>{
  template <typename... Args>
  wrap(Args&&... args) : a{std::forward<Args>(args)...} {}
  template<class L, class...R>
  wrap<L,std::is_fundamental<L>::value> operator() (L(*f)(T a, R...), R...r){
      return wrap<L,std::is_fundamental<L>::value > {f(a, r...)};
  }
  T a;
};

class testClass {
    int m;
public:
testClass(int _m) : m{_m}{}
    int multiAdd(int x, char y) {
        m += x + y;
        return m;
    }
};

int add(int a, char b)
{
    return a+b;
}

int main(){
  wrap<testClass> a{0};
  std::cout << a(&testClass::multiAdd,0,'d')(add,'a').a<<std::endl;

  wrap<int, true> b{3};
  std::cout << b(add,'a').a<<std::endl;
}