From: ulrich.eckhardt@dominolaser.com   
      
   Am 27.01.2012 08:48, schrieb Daniel Krügler:   
   > Am 26.01.2012 20:46, schrieb Frank Birbacher:   
   > [..]   
   >> In C++ the calling contex of a function will not determine it's return   
   >> type nor will it resolve overloads. [..] Functions   
   >> are determined by parameter types only. So the template operator() you   
   >> mentioned cannot deduce its return type from its use.   
   >   
   > I agree in principal, but it should be noted that conversion functions   
   > are one special example which allow to deduce a return type   
   [...]   
   > it does not solve the OPs problem, though.   
      
   I beg to differ, you just have to return a proxy type with a template   
   conversion operator:   
      
   #include    
   #include    
      
   struct X   
   {   
      // actual template function to be called   
      template T call() const   
      {   std::cout << "call<" << typeid(T).name() << ">()\n"; }   
      
      // proxy type   
      struct P   
      {   
          explicit P(X const& x): m_x(x) {}   
          template operator T() const   
          {   return m_x.call(); }   
      private:   
          X const& m_x;   
      };   
      
      /* Attention: This doesn't call any function, it only   
      creates a proxy. */   
      P operator()() const   
      {   return P(*this); }   
   };   
      
   int main()   
   {   
      X x;   
      
      int vi = x();   
      float vf = x();   
   }   
      
      
   A big danger here is that no function is called if the result of x() is not   
   used anywhere. However, I don't think this is used in places where you rely on   
   the side effects of calling a function.   
      
      
   ^)   
      
      
   Uli   
      
      
   --   
         [ 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)