6a68ed9a   
   From: daniel.kruegler@googlemail.com   
      
   Am 28.11.2011 23:31, schrieb Lorenzo:   
      
   > I feel I should explain you the background of my question... but it's   
   > such a bogus attempt that I don't even know where to start... don't   
   > scream at me saying that I'm crazy :)   
      
   I'm not screaming, but I'm still not sure what *precisely* you want,   
   lets follow what you write:   
      
   > I was trying to see if there any trick to define a function within a   
   > local type that has polymorphic behavior in its parameter type.   
   > Normally, this is done using template:   
   >   
   > // some non-local scope:   
   > template   
   > void f(T x) {}   
   >   
   > f(123);   
   > f("abc");   
      
   Fine so far.   
      
   > f can be called with int, string, etc :) However, templates cannot be   
   > part of a local type, not even in C++011 :( In other words, the   
   > following doesn't compile:   
   >   
   > void f() {   
   >      struct ltype {   
   >          template  // Error: Can't do this :(   
   >          void f(T x) {}   
   >      } l;   
   >      l.f(123);   
   >      l.f("abc");   
   > }   
      
   You cannot do this, correct, but what is wrong with   
      
   struct lbase {   
     template   
     void f(T const& x) {}   
   };   
      
   void test() {   
    lbase l;   
    l.f(123);   
    l.f("abc");   
   }   
      
   ?   
      
   Note that you have not presented anything interesting yet that   
   demonstrates why you need lbase to be a local class.   
      
   > So I was thinking of putting the template into a base of ltype (lbase)   
   > and then using variadic arguments but then I again need the actual   
   > type when I extract the variadic argument:   
   >   
   > #include   
   > #include   
   >   
   > template   
   > void f(T const&  x) { std::cout<<  x<<  std::endl; }   
   >   
   > struct lbase {   
   >      virtual void body(int argc, ...) = 0;   
   >   
   >      template   
   >      void f(T const&  x) { body(1, x); }   
   > };   
   >   
   > int main ( ) {   
   >      f(123);   
   >      f("abc");   
   >   
   >      struct ltype : lbase {   
   >          void body(int argc, ...)   
   >          {   
   >              va_list argv;   
   >              va_start(argv, argc);   
   >              auto x = va_arg(argv, int); // I need the type :(   
   >              {   
   >                  std::cout<<  "body "<<  x<<  std::endl;   
   >              }   
   >              va_end(argv);   
   >          }   
   >      } l;   
   >      l.f(123);   
   >      l.f("abc");   
   >   
   >      return 0;   
   > }   
      
   Except for much more complications in your code above, why would   
      
   #include   
      
   struct lbase {   
     template   
     void f(T const& x) { std::cout<<  x<<  std::endl; }   
   };   
      
   void test() {   
    struct ltype : lbase {} l;   
    l.f(123);   
    l.f("abc");   
   }   
      
   not solve your problem as well? (The class derivation is not necessary   
   here, I just use this to demonstrate the analogy to your code above)   
      
   Does this have to do with function objects in local scope that should   
   have an operator() overload which is a function template?   
      
   > Now I can call l.f(123) and l.f("abc") and both these calls will end   
   > up calling the body() (variadic arguments might not even be really   
   > needed for that). But in the body I need to know x's type (int,   
   > string, etc) in order to extract it so I was looking into ways around   
   > that (there might be none because the compiler really needs x's type   
   > information statically in order to compile the body function...).   
      
   You don't really explain the reason for your type-erase-type-unerasure   
   cycle (except that you want to demonstrate how to fake compile-time   
   polymorphic local classes), but if you really want to follow this route,   
   you should better use boost::any for the erased type instead of   
   dangerous hacks with va_list's. boost::any provides access to an   
   std::type_info object of the wrapped type, but using this here would   
   still require a switch over possible types. This switch must naturally   
   be finite, so cannot cover all types in general. Nonetheless I mention   
   this here, because it could be that your actual types are within a   
   limited set of types that you all know.   
      
   > I was trying to have lbase::f encapsulate the type information T into   
   > a base class argbase that will then expose it via a covariant virtual   
   > function.   
      
   By the nature of dynamic polymorphism this is not possible. Why not   
   using the function template directly?   
      
   > argbase will be passed as another parameter to the body and   
   > then I could use decltype(argbase.covariant_virtual_func()) inside   
   > body to deduce the type T of the argument x. My attempt failed   
   > miserably...   
      
   Well, yes, this cannot work.   
      
   I think we need to get more information for what you want to realize, as   
   explained above.   
      
   HTH & Greetings from Bremen,   
      
   Daniel Krügler   
      
      
   --   
         [ See http://www.gotw.ca/resources/clcm.htm for info about ]   
         [ comp.lang.c++.moderated.    First time posters: Do this! ]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)