🚀 go-pugleaf

In article i3d@engnews2.Eng.Sun.COM, "bnr (n.) postmaster" <postmast@bnr.ca> writes:
>
>template<class T>
>class Foo {
>public:
>   // etc...
>   int Bar(void)
>   { 
>     DoSomething( sizeof(T) );
>     //           ^^^^^^^^^
>   }
>   // etc...
>};
>
>This will compile file with any type 'T' except "void".  Does the new
>draft allow this to be defined as long as I don't call "Bar()" on anything
>of type "Foo<void>"?

I believe that if you never invoke or take the address of Foo<void>::Bar(),
and if Bar is not virtual, that the template should be valid. Some current
compilers might reject the code, but I believe it is allowed by the
draft standard. As I noted earlier, the draft standard says that template
functions that do not need to be generated must not be generated; the
compiler should thus never see the invalid use of sizeof.

>If so, is there any possible way to avoid "sizeof(void) is illegal" errors
>from current compilers?

Declare a specialization in the template header Foo.h:
	int Foo<void>::Bar();
The compiler should not attempt to generate Bar for Foo<void>.


>Along a similar vein...
>
>template<class T>
>class MyPtrClass {
>  T* ptr;
>public:
>   // etc...
>   T* operator->(void) { return(ptr); }
>   // etc...
>};
>
>
>This causes problems on some compilers (e.g. Borland C++ v4.5) if type
>'T' is does not have "operator->" defined, even if I never call the
>"operator->" defined above. 

I believe the template declaration is valid only when T is a class type.
Section 13.5.6 "Class Member Access" places requirements on the return type
of operator->. When the class template is processed, the declaration would be
invalid even if you never use the function.

Possibly someone could point out something in the draft which makes the
template valid as long is operator-> is never actually referenced.
---
Steve Clamage, stephen.clamage@eng.sun.com



[ 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. ]