🚀 go-pugleaf

I friend of mine ran into a rather odd situation today. We found the 
solution, but now I'm trying to find out what the standard would says about 
this
situation.

A long time ago we copied some code from a random library. Inside this code 
was something similar to:

 template <class t> class FooClass
       {
 public:
       t *FooReturn()
               {
               return (t *)UndefinedFunc();
               };
       };

Unfortunatly we forgot to copy UndefinedFunc() and its prototype along with 
the  FooClass.

As chance would have it, we never created an instance of FooClass.

On compilers A and B, FooClass compiled fine. However compiler C complained 
that FooClass called the undefined function, UndefinedFunc().

What does the standard say about templates and inline functions that are 
never used? Do they have to contain completly valid code? Or can they be 
ignored? Which compiler is right?

BTW, our solution to get the code to compile with compiler C was to simply 
delete  FooClass.

Harvey Rook
harveyr@linkage.com
"Any species that has the technology to destroy itsself, should." -Mike 
Burns


[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]