- Boost-users - lists.preview.boost.org

Any use of a Singleton<> template
by sixfurdk 08 Feb '02

08 Feb '02

I currently working on a Singleton<> template, which currently has these features. 1) Supports the same interface/concepts as auto_ptr<> 2) One Line option to create a working singleton 3) Possible to use different Singletons of same type using names (simultaneously) 4) Possible to store different Singleton Objects under the same name (not simultaneously) 5) Possible to Release By Reference (Optional, Not Default) 6) Automatic Cleanup at program termination (Optional, Default) It can be used in the following manner: class SingletonObject { void someFunction(); ... }; Singleton<SingletonObject> singleton; singleton->someFunction(); Is there any interrest in such a class? Peter Sixhøj

2 2

tokenizer compilation problem with gcc 3.0.3 and stlport
by fintaeph 07 Feb '02

07 Feb '02

Hi all, I have been having trouble getting the tokenizer examples to compile using gcc 3.0.3 and stlport. I am using the example code from http://www.boost.org/libs/tokenizer/escaped_list_separator.htm, with the following compiler output: test.cpp: In instantiation of `::boost::::boost::iterator_ada ptor<::boost::detail::::boost::detail::token_iterator_base<co nst char *>,::boost::detail::::boost::detail::tokenizer_polic y<::_STL::::_STL::basic_string<char,::_STL::::_STL::char_trai ts<char>,::_STL::::_STL::allocator<char> >,::boost::::boost:: escaped_list_separator<char,::_STL::::_STL::char_traits<char> > >,::_STL::::_STL::basic_string<char,::_STL::::_STL::char_t raits<char>,::_STL::::_STL::allocator<char> >,const ::_STL::: :_STL::basic_string<char,::_STL::::_STL::char_traits<char>,:: _STL::::_STL::allocator<char> > &,const ::_STL::::_STL::basic _string<char,::_STL::::_STL::char_traits<char>,::_STL::::_STL ::allocator<char> > *,::_STL::forward_iterator_tag,int>': test.cpp:11: instantiated from here test.cpp:11: `sizeof' applied to incomplete type `::boost:::: boost::STATIC_ASSERTION_FAILURE<false>' If anyone has encountered and solved this problem before, I would greatly appreciate knowing what I'm doing wrong. Thanks, Chris. P.S. I get similar results with all the tokenizer examples.

3 3

modifed boost::stringtok
by hicks 06 Feb '02

06 Feb '02

Hello, I have created a modifed version of boost::stringtok() (the template function in boost\pending) with the aim of proving a more convient programmer interface. (It is called stringtok_2() below, but the interface is identical to stringtok()). The present version expects a container of objects which can be assigned a std::string. The modifed version is designed to accept a container of objects which can be converted to from std::string, at present "int" and "float" in addition to "std::string". E.g. char ac[] = "1 2 3 4 5"; std::vector<int> vi; boost::stringtok_2(vi,ac); std::vector<float> vf; boost::stringtok_2(vf,ac); std::vector<std::string> vs; boost::stringtok_2(vs,ac); As you can see in the cases for "int" and "float", the programmer can avoid having to create a vector of std::string and then convert them to int (or float) after calling stringtok. The implementation is achieved through template specialization. Behind the interface is an overloaded stringtok_2, template<typename Container, class Cvt> stringtok_2(Container l, Cvt cvt, const std::string s, const std::string ws) which takes a functor argument cvt which does the string to type conversion. The hithertoe used interface template<typename Container> stringtok_2(Container l, const std::string s, const std::string ws) calls the overloaded stringtok_2 with a converting functor string_cvt_ftr<Container::value_type>. string_cvt_ftr has a default declaration and two specializations, one for "int" and one for "float". template <class T> struct string_cvt_ftr { T operator()(const std::string& s) { return s; } }; template <> struct string_cvt_ftr<int> { int operator()(const std::string& s) { return std::atoi(s.c_str()); } }; template <> struct string_cvt_ftr<float> { float operator()(const std::string& s) { return std::atof(s.c_str()); } }; That is the partial specialization. Note that a vector of std::string can still be passed as the container argument. Since the interface semantics of are a superset of boost::stringtok(), I wonder if this could be substituted as a version-up, and use the same name. However, judging from the mail I see on this list, it is possible that some compilers might not handle it, so maybe that wouldn't be a good idea. I am sending this to boost-users since I do not currently recieve plain boost mail. I include the full code (including test code) below. Craig Hicks Engineer, KGK Tokyo //////////////////////////////////////////////////////////////////// // stringtok_2.h //--------------------------------------------------------------------------- #ifndef stringtok_2H #define stringtok_2H //--------------------------------------------------------------------------- #include <string> #include <cstring> // for strchr /***************************************************************** // modified with partial template specialization for int, float containers 2002.2.6 // Craig Hicks /***************************************************************** * This is the only part of the implementation that I don't like. * It can probably be improved upon by the reader... */ namespace stringtok_2_ns { inline bool isws (char c, char const * const wstr) { using namespace std; return (strchr(wstr,c) != NULL); } } namespace boost { /***************************************************************** * Simplistic and quite Standard, but a bit slow. This should be * templatized on basic_string instead, or on a more generic StringT * that just happens to support ::size_type, .substr(), and so on. * I had hoped that "whitespace" would be a trait, but it isn't, so * the user must supply it. Enh, this lets them break up strings on * different things easier than traits would anyhow. */ template <typename Container, typename Cvt> void stringtok_2 ( Container &l, Cvt cvt, std::string const &s, char const * const ws = " \t\n" ) { using namespace stringtok_2_ns; typedef std::string::size_type size_type; const size_type S = s.size(); size_type i = 0; while (i < S) { // eat leading whitespace while ((i < S) && (isws(s[i],ws))) ++i; if (i == S) return; // nothing left but WS // find end of word size_type j = i+1; while ((j < S) && (!isws(s[j],ws))) ++j; // add word l.push_back(cvt(s.substr(i,j-i))); // set up for next loop i = j+1; } } template <class T> struct string_cvt_ftr { T operator()(const std::string& s) { return s; } }; template <> struct string_cvt_ftr<int> { int operator()(const std::string& s) { return std::atoi(s.c_str()); } }; template <> struct string_cvt_ftr<float> { float operator()(const std::string& s) { return std::atof(s.c_str()); } }; template <typename Container> void stringtok_2 ( Container &l, std::string const &s, char const * const ws = " \t\n" ) { string_cvt_ftr<Container::value_type> cvt; stringtok_2(l, cvt, s, ws); } } // namespace boost #endif /////////////////////////////////////////////////////////////////// // test code void test_stringtok_2(std::ostream& os) /* Expected output:: int 1, 2, 3, 4, 5, float 1, 2, 3, 4, 5, string 1, 2, 3, 4, 5, */ { char ac[] = "1 2 3 4 5"; os << "int" << std::endl; std::vector<int> vi; boost::stringtok_2(vi,ac); std::copy(vi.begin(), vi.end(), std::ostream_iterator<int,char>(os,", ")); os << std::endl; os << "float" << std::endl; std::vector<float> vf; boost::stringtok_2(vf,ac); std::copy(vf.begin(), vf.end(), std::ostream_iterator<float,char>(os,", ")); os << std::endl; os << "string" << std::endl; std::vector<std::string> vs; boost::stringtok_2(vs,ac); std::copy(vs.begin(), vs.end(), std::ostream_iterator<std::string,char>(os,", ")); os << std::endl; }

2 2

Tokenizer question
by Edward Diener 06 Feb '02

06 Feb '02

Two tokenizer questions 1) I do not understand the constructor parameters to the char_delimits_separator class which is the default TokenizerFunction model. I assume the constructor would enable one to specify the delimiters for each token. I assume that the "returnable" parameter is a string literal of delimiters which are also returned as tokens and that "nonreturnable" is a string literal of delimiters which are not returned as tokens. I assume that the intersection of these string literals consists of all the delimiters. Given these assumptions, what is the purpose of the bool "return_delims" first parameter ? If "returnable" specifies a non-empty string literal, then why shouldn't these be the delimiters returned as tokens irregardless of the setting of "return_delims". If "returnable" specifies an empty string literal, then no delimiters will be returned as tokens once again irregardless of the setting of "return_delims". Would someone please explain why "return_delims" exists as a parameter in conjunction with the meaning of the "returnable" parameter ? It seems utterly redundant and unnecessary. 2) How does one create one own's TokenizerFunction to be plugged into the tokenizer class template as the first template type ? The documentation on TokenizerFunction concept leaves me utterly confused on a practical level. I assume I am creating a template class here despite the name which suggests it is a function, but the documentation never explains what it is. Maybe someone from Boost or John Bandela should consider updating it.

2 2

Another Tokenizer question
by s1imshady86 06 Feb '02

06 Feb '02

How do you specify that a white space is a returnable delimiter? The obvious, char_delimiters_separator<char> func (true, " "); Doesnt work. I know it's rather newbish question, but please help. A little more documentaion on token_iterator and TokenizerFunction concept (and perhaps the three specialized ones) would help greatly! Thanks, Ray

1 0

[Fwd: Re: [Boost-Users] Four Questions on boost::shared_ptr]
by hicks 05 Feb '02

05 Feb '02

-------- Original Message -------- Subject: Re: [Boost-Users] Four Questions on boost::shared_ptr Date: Tue, 05 Feb 2002 10:08:25 +0900 From: hicks <hicks(a)kgk.co.jp> To: Boost-Users(a)yahoogroups.com, Duane Murphy <duanemurphy(a)mac.com> References: <B8838630.133F2%darin(a)bentspoon.com> <20020204170343.12718(a)mail.murphyslogic.com> Hi >>You should normally use std::vector unless you have some special reason to >>use boost:: scoped_array and boost::shared_array. Those classes are provided >>both for completeness, and because occasionally there are such special >>reasons. But not often. > >I consider user vector<> often. However there is a cost. For a fixed size >allocation of a buffer there is only the data allocated. If you use a >vector<> the vector also includes (for most implementations) the current >capacity, the current size, and the allocator. There is another sometimes very big overhead incurred by std::vector, and not incurred by by new T[]/ delete[]. Most implementions of std::vector will enter a loop and call a destructor on each element of the array, even if there is no machine code associated with that destructor. At least Borlands implemention of delete[] automatically detects this condition and does not insert a loop to call the destructors. This could be avoided if std::vector used a traits type to determine whether to enter a loop calling destructors. Craig Hicks KGK Tokyo Duane Murphy wrote: >--- At Mon, 4 Feb 2002 00:28:32 -0800, Darin Adler wrote: > >>On 2/3/02 11:54 PM, "Jon Wang" <webmaster(a)boost.100ok.com> <mailto:webmaster@boost.100ok.com> wrote: >> >>>1. Mr Stroustrup said that there wasn't a need for auto_array, for "a >>> >better > >>>solution is to use a vector". So, should we use vector or >>>scoped_array/shared_array? >>> >>You should normally use std::vector unless you have some special reason to >>use boost:: scoped_array and boost::shared_array. Those classes are provided >>both for completeness, and because occasionally there are such special >>reasons. But not often. >> > >I consider user vector<> often. However there is a cost. For a fixed size >allocation of a buffer there is only the data allocated. If you use a >vector<> the vector also includes (for most implementations) the current >capacity, the current size, and the allocator. > >I would be interested in finding a class that is somewhere between >allocating my own buffers and vector<>. Low overhead for simple >allocations; no resizing or growing. Even in this case, in order to >support iterator semantics the size is going to be needed. > >Sigh. > >I suppose a case like this might be when scoped_array would be used? > > ...Duane > > > > >Info: <http://www.boost.org> >Wiki: <http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl> >Unsubscribe: <mailto:boost-users-unsubscribe@yahoogroups.com> > > >Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/ > > > > >

1 0

Re: [Boost-Users] Four Questions on boost::shared_ptr
by Darin Adler 05 Feb '02

05 Feb '02

On 2/3/02 11:54 PM, "Jon Wang" <webmaster(a)boost.100ok.com> wrote: > 1. Mr Stroustrup said that there wasn't a need for auto_array, for "a better > solution is to use a vector". So, should we use vector or > scoped_array/shared_array? You should normally use std::vector unless you have some special reason to use boost:: scoped_array and boost::shared_array. Those classes are provided both for completeness, and because occasionally there are such special reasons. But not often. > 2. In the document, four implementations are said to have been discussed: > Direct detached, Indirect detached, Embedded detached and Placement detached. > I've tried to describle them (Are I right? See the attached file), but I don't > understand the Placement detached. Could someone please tell me what it's > like? The concept here is that the object is allocated in a special way, which require use of placement, so the count is in a header before the object. This is a form of the "embedded attached" scheme that does not require changes to the original object's class, but it does require a special form of new, so you couldn't just call the normal "new" and then give the object to such a smart pointer. [Note: There was no attached file.] > 3. In the file smart_ptr.hpp, we can see the private function > shared_ptr::share. > > I'm sorry that I don't understand that reason why ++*rpn should be done before > dispose(). Would someone please give me an example? Or is it like this? This function is gone from the latest implementation of shared_ptr slated for the next boost release, so it's probably not worthwhile to discuss this particular aspect of the old implementation in detail. The code you enclosed looks something like the kind of code that caused trouble -- the key is that deleting the old object pointed to can end up deleting the new shared pointer in some cases, and this must not happen before incrementing the reference count. The new implementation avoids this issue by using the well-known "copy and swap" idiom for implementing assignment, and is easier to understand. > 4. Why not use policies? I'm afraid that the word "parameterization will > discourage users" might not be always true, for we can use default parameters. We'll probably be using policies in future version, if we can work out all the issues. Andrei Alexandrescu is considering submitting his smart pointer class template from his Loki library to Boost for formal review, which is the most likely candidate for a Boost policy-based smart pointer. If it turns out well enough, it may replace all the existing smart pointer class templates. -- Darin

3 3

Re: [Boost-Users] Four Questions on boost::shared_ptr
by Jon Wang 04 Feb '02

04 Feb '02

>[Note: There was no attached file.] Oh, sorry! Here is the attached code. Am I right? Thanks very much. But still I haven't understand placement attached:-) #ifndef COUNTED_PTR_HPP #define COUNTED_PTR_HPP #include <cstring> #include <boost/config.hpp> // counted_ptr --------------------------------------------------------------// template <typename T> class RefLinking { protected: RefLinking(T* p) { init(p); } ~RefLinking() { dispose(); } template<typename Y> RefLinking(const RefLinking<Y>& r) { insert(&r); } // never throws RefLinking(const RefLinking& r) { insert(&r); } // never throws public: template<typename Y> void operator=(const RefLinking<Y>& r) { share(&r); } void operator=(const RefLinking& r) { share(&r); } void reset(T* p=0) { if ( px == p ) return; // fix: self-assignment safe dispose(); init(p); } // reset T* get() const { return px; } // never throws long use_count() const { long i = 0; const RefLinking* p = prev; while(p){ p = p->prev; ++i; } p = this; while(p){ p = p->next; ++i; } return i; } // never throws #if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) private: #endif T* px; RefLinking *prev, *next; // Don't split this line into two; that causes problems for some GCC 2.95.2 builds #if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) template<typename Y> friend class RefLinking; #endif void init(T* p) { px = p; prev = 0; next = 0; } void dispose() { if(prev) prev->next = next; else if(next) next->prev = prev; else delete px; } template <class Y> void insert(Y* rr) { RefLinking* r = (RefLinking*)rr; px = r->px; prev = (r); next = r->next; r->next = this; if(next) next->prev = this; } template <class Y> void share(Y* r) { if ((void*)this != (void*)r) { dispose(); insert(r); } } // share }; //*/ template <typename T> class EmbeddedAttached { protected: EmbeddedAttached(T* p) { init(p); } ~EmbeddedAttached() { dispose(); } template<typename Y> EmbeddedAttached(const EmbeddedAttached<Y>& r) : ptr(r.ptr) { // never throws if(ptr) ++(ptr->pn); } EmbeddedAttached(const EmbeddedAttached& r) : ptr(r.ptr) { if(ptr) ++(ptr->pn); } // never throws public: template<typename Y> void operator=(const EmbeddedAttached<Y>& r) { share(r.ptr); } void operator=(const EmbeddedAttached& r) { share(r.ptr); } void reset(T* p=0) { if ( ptr == p ) return; // fix: self-assignment safe dispose(); init(p); } // reset T* get() const { return ptr; } // never throws long use_count() const { return (ptr)? ptr->pn: 0; } // never throws #if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) private: #endif T* ptr; // Don't split this line into two; that causes problems for some GCC 2.95.2 builds #if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) template<typename Y> friend class EmbeddedAttached; #endif void init(T* p) { ptr = p; if(ptr) ++(ptr->pn); } void dispose() { if(ptr&&--(ptr->pn)== 0) delete ptr; } void share(T* r) { if (ptr != r && r) { // Q: why not px != rpx? A: fails when both == 0 ++(r->pn); // done before dispose() in case rpn transitively // dependent on *this (bug reported by Ken Johnson) dispose(); ptr = r; } } // share }; template <typename T> class IndirectDetached { protected: IndirectDetached(T* p) { init(p); } ~IndirectDetached() { dispose(); } template<typename Y> IndirectDetached(const IndirectDetached<Y>& r) : ptr(r.ptr) { // never throws ++(ptr->pn); } IndirectDetached(const IndirectDetached& r) : ptr(r.ptr) { ++(ptr->pn); } // never throws public: template<typename Y> void operator=(const IndirectDetached<Y>& r) { share(r.ptr); } void operator=(const IndirectDetached& r) { share(r.ptr); } void reset(T* p=0) { if ( ptr->px == p ) return; // fix: self-assignment safe dispose(); init(p); } // reset T* get() const { return ptr->px; } // never throws long use_count() const { return ptr->pn; } // never throws #if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) private: #endif struct IDHelper{ T* px; long pn; IDHelper(T* p): px(p), pn(1) {} ~IDHelper() { delete px; } }; IDHelper* ptr; // Don't split this line into two; that causes problems for some GCC 2.95.2 builds #if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) template<typename Y> friend class IndirectDetached; #endif void init(T* p) { try { ptr = new IDHelper(p); } catch (...) { delete p; throw; } } void dispose() { if(--(ptr->pn) == 0) delete ptr; } template <class Y> void share(IDHelper* r) { if ((void*)ptr != (void*)r) { // Q: why not px != rpx? A: fails when both == 0 ++(r->pn); // done before dispose() in case rpn transitively // dependent on *this (bug reported by Ken Johnson) dispose(); ptr = r; } } // share }; //*/ template <typename T> class DirectDetached { protected: DirectDetached(T* p) : px(p) { try { pn = new long(1); } catch (...) { delete p; throw; } } ~DirectDetached() { dispose(); } template<typename Y> DirectDetached(const DirectDetached<Y>& r) : px(r.px) { // never throws ++*(pn = r.pn); } DirectDetached(const DirectDetached& r) : px(r.px) { ++*(pn = r.pn); } // never throws public: template<typename Y> void operator=(const DirectDetached<Y>& r) { share(r.px, r.pn); } void operator=(const DirectDetached& r) { share(r.px, r.pn); } void reset(T* p=0) { if ( px == p ) return; // fix: self-assignment safe if (--*pn == 0) { delete px; } else { // allocate new reference counter try { pn = new long; } // fix: prevent leak if new throws catch (...) { ++*pn; // undo effect of --*pn above to meet effects guarantee delete p; throw; } // catch } // allocate new reference counter *pn = 1; px = p; } // reset T* get() const { return px; } // never throws long use_count() const { return *pn; } // never throws // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. (Matthew Langston) // Don't split this line into two; that causes problems for some GCC 2.95.2 builds #if ( defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) ) || !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) private: #endif T* px; // contained pointer long* pn; // ptr to reference counter // Don't split this line into two; that causes problems for some GCC 2.95.2 builds #if !defined( BOOST_NO_MEMBER_TEMPLATES ) && !defined( BOOST_NO_MEMBER_TEMPLATE_FRIENDS ) template<typename Y> friend class DirectDetached; #endif void dispose() { if (--*pn == 0) { delete px; delete pn; } } void share(T* rpx, long* rpn) { if (pn != rpn) { // Q: why not px != rpx? A: fails when both == 0 ++*rpn; // done before dispose() in case rpn transitively // dependent on *this (bug reported by Ken Johnson) dispose(); px = rpx; pn = rpn; } } // share }; template<typename T, class Storage = DirectDetached<T> > class counted_ptr: public Storage { public: typedef T element_type; explicit counted_ptr(T* p = 0) : Storage(p) {} template<typename Y, typename S> counted_ptr(const counted_ptr<Y, S>& r) : Storage(r) {} // never throws template<typename Y, typename S> counted_ptr& operator=(const counted_ptr<Y, S>& r) { *static_cast<Storage*>(this) = static_cast<const S&>(r); return *this; } counted_ptr(const counted_ptr& r) : Storage(r) {} // never throws counted_ptr& operator=(const counted_ptr& r) { *static_cast<Storage*>(this) = static_cast<const Storage&>(r); return *this; } T& operator*() const { return *get(); } // never throws T* operator->() const { return get(); } // never throws bool unique() const { return use_count() == 1; } // never throws void swap(counted_ptr& other) // never throws { using std::memcpy; const int size = sizeof(counted_ptr); char temp[size]; memcpy(temp, &other, size); memcpy(&other, this, size); memcpy(this, temp, size); } }; // counted_ptr #endif // COUNTED_PTR_HPP Jon Wang 2002-02-04

1 0

Re: [Boost-Users] Four Questions on boost::shared_ptr
by Darin Adler 04 Feb '02

04 Feb '02

On 2/4/02 12:51 AM, "Jon Wang" <webmaster(a)boost.100ok.com> wrote: > [Non-text portions of this message have been removed] I should have been more clear. This list doesn't allow attached files. -- Darin

1 0

Re: [Boost-Users] Four Questions on boost::shared_ptr
by Jon Wang 04 Feb '02

04 Feb '02

>[Note: There was no attached file.] Oh, sorry! Here is the attached file. Am I right? Jon Wang 2002-02-04 [Non-text portions of this message have been removed]

1 0