traits and policies

From:

Abhishek Padmanabh <abhishek.padmanabh@gmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Wed, 1 Aug 2007 07:21:11 CST

Message-ID:

<1185955742.064371.262950@m37g2000prh.googlegroups.com>

Hi,

Can I request suggestions/clarifications if my below understandings
are correct around policies and traits?

1. Policies are compile time variants of strategies as in Strategy
pattern.

2. The allocator template parameter to STL classes could be said as an
allocation policy - the default being std::allocator<T>.

3. Considering std::char_traits, they have a few typedefs and also
have functions that tell about how to compare, assign, find length,
etc. These "add" to the definition of the type in the context (context
meaning whatever char_traits is passed to make a string type out of
basic_string). char_traits looks to include policies. It provides
policies to compare, assign and find length. A basic_string of
character type "char" can have a different definitions of (or ways to
do) comparison. I can provide a specialization or a traits class of my
own where I change the compare to be case insensitive. This seems like
a policy because they are two different ways to achieve the same
objective/to fulfil a requirement/to expose a functionality/to define
the working in a specific context. I can define that compare function
as a policy like : "A compare policy that must expose a Compare member
function, callable with 2 char_type* types and a size_t argument
signifying number of elements to compare and returns a boolean
result". Am I right in concluding these two things about
std::char_traits?

4. The typedefs in std::char_traits can be considered as traits. Same
for typedefs in vector class like value_type.

5. std::numeric_limits - that can be said to be a traits (or a
collection of traits). They tell about what max() for a type is, what
epsilon() for a type is. They are not policies. They don't achieve
some behaviour but they may represent how types should/may behave or
properties they have.

6. I cannot specialize traits.

7. I can specialize policies.

8. Type traits are compile time variants of RTTI.

9. basic_string template would have been better defined as considering
(3) above:
    template< class CharT, template <class> CharTPolicyCollection,
template <class> AllocationPolicy>
        class basic_string : public CharTPolicyCollection<CharT>,
public AllocationPolicy<CharT>
    {
        //members
    };

10. The above uses public inheritance (MI). Is this correct modelling
considering public inheritance always means "Is-A"? Does the IS-A
relationship make sense here? (even if CharTPolicyCollection and
AllocationPolicy have protected destructor)

Thanks in advance for your inputs.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]