проблема с полиморфным классом

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

Почему я это делаю?потому что я хочу подделать полиморфную лямбда-функцию внутри другой функции.Также приветствуются и другие предложения.

В конечном итоге я хотел бы сделать следующее:

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 является поддельным: вызов функции включения гарантирует, что статические типы x и y будут int с.

Sigh.Вот что я бы сделал:

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

возвращая 67