Question

此代码编译良好：

 int main() 
 { 
   class lm { 
      public: 
       int operator()(int x,int y){ 
          return x+y; 
        }
   }; 

   int x = lm()(10,15);
   return 0;
 }

但这不是

 int main() 
 { 
   template<class T>
   class lm { 
      public:
       T operator()(T x,T y){ 
          return x+y; 
        }
   }; 

   int x = lm()(10,15);
   return 0;
 }

为什么我这样做？因为我想在另一个函数内伪造一个多态lambda函数。其他建议也欢迎。

最终我想做的是：

class A{
int m_var;
public:
int f(int x,int y);
}
int A::f(int x, int y)
{
   template<class T>
   class lm { 
      public:
       T operator()(T x,T y){ 
          return x+y+ m_var; //accessing the member variable of class A
        }
   }; 

   int x = lm()(10,15);
   return 0;
}

关键是函数对象应该能够访问class A的成员变量任何解决方法也会有所帮助。

Answer 1

本地类不能有成员模板（C ++ 03和C ++ 11都是这种情况）。

显而易见的解决方案是移动类，使其处于命名空间范围：

namespace {
    struct lm {
        template <typename T> T operator()(T x, T y) { return x + y; }
    };
}

int main() {  
    int x = lm()(10,15); 
}

如果要将模板与要使用的函数“关联”，请将其粘贴到main_stuff命名空间中。

Answer 2

你所问的对我来说似乎是不必要的。避免这样的代码。

本地课程不会自动“捕获”封闭课程A的成员。
本地类lm的模板参数未使用且多余。
此外，它不会这样编译，因为T隐藏了T。
根据类定义，lm()(10,15)的使用至少需要lm<int>()的模板参数（类型推断仅支持函数类）
本地lm类的 genericity 是假的：封闭函数调用保证x和y的静态类型为{{1} }第

叹息。这就是我要做的事情：

int

返回template <typename T> class A { const T m_var; public: A(T var) : m_var(var) {} T operator()(T x, T y) const { return x + y + m_var; } }; template <typename T> A<T> helper(T var) { return A<T>(var); } int main() { return helper(42)(10,15); }

多态类的问题

2 个答案: