on 04.05.2010 at 2:20 Chad Nelson wrote :
Hm... I *think* I see it now. At least, some of the time I think I do. :-) Please check my understanding: you're suggesting that I use functions in base_integer to do the allocation, and have them call other functions in base_integer to do the things that are different between fixed_integer and the variable-length integers. But then override those functions in the fixed_integer classes, not as virtual functions, but using CRTP to call the overridden functions. Am I right?
let me try to explain suppose the interface of all your concrete classes (i.e. 'integer', 'nothrow_integer' and 'fixed_integer') is homogeneous that is all classes have identical names for respective members with consistent semantics then each of the classes inherits the base class template<typename type> class base_integer {}; in the following way class integer : public base_integer<integer> {/*...*/}; then you can write template functions for all types in the following manner: template<typename int_type> void foo(const base_integer<int_type>&); template<typename type1, typename type2> void bar(const base_integer<type1>&, const base_integer<type2>&); such functions will handle all types derived from base_integer providing their type as template argument an implementation of such a function can be like this: template<typename type> type negate(const base_integer<type> &a) { const type &instance = *static_cast<type*>(&a); return instance.negated(); } notice that this function returns a concrete type deduced automatically also this function implies that all concrete types have 'negated()' member function (as an example) also the ugly static_cast may be wrapped in a functions: template<typename type> type &get_instance(base_integer<type> &a) { return *static_cast<type*>(&a); } template<typename type> const type &get_instance(const base_integer<type> &a) { return *static_cast<const type*>(&a); } designing a lib this way you have a header with those (CRTP'ed) template stuff while concrete types reside in header and/or cpp file as is convenient for you as well this approach is type safe as long as 'base_integer' parameterized according to the contract please think about it, it is a very powerful design technique, also it may solve a whole lot of troubles now and later i like this theme very much and will happily write more words on this on your demand -- Pavel P.S. if you notice a grammar mistake or weird phrasing in my message please point it out