Boost logo

Boost :

From: Reece Dunn (msclrhd_at_[hidden])
Date: 2004-05-19 05:51:58

Pavel Vozenilek wrote:
>"Max Khesin" <MKhesin_at_[hidden]> wrote:
> > Just curious:
> > what do you think of Andrei's work on policy-based strings:
> >
> >

I have only previously come across it in passing and have not had a chance
to take a look at it. I am studying it at the moment: a very good library!

> > - does it do what you want (or leave flexibility to do what you want)
> > - if so why not just use it
> > - if not what doesn't it do

>From what I understand thus far, usage would be like this:

   boost::flex_string< char, std::char_traits< char >, std::allocator< char
>, VectorStringPolicy< char > > vecstr;

which is too weildy. It would be possible to use the template typedef
concept to have something like:
   template< typename CharT, template< typename C, class A > class Storage,
class Traits, class AllocT >
   struct cust_string
      typedef boost::flex_string< CharT, Traits, AllocT, Storage< CharT,
AllocT > > type;

   cust_string< char, VectorStringPolicy >::type vecstr;

If you want a special string type, you will need to do something like this:

   template< typename CharT, class A = std::allocator< CharT > >
   class MyCustStorage{ ... };

   template< typename CharT, class Traits >
   class mybasic_string: public boost::flex_string< CharT, Traits,
std::allocator< CharT >, Storage< CharT > >
          // ...

Where you are essentially having to write more code. What I am ideally
looking for is something similar to what the iterator adaptors do, allowing:

   template< typename CharT, class Traits >
   class mybasic_string: public boost::string_adaptor< mybasic_string,
CharT, Traits >
         const CharT * c_str(){ ... }
         // ...
         // ...

Another minor point is that the policy classes do not meet the
standard/Boost naming convention.

Also: what if you want to use a different string type for substrings than
the type being used? As an example, I have a fixed-capacity string
fixed_string< n, CharT > that is equivalent to CharT[ n ], and guards
against buffer overflow on the string operations (as a safe replacement for
the equivalent C operations).

In order to write code generically on them without using template code, I
have an abstract class:

   class char_string
         virtual const char * c_str() = 0;
         virtual size_t length() = 0;
         // ...

   template< size_t n, typename CharT = char, ... >
   class fixed_string: public char_string // note: MPL code to select char
or wchar_t version
      CharT str[ n ];
      size_t len;
         inline const CharT * c_str(){ return( str ); }
         inline size_t length(){ return( len ); }
         // ...

   inline void printme( const char_string & s )
      std::cout << s.c_str();

With this, you can't use char_string as a standard type (it needs to be a
reference or pointer) because you'd get an error about instantiating an
abstract base class.

>Just remark: Andrei's flex_string is already included in Wave, (future)
>Boost library.



Get a FREE connection, FREE modem and one month's FREE line rental, plus a
US or European flight when you sign up for BT Broadband!

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