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

Re: Using graph library in VC++ 6.0 -> Change stl library?
by rohou 15 Dec '03

15 Dec '03

Using Boost graph library in VC++ 6.0, do I have to change the stl dlivered with VC6.0? What is the service pack I should use? Thanks, Boris

1 0

Boost::shared_ptr and memory leaks
by INsideR 15 Dec '03

15 Dec '03

Hello, I have wrote simple programm: using namespace boost; shared_ptr<int> a(new int(10)); shared_ptr<int> b; b=a; a.reset(new int(20)); std::cout<<"a=="<<*a<<" b=="<<*b; return 0; Checking this programm with DevPartner BoundsChecker, i found memory leak: Type Quantity Total (bytes) Allocation Location Sequence Leak exiting program 1 84 setlocale - [setlocal.c, line 547 (Boostt.exe)] 9 Memory Leak Exiting Program: Address 0x00E44F88 (84) allocated by _malloc_dbg. <if ( (ptloci = _malloc_crt( sizeof(threadlocinfo) )) == NULL )> Where is the problem? May be i write incorrect code? Best Wishes, Yury mailto:insider83@inbox.lv

2 1

problem with shared_ptr
by Eyal Fink 14 Dec '03

14 Dec '03

I am using boost share_ptr and I have a very strange problem. it looks to me more like a compiler problem but since it is a boost code I decided to post it here. I haven't succeeded to creating a small example which I can post here and demonstrate the problem (I know it is hard to help that way but I am working on creating an example) so I will just describe it. The symptom is that the shared_ptr call the delete on a random pointer. Going into the shared_ptr and shared_count objects, I sow that the ptr field of sp_counted_base_impl has a wrong value. I have added prints out all over the code and saw that inside the constructor of sp_counted_base_impl the value is set correctly but on the return when I try to look at the value and it is a wrong value. adding some more prints I saw that inside the shared_count constructor: template<class P, class D> shared_count(P p, D d) when casting pi_ to (sp_counted_base_impl<P, D>*) and calling a member function, the sizeof(*this) in side the member function is not the same every time (resulting with a different address to ptr and thus different value). the problem occurs only when compiling -O I am attaching the two file I have changes (shared_count.hpp is from boost/detail/) and the prints there created. I am sorry I can't supplied a complete example, this problems can just disappear when I remove any object file from the compilation. my configuration: compiler: gcc version 3.2 20020903 (Red Hat Linux 8.0 3.2-7) OS: Red Hat Linux release 8.0 (Psyche) boost: boost-1.30.2 any help will be appreciated #ifndef BOOST_SHARED_PTR_HPP_INCLUDED #define BOOST_SHARED_PTR_HPP_INCLUDED // // shared_ptr.hpp // // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002, 2003 Peter Dimov // // Permission to copy, use, modify, sell and distribute this software // is granted provided this copyright notice appears in all copies. // This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. // #include <boost/config.hpp> // for broken compiler workarounds #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #include <boost/detail/shared_ptr_nmt.hpp> #else #include <boost/assert.hpp> #include <boost/checked_delete.hpp> #include <boost/throw_exception.hpp> #include <boost/detail/shared_count.hpp> #include <boost/detail/workaround.hpp> #include <memory> // for std::auto_ptr #include <algorithm> // for std::swap #include <functional> // for std::less #include <typeinfo> // for std::bad_cast #include <iosfwd> // for std::basic_ostream #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash # pragma warning(push) # pragma warning(disable:4284) // odd return type for operator-> #endif namespace boost { template<class T> class weak_ptr; template<class T> class enable_shared_from_this; namespace detail { struct static_cast_tag {}; struct dynamic_cast_tag {}; struct polymorphic_cast_tag {}; template<class T> struct shared_ptr_traits { typedef T & reference; }; template<> struct shared_ptr_traits<void> { typedef void reference; }; #if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) template<> struct shared_ptr_traits<void const> { typedef void reference; }; #endif // enable_shared_from_this support template<class T, class Y> void sp_enable_shared_from_this(boost::enable_shared_from_this<T> * pe, Y * px, shared_count const & pn) { if(pe != 0) pe->_internal_weak_this._internal_assign(px, pn); } inline void sp_enable_shared_from_this(void const *, void const *, shared_count const &) { } } // namespace detail // // shared_ptr // // An enhanced relative of scoped_ptr with reference counted copy semantics. // The object pointed to is deleted when the last shared_ptr pointing to it // is destroyed or reset. // template<class T> class shared_ptr { private: // Borland 5.5.1 specific workaround typedef shared_ptr<T> this_type; public: typedef T element_type; typedef T value_type; typedef T * pointer; typedef typename detail::shared_ptr_traits<T>::reference reference; shared_ptr(): px(0), pn() // never throws in 1.30+ { } template<class Y> explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete // Eyal Fink changed that!!! //shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete { print_ptrs(); detail::sp_enable_shared_from_this(p, p, pn); print_ptrs(); } void print_ptrs() { //cout <<"px= "<<px<<" ptr= "<< pn.get_ptr(p, checked_deleter<Y>())<<endl; } // ~shared_ptr() // { // print_ptrs(); // } // // Requirements: D's copy constructor must not throw // // shared_ptr will release p by calling d(p) // template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d) { detail::sp_enable_shared_from_this(p, p, pn); } // generated copy constructor, assignment, destructor are fine... // except that Borland C++ has a bug, and g++ with -Wsynth warns #if defined(__BORLANDC__) || defined(__GNUC__) shared_ptr & operator=(shared_ptr const & r) // never throws { px = r.px; pn = r.pn; // shared_count::op= doesn't throw return *this; } #endif template<class Y> explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw { // it is now safe to copy r.px, as pn(r.pn) did not throw px = r.px; } template<class Y> shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws { } template<class Y> shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn) { } template<class Y> shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn) { if(px == 0) // need to allocate new counter -- the cast failed { pn = detail::shared_count(); } } template<class Y> shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn) { if(px == 0) { boost::throw_exception(std::bad_cast()); } } #ifndef BOOST_NO_AUTO_PTR template<class Y> explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn() { Y * tmp = r.get(); pn = detail::shared_count(r); detail::sp_enable_shared_from_this(tmp, tmp, pn); } #endif #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200) template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r) // never throws { px = r.px; pn = r.pn; // shared_count::op= doesn't throw return *this; } #endif #ifndef BOOST_NO_AUTO_PTR template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r) { this_type(r).swap(*this); return *this; } #endif void reset() // never throws in 1.30+ { this_type().swap(*this); } template<class Y> void reset(Y * p) // Y must be complete { BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors this_type(p).swap(*this); } template<class Y, class D> void reset(Y * p, D d) { this_type(p, d).swap(*this); } reference operator* () const // never throws { BOOST_ASSERT(px != 0); return *px; } T * operator-> () const // never throws { BOOST_ASSERT(px != 0); return px; } T * get() const // never throws { return px; } // implicit conversion to "bool" #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return px != 0; } #else typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return px == 0? 0: &this_type::get; } #endif // operator! is redundant, but some compilers need it bool operator! () const // never throws { return px == 0; } bool unique() const // never throws { return pn.unique(); } long use_count() const // never throws { return pn.use_count(); } void swap(shared_ptr<T> & other) // never throws { std::swap(px, other.px); pn.swap(other.pn); } template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const { return pn < rhs.pn; } void * _internal_get_deleter(std::type_info const & ti) const { return pn.get_deleter(ti); } // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. (Matthew Langston) #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: template<class Y> friend class shared_ptr; template<class Y> friend class weak_ptr; #endif T * px; // contained pointer detail::shared_count pn; // reference counter }; // shared_ptr template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr const & b) { return a.get() == b.get(); } template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr const & b) { return a.get() != b.get(); } #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 // Resolve the ambiguity between our op!= and the one in rel_ops template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) { return a.get() != b.get(); } #endif template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr const & b) { return a._internal_less(b); } template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) { a.swap(b); } template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr const & r) { return shared_ptr<T>(r, detail::static_cast_tag()); } template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr const & r) { return shared_ptr<T>(r, detail::dynamic_cast_tag()); } // shared_*_cast names are deprecated. Use *_pointer_cast instead. template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr const & r) { return shared_ptr<T>(r, detail::static_cast_tag()); } template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr const & r) { return shared_ptr<T>(r, detail::dynamic_cast_tag()); } template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr const & r) { return shared_ptr<T>(r, detail::polymorphic_cast_tag()); } template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr const & r) { BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get()); return shared_static_cast<T>(r); } // get_pointer() enables boost::mem_fn to recognize shared_ptr template<class T> inline T * get_pointer(shared_ptr<T> const & p) { return p.get(); } // operator<< #if defined(__GNUC__) && (__GNUC__ < 3) template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p) { os << p.get(); return os; } #else # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL using std::basic_ostream; template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p) # else template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p) # endif { os << p.get(); return os; } #endif // get_deleter (experimental) #if defined(__GNUC__) && (__GNUC__ < 3) // g++ 2.9x doesn't allow static_cast<X const *>(void *) template<class D, class T> D * get_deleter(shared_ptr<T> const & p) { void const * q = p._internal_get_deleter(typeid(D)); return const_cast<D *>(static_cast<D const *>(q)); } #else template<class D, class T> D * get_deleter(shared_ptr<T> const & p) { return static_cast<D *>(p._internal_get_deleter(typeid(D))); } #endif } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED #define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // detail/shared_count.hpp // // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. // // Permission to copy, use, modify, sell and distribute this software // is granted provided this copyright notice appears in all copies. // This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // #include <boost/config.hpp> #if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR) # error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible. #endif #include <boost/checked_delete.hpp> #include <boost/throw_exception.hpp> #include <boost/detail/lightweight_mutex.hpp> #if defined(BOOST_SP_USE_QUICK_ALLOCATOR) #include <boost/detail/quick_allocator.hpp> #endif #include <memory> // std::auto_ptr, std::allocator #include <functional> // std::less #include <exception> // std::exception #include <new> // std::bad_alloc #include <typeinfo> // std::type_info in get_deleter #include <cstddef> // std::size_t #ifdef __BORLANDC__ # pragma warn -8026 // Functions with excep. spec. are not expanded inline # pragma warn -8027 // Functions containing try are not expanded inline #endif namespace boost { // Debug hooks #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn); void sp_array_constructor_hook(void * px); void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn); void sp_array_destructor_hook(void * px); #endif // The standard library that comes with Borland C++ 5.5.1 // defines std::exception and its members as having C calling // convention (-pc). When the definition of bad_weak_ptr // is compiled with -ps, the compiler issues an error. // Hence, the temporary #pragma option -pc below. The version // check is deliberately conservative. #if defined(__BORLANDC__) && __BORLANDC__ == 0x551 # pragma option push -pc #endif class bad_weak_ptr: public std::exception { public: virtual char const * what() const throw() { return "boost::bad_weak_ptr"; } }; #if defined(__BORLANDC__) && __BORLANDC__ == 0x551 # pragma option pop #endif namespace detail { class sp_counted_base { private: typedef detail::lightweight_mutex mutex_type; public: sp_counted_base(): use_count_(1), weak_count_(1) { } virtual ~sp_counted_base() // nothrow { } virtual void *get_ptr() { exit(-1); } virtual void set_ptr(void *ptr) { //cout <<"we are not supposed to be here!"<<endl; exit(-1); } // dispose() is called when use_count_ drops to zero, to release // the resources managed by *this. virtual void dispose() = 0; // nothrow // destruct() is called when weak_count_ drops to zero. virtual void destruct() // nothrow { delete this; } virtual void * get_deleter(std::type_info const & ti) = 0; void add_ref() { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif if(use_count_ == 0 && weak_count_ != 0) boost::throw_exception(boost::bad_weak_ptr()); ++use_count_; ++weak_count_; } void release() // nothrow { { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif long new_use_count = --use_count_; if(new_use_count != 0) { --weak_count_; return; } } dispose(); weak_release(); } void weak_add_ref() // nothrow { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif ++weak_count_; } void weak_release() // nothrow { long new_weak_count; { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif new_weak_count = --weak_count_; } if(new_weak_count == 0) { destruct(); } } long use_count() const // nothrow { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif return use_count_; } private: sp_counted_base(sp_counted_base const &); sp_counted_base & operator= (sp_counted_base const &); // inv: use_count_ <= weak_count_ long use_count_; long weak_count_; #if defined(BOOST_HAS_THREADS) mutable mutex_type mtx_; #endif }; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int) { boost::sp_scalar_constructor_hook(px, sizeof(T), pn); } template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int) { boost::sp_array_constructor_hook(px); } template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long) { } template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int) { boost::sp_scalar_destructor_hook(px, sizeof(T), pn); } template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int) { boost::sp_array_destructor_hook(px); } template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long) { } #endif // // Borland's Codeguard trips up over the -Vx- option here: // #ifdef __CODEGUARD__ # pragma option push -Vx- #endif template<class P, class D> class sp_counted_base_impl: public sp_counted_base { private: D del; // copy constructor must not throw P ptr; // copy constructor must not throw sp_counted_base_impl(sp_counted_base_impl const &); sp_counted_base_impl & operator= (sp_counted_base_impl const &); typedef sp_counted_base_impl<P, D> this_type; public: // pre: initial_use_count <= initial_weak_count, d(p) must not throw sp_counted_base_impl(P p, D d): ptr(p), del(d) { cout <<"IN sp_counted_base_impl ocnstructro ptr="<<ptr<<" p="<<p<<endl; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) detail::cbi_call_constructor_hook(this, p, d, 0); #endif cout <<"sizeof(*this)= "<<sizeof(*this)<<endl; cout <<"IN sp_counted_base_impl end ocnstructro ptr=" <<ptr<<" ptr addr: "<<&ptr<<" p="<<p<<endl; } virtual void dispose() // nothrow { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) detail::cbi_call_destructor_hook(this, ptr, del, 0); #endif //cout <<"IN boost::dispose ptr="<<ptr<<endl; del(ptr); } P get_ptr() { cout <<"this= "<<this<<" ptr in get_ptr= "<<ptr<<endl; cout <<"sizeof(*this)= "<<sizeof(*this)<<endl; cout <<"ptr addr: "<<&ptr<<endl; return ptr; } void set_ptr(P _ptr) { cout <<"this= "<<this<<" setting ptr to: "<<_ptr<<endl; ptr=_ptr; cout <<"sizeof(*this)= "<<sizeof(*this)<<endl; cout <<"ptr= "<<ptr<<endl; cout <<"ptr addr: "<<&ptr<<endl; } virtual void * get_deleter(std::type_info const & ti) { return ti == typeid(D)? &del: 0; } #if defined(BOOST_SP_USE_STD_ALLOCATOR) void * operator new(std::size_t) { return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0)); } void operator delete(void * p) { std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1); } #endif #if defined(BOOST_SP_USE_QUICK_ALLOCATOR) void * operator new(std::size_t) { return quick_allocator<this_type>::alloc(); } void operator delete(void * p) { quick_allocator<this_type>::dealloc(p); } #endif }; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int const shared_count_id = 0x2C35F101; int const weak_count_id = 0x298C38A4; #endif class weak_count; class shared_count { private: sp_counted_base * pi_; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int id_; #endif friend class weak_count; public: shared_count(): pi_(0) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { } template<class P, class D> shared_count(P p, D d): pi_(0) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { cout <<"in shared_count: p= "<<p<<endl; #ifndef BOOST_NO_EXCEPTIONS try { pi_ = new sp_counted_base_impl<P, D>(p, d); cout <<"return from new sp_counted_base_impl1: p= "<ptr= "<<pi_->get_ptr()<<endl; } catch(...) { d(p); // delete p throw; } #else pi_ = new sp_counted_base_impl<P, D>(p, d); cout <<"return from new sp_counted_base_impl2: p= "<ptr= "<<pi_->get_ptr()<<endl; if(pi_ == 0) { d(p); // delete p boost::throw_exception(std::bad_alloc()); } #endif ((sp_counted_base_impl<P, D>*)pi_)->set_ptr(p); cout <<"after fix: pi_->ptr= " <<((sp_counted_base_impl<P, D>*)pi_)->get_ptr()<<endl; cout <<"end of shared_count: ptr= "<<pi_->get_ptr()<<endl; } #ifndef BOOST_NO_AUTO_PTR // auto_ptr<Y> is special cased to provide the strong guarantee template<class Y> explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>())) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { r.release(); } #endif ~shared_count() // nothrow { if(pi_ != 0) pi_->release(); #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) id_ = 0; #endif } shared_count(shared_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->add_ref(); } explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0 shared_count & operator= (shared_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != 0) tmp->add_ref(); if(pi_ != 0) pi_->release(); pi_ = tmp; return *this; } void swap(shared_count & r) // nothrow { sp_counted_base * tmp = r.pi_; r.pi_ = pi_; pi_ = tmp; } long use_count() const // nothrow { return pi_ != 0? pi_->use_count(): 0; } bool unique() const // nothrow { return use_count() == 1; } friend inline bool operator==(shared_count const & a, shared_count const & b) { return a.pi_ == b.pi_; } friend inline bool operator<(shared_count const & a, shared_count const & b) { return std::less<sp_counted_base *>()(a.pi_, b.pi_); } void * get_deleter(std::type_info const & ti) const { return pi_? pi_->get_deleter(ti): 0; } template<class P, class D> P get_ptr() { return pi_?((sp_counted_base_impl<P, D>*)pi_)->get_ptr() : 0; } void set_ptr(void *ptr) { if(pi_) pi_->set_ptr(ptr); } }; #ifdef __CODEGUARD__ # pragma option pop #endif class weak_count { private: sp_counted_base * pi_; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int id_; #endif friend class shared_count; public: weak_count(): pi_(0) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(weak_count_id) #endif { } weak_count(shared_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->weak_add_ref(); } weak_count(weak_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->weak_add_ref(); } ~weak_count() // nothrow { if(pi_ != 0) pi_->weak_release(); #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) id_ = 0; #endif } weak_count & operator= (shared_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != 0) tmp->weak_add_ref(); if(pi_ != 0) pi_->weak_release(); pi_ = tmp; return *this; } weak_count & operator= (weak_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != 0) tmp->weak_add_ref(); if(pi_ != 0) pi_->weak_release(); pi_ = tmp; return *this; } void swap(weak_count & r) // nothrow { sp_counted_base * tmp = r.pi_; r.pi_ = pi_; pi_ = tmp; } long use_count() const // nothrow { return pi_ != 0? pi_->use_count(): 0; } friend inline bool operator==(weak_count const & a, weak_count const & b) { return a.pi_ == b.pi_; } friend inline bool operator<(weak_count const & a, weak_count const & b) { return std::less<sp_counted_base *>()(a.pi_, b.pi_); } }; inline shared_count::shared_count(weak_count const & r): pi_(r.pi_) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) { pi_->add_ref(); } else { boost::throw_exception(boost::bad_weak_ptr()); } } } // namespace detail } // namespace boost #ifdef __BORLANDC__ # pragma warn .8027 // Functions containing try are not expanded inline # pragma warn .8026 // Functions with excep. spec. are not expanded inline #endif #endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED in shared_count: p= 0x8127738 IN sp_counted_base_impl ocnstructro ptr=0x8127738 p=0x8127738 sizeof(*this)= 44 IN sp_counted_base_impl end ocnstructro ptr=0x8127738 ptr addr: 0x8127fd8 p=0x81 27738 this= 0x8127fb0 ptr in get_ptr= 0 sizeof(*this)= 20 ptr addr: 0x8127fc0 return from new sp_counted_base_impl1: p= 0x8127738 pi_->ptr= 0 this= 0x8127fb0 setting ptr to: 0x8127738 sizeof(*this)= 44 ptr= 0x8127738 ptr addr: 0x8127fd8 this= 0x8127fb0 ptr in get_ptr= 0 sizeof(*this)= 20 ptr addr: 0x8127fc0 after fix: pi_->ptr= 0 this= 0x8127fb0 ptr in get_ptr= 0 sizeof(*this)= 20 ptr addr: 0x8127fc0 end of shared_count: ptr= 0

2 2

Newbie question: block read inputs to regex
by annirak＠shaw.ca 13 Dec '03

13 Dec '03

I'm using regex_grep() to search through file contents for matches. I want to read the file in blocks to keep memory use down for large files. What I want to know is whether there is some way of adding the next block of memory to the grep where the last one left off. The best solution I can come up with is using some sort of double-buffering scheme, but that would take an awful lot of memory copies and searching some text multiple times. Both things I would prefer to avoid. What can I do? --Brendan

3 2

Re: Re: find japanese character with boost regex++
by moscao＠free.fr 13 Dec '03

13 Dec '03

>> Actually I have a text with a lot of strange characters and japanese >> one ( Hiragana, Katakana, Kanji everything..!) and I want to find these >>japanese sentence in order to translate them and replace in the text. >>I need hence a way in order to identify a japanese sentence . A kind >>of function const bool isJap( const wchar ) const would be fine. >Do you need to use regexes? I've not tried boost.regex yet so cannot help >there. >Is your text just ascii and Japanese? Or do you need to distinguish from >other languages as well? >If just ascii and Japanese, you could define a Japanese char as anything >that is not ascii (beware shift-jis encoding though, as 2nd byte of a double >byte character is in the ascii range). If your data is unicode it should >also be easy to treat European characters as non-Japanese as well. >Darren Thanks Darren for your reply, Well actually I can avoid using regex but my text is more than ascii and japanese. Actually it is a byte file where some pieces are japanese sentences and others are byte controls like 0x00 ( which introduces more difficulties because you cannot parse the text as a string because 0x00 is an end character... ). So I thinks I have to parse bytes by pair and try to identify them as Shift-JIS when it is the case. Any idea of a function or program that does it? Thanks, jschmid

3 2

R: [Boost-users] filesystem::copy_file throws -- but why?
by Galante Michele 12 Dec '03

12 Dec '03

I think you should rewrite your code either as: int processFile(const fs::path& fileName) { fs::path copyFileName(fileName.string() + ".bak"); fs::copy_file(fileName, copyFileName); } or as: int processFile(const fs::path& fileName) { fs::path copyFileName(fileName.native_file_string() + ".bak", fs::native); fs::copy_file(fileName, copyFileName); } In your example you are creating a fs::path from a string in "native" form by using the default constructor, which expects the string to be in "generic" form. Hope this helps. Regards, Michele Galante Zucchetti Centro Sistemi s.p.a. m.galante(a)centrosistemi.it -----Messaggio originale----- Da: Scott Meyers [mailto:Usenet@aristeia.com] Inviato: giovedì 11 dicembre 2003 7.11 A: boost-users(a)lists.boost.org Oggetto: [Boost-users] filesystem::copy_file throws -- but why? [...] int processFile(const fs::path& fileName) { fs::path copyFileName(fileName.native_file_string() + ".bak"); fs::copy_file(fileName, copyFileName); } This throws an exception: boost::filesystem::path: invalid name "D:\Temp\CDFix\INDEX.HTM.bak" in path: "D:\Temp\CDFix \INDEX.HTM.bak" [...]

4 4

Boost::Variant
by Akim Demaille 12 Dec '03

12 Dec '03

What is the status of Boost::Variant? It used to be documented in replicas of the real Boost documentation, but now these sites seem to be closed, and I can't find any information on boost.org. Thanks!

2 2

Need linking help for boost::filesystem
by Scott Meyers 12 Dec '03

12 Dec '03

I'd like to play with boost::filesystem, and this turns out to be the first boost library I've tried to use that requires that I build something first. I downloaded bjam, and it appears that I have successfully built filesystem libraries for the compilers I care about (VC6, VC7.1, gcc, and como), because there is a subdirectory for each of them under the libboost_filesystem.lib directory, and each subdirectory, if you push down far enough, has .obj files under both debug and release. But I can't get anything to link. I can get the sample filesystem app (simple_ls.cpp) to compile cleanly under all compilers, but nothing will link. It seems clear that I somehow need to tell the linker where to find the appropriate filesystem libraries, but I'm not sure where to point it. Help? I'm running Windows 2000. Thanks, Scott

10 15

newbie BGL problem: core dump due to graph size
by duccio.medini＠tin.it 12 Dec '03

12 Dec '03

Hi all. I am calculating the connected components of af graph with a c++ code written with BGL. My graph is huge (4E+05 vertexes, 10^6 ~ 10^8 edges). The code uses the connected_components algorithm (or, in a different version, directly the depth_first_visit one) and works well up to a "reasonable" number of edges in the graph. Over this threshold it core dumps. I have the same problem both on SPARC Solaris 9 g++3.2.2 and on Intel Linux 2.4 g++3.1 . I know that it should not be a problem of the RAM memory available on the system (or addressable form a single istance). I am able to use up to 6-7 GBs of RAM, and it tipically core dumps at 2.5-5 GBs. I suspect that I'm violating some intrinsic size limit in the BGL adjacency_list class or similar. Are there such limits, and can they be extended? Any clue would be really appreciated. Thanks in advance! Duccio Medini

4 4

Shared_ptr and constness
by cyril.godart＠bnpparibas.com 12 Dec '03

12 Dec '03

Hi, Just out of curiosity. I am increasingly using the smart_ptr and more specifically the shared_ptr but I came to realize that actually it rather violently breaches the constness rules. The example below is one of the many things you can do with a shared pointer that is forbidden with a naked pointer. As the shared_ptr penetrates even further in my code I come to realize that what I am gaining on the comfort side I loose on the safety. Clearly, that's my call but I was curious to know if it is a known fact that it is impossible to enforce constness rules. Cyril Godart Quantitative Analyst BNP Paribas. struct A { int bar; }; typedef boost::shared_ptr<A> A_ptr_t; void foo(const A_ptr_t& a) { a->bar++;//semantically this should not be possible. } int main(int argc, char* argv[]) { A_ptr_t a(new A); a->bar = 1; foo(a); return 0; } This message and any attachments (the "message") is intended solely for the addressees and is confidential. If you receive this message in error, please delete it and immediately notify the sender. Any use not in accord with its purpose, any dissemination or disclosure, either whole or partial, is prohibited except formal approval. The internet can not guarantee the integrity of this message. BNP PARIBAS (and its subsidiaries) shall (will) not therefore be liable for the message if modified. --------------------------------------------- Ce message et toutes les pieces jointes (ci-apres le "message") sont etablis a l'intention exclusive de ses destinataires et sont confidentiels. Si vous recevez ce message par erreur, merci de le detruire et d'en avertir immediatement l'expediteur. Toute utilisation de ce message non conforme a sa destination, toute diffusion ou toute publication, totale ou partielle, est interdite, sauf autorisation expresse. L'internet ne permettant pas d'assurer l'integrite de ce message, BNP PARIBAS (et ses filiales) decline(nt) toute responsabilite au titre de ce message, dans l'hypothese ou il aurait ete modifie.

2 1