The class template is parameterized on T, the type of the object pointed to. intrusive_ptr<T> can be implicitly converted to intrusive_ptr<U> diff --git a/intrusive_ref_counter.html b/intrusive_ref_counter.html index 30be3af..72a46e0 100644 --- a/intrusive_ref_counter.html +++ b/intrusive_ref_counter.html @@ -1,7 +1,7 @@
-The basic_intrusive_ref_counter class template implements a reference counter for a defived +
The intrusive_ref_counter class template implements a reference counter for a derived user's class that is intended to be used with intrusive_ptr. The base class has associated intrusive_ptr_add_ref and intrusive_ptr_release functions which modify the reference counter as needed and destroy the user's object when the counter drops to zero.
-The class template is parameterized on CounterPolicyT, which is a policy that defines the nature of the reference counter. +
The class template is parameterized on DerivedT and CounterPolicyT parameters. + The first parameter is the user's class that derives from intrusive_ref_counter. This type + is needed in order to destroy the object correctly when there are no references to it left.
+The second parameter is a policy that defines the nature of the reference counter. Boost.SmartPtr provides two such policies: thread_unsafe_counter and thread_safe_counter. The former - instructs the basic_intrusive_ref_counter base class to use a counter only suitable for a single-threaded use. + instructs the intrusive_ref_counter base class to use a counter only suitable for a single-threaded use. Pointers to a single object that uses this kind of reference counter must not be used in different threads. The latter policy makes the reference counter thread-safe, unless the target platform doesn't support threading. Since in modern systems support for - threading is common, a shorthand intrusive_ref_counter is provided, which is an alias for - basic_intrusive_ref_counter<thread_safe_counter>.
+ threading is common, the default counter policy is thread_safe_counter.namespace boost {
- template<class CounterPolicyT> class basic_intrusive_ref_counter {
-
- public:
-
- basic_intrusive_ref_counter();
- basic_intrusive_ref_counter(basic_intrusive_ref_counter const & r);
-
- virtual ~basic_intrusive_ref_counter();
-
- basic_intrusive_ref_counter & operator=(basic_intrusive_ref_counter const & r) noexcept;
-
- unsigned int use_count() const noexcept;
- };
-
struct thread_unsafe_counter;
struct thread_safe_counter;
- typedef basic_intrusive_ref_counter<thread_safe_counter> intrusive_ref_counter;
+ template<class DerivedT, class CounterPolicyT = thread_safe_counter>
+ class intrusive_ref_counter
+ {
+ public:
+ intrusive_ref_counter() = noexcept;
+ intrusive_ref_counter(intrusive_ref_counter const & r) = noexcept;
+
+ intrusive_ref_counter & operator=(intrusive_ref_counter const & r) noexcept;
+
+ unsigned int use_count() const noexcept;
+
+ protected:
+ ~intrusive_ref_counter() = default;
+ };
}
basic_intrusive_ref_counter();+
intrusive_ref_counter();
-Postconditions:
use_count() == 0.Throws: nothing.
Notes: The pointer to the constructed object is expected to be passed to intrusive_ptr constructor, assignment operator or reset() method, which would increment the reference counter.
basic_intrusive_ref_counter(basic_intrusive_ref_counter const &);+
intrusive_ref_counter(intrusive_ref_counter const &);
Postconditions:
use_count() == 0.Throws: nothing.
@@ -64,12 +65,14 @@ constructor, assignment operator or reset() method, which would increment the reference counter.
virtual ~basic_intrusive_ref_counter();+
~intrusive_ref_counter();
+Throws: nothing.
Effects: Destroys the counter object.
+Notes: The destructor is protected so that the object can only be destroyed through the DerivedT class.
basic_intrusive_ref_counter & operator=(basic_intrusive_ref_counter const & r) noexcept;+
intrusive_ref_counter & operator=(intrusive_ref_counter const & r) noexcept;
Effects: Does nothing, reference counter is not modified.
Returns:
@@ -83,7 +86,7 @@*this.
- $Date: 2013-08-31 23:37:43 +0400 (Sat, 31 Aug 2013) $
+ $Date$Copyright © 2013 Andrey Semashev. Distributed under the Boost Software License, Version 1.0. See accompanying file LICENSE_1_0.txt or diff --git a/test/intrusive_ref_counter_test.cpp b/test/intrusive_ref_counter_test.cpp index 4f2ab88..53d0bd3 100644 --- a/test/intrusive_ref_counter_test.cpp +++ b/test/intrusive_ref_counter_test.cpp @@ -38,7 +38,7 @@ namespace N1 { class my_class : - public boost::intrusive_ref_counter + public boost::intrusive_ref_counter< my_class > { public: static unsigned int destructor_count; @@ -56,7 +56,7 @@ unsigned int my_class::destructor_count = 0; namespace N2 { class my_class : - public boost::basic_intrusive_ref_counter< boost::thread_unsafe_counter > + public boost::intrusive_ref_counter< my_class, boost::thread_unsafe_counter > { public: static unsigned int destructor_count; @@ -73,17 +73,18 @@ unsigned int my_class::destructor_count = 0; namespace N3 { -struct X : - public virtual boost::intrusive_ref_counter +struct root : + public boost::intrusive_ref_counter< root > { + virtual ~root() {} }; } // namespace N3 namespace N4 { -struct Y : - public virtual boost::intrusive_ref_counter +struct X : + public virtual N3::root { }; @@ -91,9 +92,18 @@ struct Y : namespace N5 { +struct Y : + public virtual N3::root +{ +}; + +} // namespace N5 + +namespace N6 { + struct Z : - public N3::X, - public N4::Y + public N4::X, + public N5::Y { static unsigned int destructor_count; @@ -105,7 +115,7 @@ struct Z : unsigned int Z::destructor_count = 0; -} // namespace N5 +} // namespace N6 int main() @@ -130,16 +140,16 @@ int main() // The test checks that destroying through the base class works { - boost::intrusive_ptr< N5::Z > p1 = new N5::Z(); + boost::intrusive_ptr< N6::Z > p1 = new N6::Z(); BOOST_TEST(p1->use_count() == 1); - BOOST_TEST(N5::Z::destructor_count == 0); - boost::intrusive_ptr< boost::intrusive_ref_counter > p2 = p1; + BOOST_TEST(N6::Z::destructor_count == 0); + boost::intrusive_ptr< N3::root > p2 = p1; BOOST_TEST(p1->use_count() == 2); - BOOST_TEST(N5::Z::destructor_count == 0); + BOOST_TEST(N6::Z::destructor_count == 0); p1 = NULL; - BOOST_TEST(N5::Z::destructor_count == 0); + BOOST_TEST(N6::Z::destructor_count == 0); p2 = NULL; - BOOST_TEST(N5::Z::destructor_count == 1); + BOOST_TEST(N6::Z::destructor_count == 1); } return boost::report_errors();