feedc0de/boost_utility
1
0
Fork 0
forked from boostorg/utility
Code Pull Requests Activity

Initial base_from_member commit

Browse Source 
[SVN r11086]
This commit is contained in:
Beman Dawes
2001-09-10 14:04:28 +00:00
parent 7f43c682db
commit 97cde2183d
6 changed files with 1046 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

341
base_from_member.html Normal file
View File

@@ -0,0 +1,341 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<title>Boost: Base-from-Member Idiom Documentation</title>
</head>
<body bgcolor="white" link="blue" text="black" vlink="purple" alink="red">
<h1><img src="../../c++boost.gif" alt="C++ Boost" align="middle"
width="277" height="86">Base-from-Member Idiom</h1>
<p>The class template <code>boost::base_from_member</code> provides
a workaround for a class that needs to initialize a base class with a
member. The class template is in <cite><a
href="../../boost/utility/base_from_member.hpp">boost/utility/base_from_member.hpp</a></cite>
which is included in <i><a href="../../boost/utility.hpp">boost/utility.hpp</a></i>.
The class template is forward declared in <i><a href="../../boost/utility_fwd.hpp">boost/utility_fwd.hpp</a></i>.</p>
<p>There is test/example code in <cite><a
href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.</p>
<h2><a name="contents">Contents</a></h2>
<ul>
<li><a href="#contents">Contents</a></li>
<li><a href="#rationale">Rationale</a></li>
<li><a href="#synopsis">Synopsis</a></li>
<li><a href="#usage">Usage</a></li>
<li><a href="#example">Example</a></li>
<li><a href="#credits">Credits</a>
<ul>
<li><a href="#contributors">Contributors</a></li>
</ul></li>
</ul>
<h2><a name="rationale">Rationale</a></h2>
<p>When developing a class, sometimes a base class needs to be
initialized with a member of the current class. As a na&iuml;ve
example:</p>
<blockquote><pre>
#include &lt;streambuf&gt; <i>// for std::streambuf</i>
#include &lt;ostream&gt; <i>// for std::ostream</i>
class fdoutbuf
: public std::streambuf
{
public:
explicit fdoutbuf( int fd );
//...
};
class fdostream
: public std::ostream
{
protected:
fdoutbuf buf;
public:
explicit fdostream( int fd )
: buf( fd ), std::ostream( &amp;buf )
{}
//...
};
</pre></blockquote>
<p>This is undefined because C++'s initialization order mandates that
the base class is initialized before the member it uses. Ron Klatchko
developed a way around this by using the initialization order in his
favor. Base classes are intialized in order of declaration, so moving
the desired member to another base class, that is initialized before the
desired base class, can ensure proper initialization.</p>
<p>A custom base class can be made for this idiom:</p>
<blockquote><pre>
#include &lt;streambuf&gt; <i>// for std::streambuf</i>
#include &lt;ostream&gt; <i>// for std::ostream</i>
class fdoutbuf
: public std::streambuf
{
public:
explicit fdoutbuf( int fd );
//...
};
struct fdostream_pbase
{
fdoutbuf sbuffer;
explicit fdostream_pbase( int fd )
: sbuffer( fd )
{}
};
class fdostream
: private fdostream_pbase
, public std::ostream
{
typedef fdostream_pbase pbase_type;
typedef std::ostream base_type;
public:
explicit fdostream( int fd )
: pbase_type( fd ), base_type( &amp;sbuffer )
{}
//...
};
</pre></blockquote>
<p>Other projects can use similar custom base classes. The technique is basic enough to make a template, with a sample template class in this library. The main template parameter is the type of the enclosed member. The template class has several (explicit) constructor member templates, which implicitly type the constructor arguments and pass them to the member. The template class uses implicit copy construction and assignment, cancelling them if the enclosed member is non-copyable.</p>
<p>Manually coding a base class may be better if the construction
and/or copying needs are too complex for the supplied template class,
or if the compiler is not advanced enough to use it.</p>
<p>Since base classes are unnamed, a class cannot have multiple (direct)
base classes of the same type. The supplied template class has an
extra template parameter, an integer, that exists solely to provide type
differentiation. This parameter has a default value so a single use of a
particular member type does not need to concern itself with the integer.</p>
<h2><a name="synopsis">Synopsis</a></h2>
<blockquote><pre>
template &lt; typename MemberType, int UniqueID = 0 &gt;
class boost::base_from_member
{
protected:
MemberType member;
explicit base_from_member();
template&lt; typename T1 &gt;
explicit base_from_member( T1 x1 );
//...
template&lt; typename T1, typename T2, typename T3 &gt;
explicit base_from_member( T1 x1, T2 x2, T3 x3 );
};
</pre></blockquote>
<p>The class template has a first template parameter
<var>MemberType</var> representing the type of the based-member.
It has a last template parameter <var>UniqueID</var>, that is an
<code>int</code>, to differentiate between multiple base classes that use
the same based-member type. The last template parameter has a default
value of zero if it is omitted. The class template has a protected
data member called <var>member</var> that the derived class can use
for later base classes (or itself).</p>
<p>There is a default constructor and several constructor member
templates. These constructor templates can take as many arguments
(currently up to three) as possible and pass them to a constructor of
the data member. Since C++ does not allow any way to explicitly state
the template parameters of a templated constructor, make sure that
the arguments are already close as possible to the actual type used in
the data member's desired constructor.</p>
<h2><a name="usage">Usage</a></h2>
<p>With the starting example, the <code>fdoutbuf</code> sub-object needs
to be encapsulated in a base class that is inheirited before
<code>std::ostream</code>.</p>
<blockquote><pre>
#include &lt;boost/utility/base_from_member.hpp&gt;
#include &lt;streambuf&gt; <i>// for std::streambuf</i>
#include &lt;ostream&gt; <i>// for std::ostream</i>
class fdoutbuf
: public std::streambuf
{
public:
explicit fdoutbuf( int fd );
//...
};
class fdostream
: private boost::base_from_member&lt;fdoutbuf&gt;
, public std::ostream
{
// Helper typedef's
typedef boost::base_from_member&lt;fdoutbuf&gt; pbase_type;
typedef std::ostream base_type;
public:
explicit fdostream( int fd )
: pbase_type( fd ), base_type( &amp;member )
{}
//...
};
</pre></blockquote>
<p>The base-from-member idiom is an implementation detail, so it
should not be visible to the clients (or any derived classes) of
<code>fdostream</code>. Due to the initialization order, the
<code>fdoutbuf</code> sub-object will get initialized before the
<code>std::ostream</code> sub-object does, making the former
sub-object safe to use in the latter sub-object's construction. Since the
<code>fdoutbuf</code> sub-object of the final type is the only sub-object
with the name &quot;member,&quot; that name can be used
unqualified within the final class.</p>
<h2><a name="example">Example</a></h2>
<p>The base-from-member class templates should commonly involve
only one base-from-member sub-object, usually for attaching a
stream-buffer to an I/O stream. The next example demonstrates how
to use multiple base-from-member sub-objects and the resulting
qualification issues.</p>
<blockquote><pre>
#include &lt;boost/utility/base_from_member.hpp&gt;
#include &lt;cstddef&gt; <i>// for NULL</i>
struct an_int
{
int y;
an_int( float yf );
};
class switcher
{
public:
switcher();
switcher( double, int * );
//...
};
class flow_regulator
{
public:
flow_regulator( switcher &amp;, switcher &amp; );
//...
};
template &lt; unsigned Size &gt;
class fan
{
public:
explicit fan( switcher );
//...
};
class system
: private boost::base_from_member&lt;an_int&gt;
, private boost::base_from_member&lt;switcher&gt;
, private boost::base_from_member&lt;switcher, 1&gt;
, private boost::base_from_member&lt;switcher, 2&gt;
, protected flow_regulator
, public fan&lt;6&gt;
{
// Helper typedef's
typedef boost::base_from_member&lt;an_int&gt; pbase0_type;
typedef boost::base_from_member&lt;switcher&gt; pbase1_type;
typedef boost::base_from_member&lt;switcher, 1&gt; pbase2_type;
typedef boost::base_from_member&lt;switcher, 2&gt; pbase3_type;
typedef flow_regulator base1_type;
typedef fan&lt;6&gt; base2_type;
public:
system( double x );
//...
};
system::system( double x )
: pbase0_type( 0.2 )
, pbase1_type()
, pbase2_type( -16, &amp;this-&gt;pbase0_type::member )
, pbase3_type( x, static_cast&lt;int *&gt;(NULL) )
, base1_type( pbase3_type::member, pbase1_type::member )
, base2_type( pbase2_type::member )
{
//...
}
</pre></blockquote>
<p>The final class has multiple sub-objects with the name
&quot;member,&quot; so any use of that name needs qualification by
a name of the appropriate base type. (Using <code>typedef</code>s
ease mentioning the base types.) However, the fix introduces a new
problem when a pointer is needed. Using the address operator with
a sub-object qualified with its class's name results in a pointer-to-member
(here, having a type of <code>an_int boost::base_from_member&lt;an_int,
0&gt; :: *</code>) instead of a pointer to the member (having a type of
<code>an_int *</code>). The new problem is fixed by qualifying the
sub-object with &quot;<code>this-&gt;</code>,&quot; and is needed just
for pointers, and not for references or values.</p>
<p>There are some argument conversions in the initialization. The
constructor argument for <code>pbase0_type</code> is converted from
<code>double</code> to <code>float</code>. The first constructor
argument for <code>pbase2_type</code> is converted from <code>int</code>
to <code>double</code>. The second constructor argument for
<code>pbase3_type</code> is a special case of necessary conversion; all
forms of the null-pointer literal in C++ also look like compile-time
integral expressions, so C++ always interprets such code as an integer
when it has overloads that can take either an integer or a pointer. The
last conversion is necessary for the compiler to call a constructor form
with the exact pointer type used in <code>switcher</code>'s constructor.</p>
<h2><a name="credits">Credits</a></h2>
<h3><a name="contributors">Contributors</a></h3>
<dl>
<dt><a href="../../people/ed_brey.htm">Ed Brey</a>
<dd>Suggested some interface changes.
<dt>Ron Klatchko (<a href="mailto:ron@crl.com">ron@crl.com</a>)
<dd>Invented the idiom of how to use a class member for initializing
a base class.
<dt><a href="../../people/dietmar_kuehl.htm">Dietmar Kuehl</a>
<dd>Popularized the base-from-member idiom in his
<a href="http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/">IOStream
example classes</a>.
<dt><a href="../../people/daryle_walker.html">Daryle Walker</a>
<dd>Started the library. Contributed the test file <cite><a
href="base_from_member_test.cpp">base_from_member_test.cpp</a></cite>.
</dl>
<hr>
<p>Revised: 22 August 2001</p>
<p>Copyright &copy; boost.org 2001. Permission to copy, use, modify,
sell and distribute this document is granted provided this copyright
notice appears in all copies. This document is provided &quot;as
is&quot; without express or implied warranty, and with no claim as to
its suitability for any purpose.</p>
</body>
</html>

597
base_from_member_test.cpp Normal file
View File

@@ -0,0 +1,597 @@
// Boost test program for base-from-member class templates -----------------//
// (C) Copyright Daryle Walker 2001. 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 for most recent version including documentation.
// Revision History
// 29 Aug 2001 Initial Version (Daryle Walker)
#define BOOST_INCLUDE_MAIN
#include <boost/test/test_tools.hpp> // for BOOST_TEST, main
#include <boost/config.hpp> // for BOOST_NO_MEMBER_TEMPLATES
#include <boost/cstdlib.hpp> // for boost::exit_success
#include <boost/utility.hpp> // for boost::noncopyable
#include <boost/utility/base_from_member.hpp> // for boost::base_from_member
#include <functional> // for std::binary_function, std::less
#include <iostream> // for std::cout (std::ostream, std::endl indirectly)
#include <set> // for std::set
#include <typeinfo> // for std::type_info
#include <utility> // for std::pair, std::make_pair
#include <vector> // for std::vector
// Control if extra information is printed
#ifndef CONTROL_EXTRA_PRINTING
#define CONTROL_EXTRA_PRINTING 1
#endif
// A (sub)object can be identified by its memory location and its type.
// Both are needed since an object can start at the same place as its
// first base class subobject and/or contained subobject.
typedef std::pair< void *, std::type_info const * > object_id;
// Object IDs need to be printed
std::ostream & operator <<( std::ostream &os, object_id const &oi );
// A way to generate an object ID
template < typename T >
object_id identify( T &obj );
// A custom comparison type is needed
struct object_id_compare
: std::binary_function<object_id, object_id, bool>
{
bool operator ()( object_id const &a, object_id const &b ) const;
}; // object_id_compare
// A singleton of this type coordinates the acknowledgements
// of objects being created and used.
class object_registrar
: boost::noncopyable
{
public:
#ifndef BOOST_NO_MEMBER_TEMPLATES
template < typename T >
void register_object( T &obj )
{ this->register_object_imp( identify(obj) ); }
template < typename T, typename U >
void register_use( T &owner, U &owned )
{ this->register_use_imp( identify(owner), identify(owned) ); }
template < typename T, typename U >
void unregister_use( T &owner, U &owned )
{ this->unregister_use_imp( identify(owner), identify(owned) ); }
template < typename T >
void unregister_object( T &obj )
{ this->unregister_object_imp( identify(obj) ); }
#endif
void register_object_imp( object_id obj );
void register_use_imp( object_id owner, object_id owned );
void unregister_use_imp( object_id owner, object_id owned );
void unregister_object_imp( object_id obj );
typedef std::set<object_id, object_id_compare> set_type;
typedef std::vector<object_id> error_record_type;
typedef std::vector< std::pair<object_id, object_id> > error_pair_type;
set_type db_;
error_pair_type defrauders_in_, defrauders_out_;
error_record_type overeager_, overkilled_;
}; // object_registrar
// A sample type to be used by containing types
class base_or_member
{
public:
explicit base_or_member( int x = 1, double y = -0.25 );
~base_or_member();
}; // base_or_member
// A sample type that uses base_or_member, used
// as a base for the main demonstration classes
class base_class
{
public:
explicit base_class( base_or_member &x, base_or_member *y = 0,
base_or_member *z = 0 );
~base_class();
private:
base_or_member *x_, *y_, *z_;
}; // base_class
// This bad class demonstrates the direct method of a base class needing
// to be initialized by a member. This is improper since the member
// isn't initialized until after the base class.
class bad_class
: public base_class
{
public:
bad_class();
~bad_class();
private:
base_or_member x_;
}; // bad_class
// The first good class demonstrates the correct way to initialize a
// base class with a member. The member is changed to another base
// class, one that is initialized before the base that needs it.
class good_class_1
: private boost::base_from_member<base_or_member>
, public base_class
{
typedef boost::base_from_member<base_or_member> pbase_type;
typedef base_class base_type;
public:
good_class_1();
~good_class_1();
}; // good_class_1
// The second good class also demonstrates the correct way to initialize
// base classes with other subobjects. This class uses the other helpers
// in the library, and shows the technique of using two base subobjects
// of the "same" type.
class good_class_2
: private boost::base_from_member<base_or_member, 0>
, private boost::base_from_member<base_or_member, 1>
, private boost::base_from_member<base_or_member, 2>
, public base_class
{
typedef boost::base_from_member<base_or_member, 0> pbase_type0;
typedef boost::base_from_member<base_or_member, 1> pbase_type1;
typedef boost::base_from_member<base_or_member, 2> pbase_type2;
typedef base_class base_type;
public:
good_class_2();
~good_class_2();
}; // good_class_2
// Declare/define the single object registrar
object_registrar obj_reg;
// Main functionality
int
test_main( int , char * [] )
{
BOOST_TEST( obj_reg.db_.empty() );
BOOST_TEST( obj_reg.defrauders_in_.empty() );
BOOST_TEST( obj_reg.defrauders_out_.empty() );
BOOST_TEST( obj_reg.overeager_.empty() );
BOOST_TEST( obj_reg.overkilled_.empty() );
// Make a separate block to examine pre- and post-effects
{
using std::cout;
using std::endl;
bad_class bc;
BOOST_TEST( obj_reg.db_.size() == 3 );
BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
good_class_1 gc1;
BOOST_TEST( obj_reg.db_.size() == 6 );
BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
good_class_2 gc2;
BOOST_TEST( obj_reg.db_.size() == 11 );
BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
BOOST_TEST( obj_reg.defrauders_out_.empty() );
BOOST_TEST( obj_reg.overeager_.empty() );
BOOST_TEST( obj_reg.overkilled_.empty() );
// Getting the addresses of the objects ensure
// that they're used, and not optimized away.
cout << "Object 'bc' is at " << &bc << '.' << endl;
cout << "Object 'gc1' is at " << &gc1 << '.' << endl;
cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
}
BOOST_TEST( obj_reg.db_.empty() );
BOOST_TEST( obj_reg.defrauders_in_.size() == 1 );
BOOST_TEST( obj_reg.defrauders_out_.size() == 1 );
BOOST_TEST( obj_reg.overeager_.empty() );
BOOST_TEST( obj_reg.overkilled_.empty() );
return boost::exit_success;
}
// Print an object's ID
std::ostream &
operator <<
(
std::ostream & os,
object_id const & oi
)
{
// I had an std::ostringstream to help, but I did not need it since
// the program never screws around with formatting. Worse, using
// std::ostringstream is an issue with some compilers.
return os << '[' << ( oi.second ? oi.second->name() : "NOTHING" )
<< " at " << oi.first << ']';
}
// Get an object ID given an object
template < typename T >
inline
object_id
identify
(
T & obj
)
{
return std::make_pair( static_cast<void *>(&obj), &(typeid( obj )) );
}
// Compare two object IDs
bool
object_id_compare::operator ()
(
object_id const & a,
object_id const & b
) const
{
std::less<void *> vp_cmp;
if ( vp_cmp(a.first, b.first) )
{
return true;
}
else if ( vp_cmp(b.first, a.first) )
{
return false;
}
else
{
// object pointers are equal, compare the types
if ( a.second == b.second )
{
return false;
}
else if ( !a.second )
{
return true; // NULL preceeds anything else
}
else if ( !b.second )
{
return false; // NULL preceeds anything else
}
else
{
return a.second->before( *b.second );
}
}
}
// Let an object register its existence
void
object_registrar::register_object_imp
(
object_id obj
)
{
if ( db_.count(obj) <= 0 )
{
db_.insert( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Registered " << obj << '.' << std::endl;
#endif
}
else
{
overeager_.push_back( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to register a non-existant " << obj
<< '.' << std::endl;
#endif
}
}
// Let an object register its use of another object
void
object_registrar::register_use_imp
(
object_id owner,
object_id owned
)
{
if ( db_.count(owned) > 0 )
{
// We don't care to record usage registrations
}
else
{
defrauders_in_.push_back( std::make_pair(owner, owned) );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to own a non-existant " << owned
<< " by " << owner << '.' << std::endl;
#endif
}
}
// Let an object un-register its use of another object
void
object_registrar::unregister_use_imp
(
object_id owner,
object_id owned
)
{
if ( db_.count(owned) > 0 )
{
// We don't care to record usage un-registrations
}
else
{
defrauders_out_.push_back( std::make_pair(owner, owned) );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to disown a non-existant " << owned
<< " by " << owner << '.' << std::endl;
#endif
}
}
// Let an object un-register its existence
void
object_registrar::unregister_object_imp
(
object_id obj
)
{
set_type::iterator const i = db_.find( obj );
if ( i != db_.end() )
{
db_.erase( i );
#if CONTROL_EXTRA_PRINTING
std::cout << "Unregistered " << obj << '.' << std::endl;
#endif
}
else
{
overkilled_.push_back( obj );
#if CONTROL_EXTRA_PRINTING
std::cout << "Attempted to unregister a non-existant " << obj
<< '.' << std::endl;
#endif
}
}
// Macros to abstract the registration of objects
#ifndef BOOST_NO_MEMBER_TEMPLATES
#define PRIVATE_REGISTER_BIRTH(o) obj_reg.register_object( (o) )
#define PRIVATE_REGISTER_DEATH(o) obj_reg.unregister_object( (o) )
#define PRIVATE_REGISTER_USE(o, w) obj_reg.register_use( (o), (w) )
#define PRIVATE_UNREGISTER_USE(o, w) obj_reg.unregister_use( (o), (w) )
#else
#define PRIVATE_REGISTER_BIRTH(o) obj_reg.register_object_imp( \
identify((o)) )
#define PRIVATE_REGISTER_DEATH(o) obj_reg.unregister_object_imp( \
identify((o)) )
#define PRIVATE_REGISTER_USE(o, w) obj_reg.register_use_imp( identify((o)), \
identify((w)) )
#define PRIVATE_UNREGISTER_USE(o, w) obj_reg.unregister_use_imp( \
identify((o)), identify((w)) )
#endif
// Create a base_or_member, with arguments to simulate member initializations
base_or_member::base_or_member
(
int x, // = 1
double y // = -0.25
)
{
PRIVATE_REGISTER_BIRTH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy x-factor is " << x << " and my y-factor is " << y
<< '.' << std::endl;
#endif
}
// Destroy a base_or_member
inline
base_or_member::~base_or_member
(
)
{
PRIVATE_REGISTER_DEATH( *this );
}
// Create a base_class, registering any objects used
base_class::base_class
(
base_or_member & x,
base_or_member * y, // = 0
base_or_member * z // = 0
)
: x_( &x ), y_( y ), z_( z )
{
PRIVATE_REGISTER_BIRTH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy x-factor is " << x_;
#endif
PRIVATE_REGISTER_USE( *this, *x_ );
if ( y_ )
{
#if CONTROL_EXTRA_PRINTING
std::cout << ", my y-factor is " << y_;
#endif
PRIVATE_REGISTER_USE( *this, *y_ );
}
if ( z_ )
{
#if CONTROL_EXTRA_PRINTING
std::cout << ", my z-factor is " << z_;
#endif
PRIVATE_REGISTER_USE( *this, *z_ );
}
#if CONTROL_EXTRA_PRINTING
std::cout << '.' << std::endl;
#endif
}
// Destroy a base_class, unregistering the objects it uses
base_class::~base_class
(
)
{
PRIVATE_REGISTER_DEATH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy x-factor was " << x_;
#endif
PRIVATE_UNREGISTER_USE( *this, *x_ );
if ( y_ )
{
#if CONTROL_EXTRA_PRINTING
std::cout << ", my y-factor was " << y_;
#endif
PRIVATE_UNREGISTER_USE( *this, *y_ );
}
if ( z_ )
{
#if CONTROL_EXTRA_PRINTING
std::cout << ", my z-factor was " << z_;
#endif
PRIVATE_UNREGISTER_USE( *this, *z_ );
}
#if CONTROL_EXTRA_PRINTING
std::cout << '.' << std::endl;
#endif
}
// Create a bad_class, noting the improper construction order
bad_class::bad_class
(
)
: x_( -7, 16.75 ), base_class( x_ ) // this order doesn't matter
{
PRIVATE_REGISTER_BIRTH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factor is at " << &x_
<< " and my base is at " << static_cast<base_class *>(this) << '.'
<< std::endl;
#endif
}
// Destroy a bad_class, noting the improper destruction order
bad_class::~bad_class
(
)
{
PRIVATE_REGISTER_DEATH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factor was at " << &x_
<< " and my base was at " << static_cast<base_class *>(this)
<< '.' << std::endl;
#endif
}
// Create a good_class_1, noting the proper construction order
good_class_1::good_class_1
(
)
: pbase_type( 8 ), base_type( member )
{
PRIVATE_REGISTER_BIRTH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factor is at " << &member
<< " and my base is at " << static_cast<base_class *>(this) << '.'
<< std::endl;
#endif
}
// Destroy a good_class_1, noting the proper destruction order
good_class_1::~good_class_1
(
)
{
PRIVATE_REGISTER_DEATH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factor was at " << &member
<< " and my base was at " << static_cast<base_class *>(this)
<< '.' << std::endl;
#endif
}
// Create a good_class_2, noting the proper construction order
good_class_2::good_class_2
(
)
: pbase_type0(), pbase_type1(-16, 0.125), pbase_type2(2, -3)
, base_type( pbase_type1::member, &this->pbase_type0::member,
&this->pbase_type2::member )
{
PRIVATE_REGISTER_BIRTH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factors are at " << &this->pbase_type0::member
<< ", " << &this->pbase_type1::member << ", "
<< &this->pbase_type2::member << ", and my base is at "
<< static_cast<base_class *>(this) << '.' << std::endl;
#endif
}
// Destroy a good_class_2, noting the proper destruction order
good_class_2::~good_class_2
(
)
{
PRIVATE_REGISTER_DEATH( *this );
#if CONTROL_EXTRA_PRINTING
std::cout << "\tMy factors were at " << &this->pbase_type0::member
<< ", " << &this->pbase_type1::member << ", "
<< &this->pbase_type2::member << ", and my base was at "
<< static_cast<base_class *>(this) << '.' << std::endl;
#endif
}

20
include/boost/utility.hpp
View File

@@ -10,23 +10,15 @@
// Classes appear in alphabetical order
// Revision History
// 21 May 01 checked_delete() and checked_array_delete() added (Beman Dawes,
// suggested by Dave Abrahams, generalizing idea from Vladimir Prus)
// 21 May 01 made next() and prior() inline (Beman Dawes)
// 26 Jan 00 protected noncopyable destructor added (Miki Jovanovic)
// 10 Dec 99 next() and prior() templates added (Dave Abrahams)
// 30 Aug 99 moved cast templates to cast.hpp (Beman Dawes)
// 3 Aug 99 cast templates added
// 20 Jul 99 name changed to utility.hpp
// 9 Jun 99 protected noncopyable default ctor
// 2 Jun 99 Initial Version. Class noncopyable only contents (Dave Abrahams)
#ifndef BOOST_UTILITY_HPP
#define BOOST_UTILITY_HPP
#include <boost/config.hpp> // broken compiler workarounds
#include <boost/static_assert.hpp>
#include <boost/config.hpp> // broken compiler workarounds
#include <boost/static_assert.hpp>
// certain headers are part of the <utility.hpp> interface
#include <boost/utility/base_from_member.hpp>
#include <cstddef> // for size_t
#include <utility> // for std::pair

59
include/boost/utility/base_from_member.hpp Normal file
View File

@@ -0,0 +1,59 @@
// boost utility/base_from_member.hpp header file --------------------------//
// (C) Copyright Daryle Walker 2001. 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 for most recent version including documentation.
#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
#include <boost/utility_fwd.hpp> // self include
namespace boost
{
// Base-from-member class template -----------------------------------------//
// Helper to initialize a base object so a derived class can use this
// object in the initialization of another base class. Used by
// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
// base class needing to be initialized by a member.
// Contributed by Daryle Walker
template < typename MemberType, int UniqueID >
class base_from_member
{
protected:
MemberType member;
explicit base_from_member()
: member()
{}
template< typename T1 >
explicit base_from_member( T1 x1 )
: member( x1 )
{}
template< typename T1, typename T2 >
explicit base_from_member( T1 x1, T2 x2 )
: member( x1, x2 )
{}
template< typename T1, typename T2, typename T3 >
explicit base_from_member( T1 x1, T2 x2, T3 x3 )
: member( x1, x2, x3 )
{}
}; // boost::base_from_member
} // namespace boost
#endif // BOOST_UTILITY_BASE_FROM_MEMBER_HPP

38
include/boost/utility_fwd.hpp Normal file
View File

@@ -0,0 +1,38 @@
// Boost utility_fwd.hpp header file ---------------------------------------//
// (C) Copyright boost.org 2001. 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 for most recent version including documentation.
#ifndef BOOST_UTILITY_FWD_HPP
#define BOOST_UTILITY_FWD_HPP
namespace boost
{
// From <boost/utility/base_from_member.hpp> -------------------------------//
template < typename MemberType, int UniqueID = 0 >
class base_from_member;
// From <boost/utility.hpp> ------------------------------------------------//
class noncopyable;
template < class A, class B >
class tied;
// Also has a few function templates
} // namespace boost
#endif // BOOST_UTILITY_FWD_HPP

6
utility.htm
View File

@@ -16,6 +16,8 @@
<h2>Contents</h2>
<ul>
<li>Class templates supporting the <a href="base_from_member.html">base-from-member
idiom</a></li>
<li>Function templates <a href="#checked_delete">checked_delete() and
checked_array_delete()</a></li>
<li>Function templates <a href="#functions next">next() and prior()</a></li>
@@ -131,11 +133,13 @@ emphasize that it is to be used only as a base class.&nbsp; Dave Abrahams notes
concern about the effect on compiler optimization of adding (even trivial inline)
destructor declarations. He says &quot;Probably this concern is misplaced, because
noncopyable will be used mostly for classes which own resources and thus have non-trivial destruction semantics.&quot;</p>
<h2>Class templates for the Base-from-Member Idiom</h2>
<p>See <a href="base_from_member.html">separate documentation</a>.</p>
<h2>Function template tie()</h2>
<p>See <a href="tie.html">separate documentation</a>.</p>
<hr>
<p>Revised&nbsp; <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
-->22 May, 2001<!--webbot bot="Timestamp" endspan i-checksum="13960"
-->10 September, 2001<!--webbot bot="Timestamp" endspan i-checksum="39328"
-->
</p>
<p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and