From: use_my_alias_here@hotmail.com   
      
   On 2012-01-05 18:03, Dave Abrahams wrote:   
   > on Wed Jan 04 2012, Gene Bushuyev  wrote:   
   >   
   >> It's a very fundamental rule that members of a template are not   
   >> implicitly instantiated until they are used. That reduces the   
   >> compilation time, size of libraries, cuts on dependencies, and makes   
   >> sfinae possible.   
   >   
   > I don't think this has anything to do with SFINAE, which applies to   
   > ordinary function templates that aren't class members.  You may be   
   > thinking of the a similar advantage: it's easy to make class templates   
   > with optional features that are supported depending on details of the   
   > template parameters.  For example, if T is LessThanComparable, you can   
   > call std::list::sort without arguments.   
   >   
   >     l.sort()   
   >   
   > This overload of std::list::sort() contains code   
   > that evaluates   
   >   
   >     x<  y   
   >   
   > where x and y are of type T.   
   >   
   > If the overload of list::sort that takes no arguments was eagerly   
   > instantiated, list  would not be usable at all with a T that isn't   
   > LessThanComparable:   
   >   
   >     struct X {};   
   >   
   >     std::list  l; //<== compilation would fail in sort()   
   >   
   > Since list::sort is instantiated only when used, we can make a   
   > list, and we're fine as long as we don't try to sort it.   
   >   
      
   Ok, thanks!   
   The only workaround I've found so far is the following in the   
   constructor of PrintingYou:   
      
   struct PrintMe   
   {   
     PrintMe() { std::cout << "PrintMe" << std::endl; }   
   };   
      
   template   
   struct PrintingYou   
   {   
     PrintingYou()   
     {   
       pm; // Refer to pm and hope this constructor is used.   
     }   
      
     static PrintMe pm;   
   };   
   template   
   PrintMe PrintingYou::pm;   
      
      
   I don't like this solution, first and foremost because it's unintuitive   
   programming. Secondly because the compiler gives:   
      
   warning: statement has no effect [-Wunused-value]   
      
   Third; I have no idea what the compiler is capable of. Maybe it decides   
   to optimize away that unused statement and the construction of PrintMe   
   with it.   
      
   The workaround that Gene Bushuyev proposed unfortunately doesn't help   
   much since if I have to make an explicit instantiation for every type   
   that uses this template then the point of templates begins to fade, and   
   it's also very error prone.   
      
   Is there a better workaround to my problem?   
      
      
   Thanks,   
   Daniel   
      
      
   --   
         [ 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)