🚀 go-pugleaf

howlett@netcom.com (Scott Howlett) writes:
	...
>> template <class T> inline bool can_memmove(const T&) { return false; }
>> inline bool can_memmove(const int&) { return true; } // etc

>Perhaps this would be better as something like the following:

>template<class T> class type_traits {
>    enum { can_memmove = true };
>};

>class type_traits<foo> {
>    enum { can_memmove = false };
>};

>That way you get the answer to can_memmove at compile time. Not only
>does this save you code (both time and space) but it allows you to

I would be surprised to find myself using a compiler unable to
optimize away an inline function call returning a manifest constant...
it is however true that the idiom you propose seems to have no
offseting defect.

>do things which require compile-time constants, such as using
>type_traits<T>::can_memmove as a parameter to some other template.

Conceded, and this makes the idiom you suggest appear to be quite
preferable, thanks.


Alex
--
DISCLAIMER: these are TOTALLY personal opinions and viewpoints, NOT connected
in any way with my employer, nor any other organization or individual!
Email: martelli@cadlab.it                            Phone: +39 (51) 597313
CAD.LAB s.p.a., v. Ronzani 7/29, Casalecchio, Italia   Fax: +39 (51) 597120
---
[ 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. ]