Boost logo

Boost :

From: Dan McLeran (dan.mcleran_at_[hidden])
Date: 2005-09-23 09:43:43

I was thinking of exactly this kind of thing last night.One should be able
to tell whether or not compile-time calculations are allowed based on
template parameter T.

"Simon Buchan" <simon_at_[hidden]> wrote in message
> Dan McLeran wrote:
>>>let's finally do it - C++ lacks bounded types and it's high time to fix
>>>that! ;-)
>> I agree. I had been programming in C++ for a number of years before I was
>> introduced to Ada. I loved the strict typing one can do in Ada and I
>> would
>> like to have at least some of these facilities in C++ as well (since that
>> is
>> what I use every day). I will certainly check out what you've posted
>> (bounded types). One thing to keep in mind as we move forward with this
>> is
>> that, IMO, we need to support as much compile-time computation as much as
>> possible. One thing I am struggling with is how to support both bounded
>> floating-point types, but as the same time, have a bounded types template
>> be
>> able to be used from boost::mpl for compile-time computation.
>> Regards,
>> Dan McLeran
>> _______________________________________________
>> Unsubscribe & other changes:
> AFAIK, no compiler actually supports compile-time floating-point
> compilation, since there is no general guarantee that the same
> architecture would be running the program (think cross-compiles), and
> almost every floating-point operation is "implementation-defined",
> basicly, could do anything at all.
> Say: PPC has 128-bit long doubles, x86 only has 80-bits, but x86
> internally always uses long doubles for calculations, even with 32-bit
> floats, and therefore gives different results than the PPC. I can't
> remember if those statements are accurate, but something like that goes
> on.
> You could try a factory function taking constant T's, hoping the
> compiler can constant-propagate through function calls (since it would
> be inline, it should be able to), and overload that for integral
> expressions? (enable_if<> should be useful here) ie:
> template <typename T>
> class bounded_t
> { // just a boring run-time checked version
> }
> template <int min, int max>
> class bounded_t<int>// and char, (un)signed char, wchar_t, etc...
> { // fancy compile-time version
> }
> template <typename T>
> bounded_t<T> bounded(const T& t, const T& min, const T& max, int dummy =
> disable_if<mpl::is_integral<T>, int>)
> { return bounded<T>(t, min, max);
> }
> template <typename T>
> bounded_t<T, int, int> bounded(const T& t, const T min, const T max, int
> dummy = enable_if<mpl::is_integral<T>, int>)
> { return bounded_t<T, min, max>(t);
> }
> BTW, I have NO idea whether anything like that would ever work, on any
> far-out plane of the universe. You have been warned.
> _______________________________________________
> Unsubscribe & other changes:

Boost list run by bdawes at, gregod at, cpdaniel at, john at