forked from boostorg/utility
Compare commits
10 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
| 11fa077264 | |||
| b5418034ff | |||
| 6dda4704e1 | |||
| 79c360a1d8 | |||
| b70ad177bb | |||
| 7b02fdb1d9 | |||
| 73acec35c9 | |||
| 3ddb9abc3c | |||
| 5b06dd0d0d | |||
| daf7829ffa |
188
CopyConstructible.html
Normal file
188
CopyConstructible.html
Normal file
@ -0,0 +1,188 @@
|
||||
<HTML>
|
||||
<!--
|
||||
-- Copyright (c) Jeremy Siek 2000
|
||||
--
|
||||
-- Permission to use, copy, modify, distribute and sell this software
|
||||
-- and its documentation for any purpose is hereby granted without fee,
|
||||
-- provided that the above copyright notice appears in all copies and
|
||||
-- that both that copyright notice and this permission notice appear
|
||||
-- in supporting documentation. Silicon Graphics makes no
|
||||
-- representations about the suitability of this software for any
|
||||
-- purpose. It is provided "as is" without express or implied warranty.
|
||||
-->
|
||||
<Head>
|
||||
<Title>CopyConstructible</Title>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
|
||||
ALINK="#ff0000">
|
||||
<IMG SRC="../../c++boost.gif"
|
||||
ALT="C++ Boost">
|
||||
<!--end header-->
|
||||
<BR Clear>
|
||||
<H1>CopyConstructible</H1>
|
||||
|
||||
<h3>Description</h3>
|
||||
A type is CopyConstructible if it is possible to copy objects of that
|
||||
type.
|
||||
|
||||
<h3>Notation</h3>
|
||||
<Table>
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
<tt>T</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
is type that is a model of CopyConstructible
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
<tt>t</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
is an object of type <tt>T</tt>
|
||||
</TD>
|
||||
</tr>
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
<tt>u</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
is an object of type <tt>const T</tt>
|
||||
</TD>
|
||||
</tr>
|
||||
|
||||
</table>
|
||||
<h3>Definitions</h3>
|
||||
<h3>Valid expressions</h3>
|
||||
<Table border>
|
||||
<TR>
|
||||
<TH>
|
||||
Name
|
||||
</TH>
|
||||
<TH>
|
||||
Expression
|
||||
</TH>
|
||||
<TH>
|
||||
Return type
|
||||
</TH>
|
||||
<TH>
|
||||
Semantics
|
||||
</TH>
|
||||
</TR>
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
Copy constructor
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T(t)</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>t</tt> is equivalent to <tt>T(t)</tt>
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
Copy constructor
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<pre>
|
||||
T(u)
|
||||
</pre>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>u</tt> is equivalent to <tt>T(u)</tt>
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
Destructor
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<pre>
|
||||
t.~T()
|
||||
</pre>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
Address Operator
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<pre>
|
||||
&t
|
||||
</pre>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T*</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
denotes the address of <tt>t</tt>
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
<TR>
|
||||
<TD VAlign=top>
|
||||
Address Operator
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<pre>
|
||||
&u
|
||||
</pre>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
<tt>T*</tt>
|
||||
</TD>
|
||||
<TD VAlign=top>
|
||||
denotes the address of <tt>u</tt>
|
||||
</TD>
|
||||
</TR>
|
||||
|
||||
|
||||
|
||||
</table>
|
||||
|
||||
|
||||
</table>
|
||||
<h3>Models</h3>
|
||||
|
||||
<UL>
|
||||
<LI><tt>int</tt>
|
||||
<LI><tt>std::pair</tt>
|
||||
</UL>
|
||||
|
||||
<h3>See also</h3>
|
||||
<A
|
||||
href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</A>
|
||||
and
|
||||
<A href="http://www.sgi.com/Technology/STL/Assignable.html">Assignable</A>
|
||||
|
||||
<br>
|
||||
<HR>
|
||||
<TABLE>
|
||||
<TR valign=top>
|
||||
<TD nowrap>Copyright © 2000</TD><TD>
|
||||
<A HREF=http://www.lsc.nd.edu/~jsiek>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
|
||||
</TD></TR></TABLE>
|
||||
|
||||
</BODY>
|
||||
</HTML>
|
||||
92
MultiPassInputIterator.html
Normal file
92
MultiPassInputIterator.html
Normal file
@ -0,0 +1,92 @@
|
||||
<HTML>
|
||||
<!--
|
||||
-- Copyright (c) Jeremy Siek 2000
|
||||
--
|
||||
-- Permission to use, copy, modify, distribute and sell this software
|
||||
-- and its documentation for any purpose is hereby granted without fee,
|
||||
-- provided that the above copyright notice appears in all copies and
|
||||
-- that both that copyright notice and this permission notice appear
|
||||
-- in supporting documentation. Silicon Graphics makes no
|
||||
-- representations about the suitability of this software for any
|
||||
-- purpose. It is provided "as is" without express or implied warranty.
|
||||
-->
|
||||
<Head>
|
||||
<Title>MultiPassInputIterator</Title>
|
||||
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
|
||||
ALINK="#ff0000">
|
||||
<IMG SRC="../../c++boost.gif"
|
||||
ALT="C++ Boost">
|
||||
|
||||
<BR Clear>
|
||||
|
||||
<H2>
|
||||
<A NAME="concept:MultiPassInputIterator"></A>
|
||||
MultiPassInputIterator
|
||||
</H2>
|
||||
|
||||
This concept is a refinement of <a
|
||||
href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>,
|
||||
adding the requirements that the iterator can be used to make multiple
|
||||
passes through a range, and that if <TT>it1 == it2</TT> and
|
||||
<TT>it1</TT> is dereferenceable then <TT>++it1 == ++it2</TT>. The
|
||||
MultiPassInputIterator is very similar to the <a
|
||||
href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>. The
|
||||
only difference is that a <a
|
||||
href="http://www.sgi.com/Technology/STL/ForwardIterator.hmtl">ForwardIterator</a>
|
||||
requires the <TT>reference</TT> type to be <TT>value_type&</TT>, whereas
|
||||
MultiPassInputIterator is like <a
|
||||
href="http://www.sgi.com/Technology/STL/InputIterator.html">InputIterator</a>
|
||||
in that the <TT>reference</TT> type merely has to be convertible to
|
||||
<TT>value_type</TT>.
|
||||
|
||||
|
||||
<h3>Design Notes</h3>
|
||||
|
||||
comments by Valentin Bonnard:
|
||||
|
||||
<p> I think that introducing MultiPassInputIterator isn't the right
|
||||
solution. Do you also want to define MultiPassBidirectionnalIterator
|
||||
and MultiPassRandomAccessIterator ? I don't, definitly. It only
|
||||
confuses the issue. The problem lies into the existing hierarchy of
|
||||
iterators, which mixes movabillity, modifiabillity and lvalue-ness,
|
||||
and these are clearly independant.
|
||||
|
||||
<p> The terms Forward, Bidirectionnal and RandomAccess are about
|
||||
movabillity and shouldn't be used to mean anything else. In a
|
||||
completly orthogonal way, iterators can be immutable, mutable, or
|
||||
neither. Lvalueness of iterators is also orthogonal with
|
||||
immutabillity. With these clean concepts, your MultiPassInputIterator
|
||||
is just called a ForwardIterator.
|
||||
|
||||
<p>
|
||||
Other translations are:<br>
|
||||
std::ForwardIterator -> ForwardIterator & LvalueIterator<br>
|
||||
std::BidirectionnalIterator -> BidirectionnalIterator & LvalueIterator<br>
|
||||
std::RandomAccessIterator -> RandomAccessIterator & LvalueIterator<br>
|
||||
|
||||
<p>
|
||||
Note that in practice the only operation not allowed on my
|
||||
ForwardIterator which is allowed on std::ForwardIterator is
|
||||
<tt>&*it</tt>. I think that <tt>&*</tt> is rarely needed in generic code.
|
||||
|
||||
<p>
|
||||
reply by Jeremy Siek:
|
||||
|
||||
<p>
|
||||
The above analysis by Valentin is right on. Of course, there is
|
||||
the problem with backward compatibility. The current STL implementations
|
||||
are based on the old definition of ForwardIterator. The right course
|
||||
of action is to get ForwardIterator, etc. changed in the C++ standard.
|
||||
Once that is done we can drop MultiPassInputIterator.
|
||||
|
||||
|
||||
<br>
|
||||
<HR>
|
||||
<TABLE>
|
||||
<TR valign=top>
|
||||
<TD nowrap>Copyright © 2000</TD><TD>
|
||||
<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
|
||||
</TD></TR></TABLE>
|
||||
|
||||
</BODY>
|
||||
</HTML>
|
||||
@ -53,7 +53,7 @@ using std::cin;
|
||||
namespace opt{
|
||||
|
||||
//
|
||||
// algorithm destroy_arry:
|
||||
// algorithm destroy_array:
|
||||
// The reverse of std::unitialized_copy, takes a block of
|
||||
// unitialized memory and calls destructors on all objects therein.
|
||||
//
|
||||
|
||||
@ -1,3 +1,11 @@
|
||||
// boost::compressed_pair test program
|
||||
|
||||
// (C) Copyright John Maddock 2000. 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.
|
||||
|
||||
// standalone test program for <boost/call_traits.hpp>
|
||||
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
@ -6,12 +14,7 @@
|
||||
#include <typeinfo>
|
||||
#include <boost/call_traits.hpp>
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
// turn off some warnings, the way we do the tests will generate a *lot* of these
|
||||
// this is a result of the tests not call_traits itself....
|
||||
#pragma option -w-8004 -w-ccc -w-rch -w-eff -w-aus
|
||||
#endif
|
||||
|
||||
#include "type_traits_test.hpp"
|
||||
//
|
||||
// struct contained models a type that contains a type (for example std::pair)
|
||||
// arrays are contained by value, and have to be treated as a special case:
|
||||
@ -178,30 +181,6 @@ struct UDT
|
||||
bool operator == (const UDT& v){ return v.i_ == i_; }
|
||||
};
|
||||
|
||||
//
|
||||
// define tests here
|
||||
unsigned failures = 0;
|
||||
unsigned test_count = 0;
|
||||
|
||||
#define value_test(v, x) ++test_count;\
|
||||
if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(boost::is_same<v, x>::value == false){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
|
||||
#else
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(typeid(v) != typeid(x)){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
|
||||
#endif
|
||||
|
||||
int main()
|
||||
{
|
||||
checker<UDT> c1;
|
||||
@ -261,7 +240,7 @@ int main()
|
||||
type_test(const int&, boost::call_traits<cr_type>::const_reference)
|
||||
type_test(int&, boost::call_traits<cr_type>::param_type)
|
||||
#else
|
||||
std::cout << "GNU C++ cannot instantiate call_traits<cr_type>, skipping four tests (4 errors)" << std::endl;
|
||||
std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
|
||||
failures += 4;
|
||||
test_count += 4;
|
||||
#endif
|
||||
@ -363,7 +342,6 @@ void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_ty
|
||||
param_type p4(p);
|
||||
}
|
||||
#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
|
||||
//
|
||||
// now check call_traits assertions by instantiating call_traits_test:
|
||||
template struct call_traits_test<int>;
|
||||
@ -375,4 +353,3 @@ template struct call_traits_test<const int&>;
|
||||
template struct call_traits_test<int[2], true>;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
@ -5,43 +5,17 @@
|
||||
// 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.
|
||||
|
||||
// standalone test program for <boost/compressed_pair.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <typeinfo>
|
||||
#include <cassert>
|
||||
|
||||
#include <boost/compressed_pair.hpp>
|
||||
#include "type_traits_test.hpp"
|
||||
|
||||
using namespace boost;
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma option -w-ccc -w-rch -w-eff -w-aus
|
||||
#endif
|
||||
|
||||
//
|
||||
// define tests here
|
||||
unsigned failures = 0;
|
||||
unsigned test_count = 0;
|
||||
|
||||
#define value_test(v, x) ++test_count;\
|
||||
if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
|
||||
#define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(boost::is_same<v, x>::value == false){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
|
||||
#else
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(typeid(v) != typeid(x)){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
|
||||
#endif
|
||||
|
||||
struct empty_POD_UDT{};
|
||||
struct empty_UDT
|
||||
{
|
||||
|
||||
@ -6,6 +6,9 @@
|
||||
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// call_traits: defines typedefs for function usage
|
||||
// (see libs/utility/call_traits.htm)
|
||||
|
||||
/* Release notes:
|
||||
23rd July 2000:
|
||||
Fixed array specialization. (JM)
|
||||
@ -73,7 +76,7 @@ struct call_traits<T&>
|
||||
typedef T& param_type; // hh removed const
|
||||
};
|
||||
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x550)
|
||||
#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
|
||||
// these are illegal specialisations; cv-qualifies applied to
|
||||
// references have no effect according to [8.3.2p1],
|
||||
// C++ Builder requires them though as it treats cv-qualified
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
|
||||
// compressed_pair: pair that "compresses" empty members
|
||||
// (see libs/utility/compressed_pair.htm)
|
||||
//
|
||||
// JM changes 25 Jan 2000:
|
||||
// Removed default arguments from compressed_pair_switch to get
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
//
|
||||
// Crippled version for crippled compilers:
|
||||
// see libs/utility/call_traits.htm
|
||||
//
|
||||
#ifndef BOOST_OB_CALL_TRAITS_HPP
|
||||
#define BOOST_OB_CALL_TRAITS_HPP
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
// warranty, and with no claim as to its suitability for any purpose.
|
||||
|
||||
// See http://www.boost.org for most recent version including documentation.
|
||||
// see libs/utility/compressed_pair.hpp
|
||||
//
|
||||
/* Release notes:
|
||||
23rd July 2000:
|
||||
|
||||
@ -24,6 +24,7 @@
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <cstddef> // for size_t
|
||||
#include <utility> // for std::pair
|
||||
|
||||
namespace boost
|
||||
{
|
||||
@ -63,6 +64,32 @@ namespace boost
|
||||
const noncopyable& operator=( const noncopyable& );
|
||||
}; // noncopyable
|
||||
|
||||
// class tied -------------------------------------------------------//
|
||||
|
||||
// A helper for conveniently assigning the two values from a pair
|
||||
// into separate variables. The idea for this comes from Jaakko J<>rvi's
|
||||
// Binder/Lambda Library.
|
||||
|
||||
// Constributed by Jeremy Siek
|
||||
|
||||
template <class A, class B>
|
||||
class tied {
|
||||
public:
|
||||
inline tied(A& a, B& b) : _a(a), _b(b) { }
|
||||
template <class U, class V>
|
||||
inline tied& operator=(const std::pair<U,V>& p) {
|
||||
_a = p.first;
|
||||
_b = p.second;
|
||||
return *this;
|
||||
}
|
||||
protected:
|
||||
A& _a;
|
||||
B& _b;
|
||||
};
|
||||
|
||||
template <class A, class B>
|
||||
inline tied<A,B> tie(A& a, B& b) { return tied<A,B>(a, b); }
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UTILITY_HPP
|
||||
|
||||
45
iterator_adaptor_examples.cpp
Normal file
45
iterator_adaptor_examples.cpp
Normal file
@ -0,0 +1,45 @@
|
||||
// (C) Copyright Jeremy Siek 2000. 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 <functional>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <boost/iterator_adaptors.hpp>
|
||||
|
||||
int
|
||||
main(int, char*[])
|
||||
{
|
||||
// This is a simple example of using the transform_iterators class to
|
||||
// generate iterators that multiply the value returned by dereferencing
|
||||
// the iterator. In this case we are multiplying by 2.
|
||||
|
||||
int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
|
||||
typedef std::binder1st< std::multiplies<int> > Function;
|
||||
typedef boost::transform_iterator<Function, int*,
|
||||
boost::iterator<std::random_access_iterator_tag, int>
|
||||
>::type doubling_iterator;
|
||||
|
||||
doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
|
||||
i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));
|
||||
|
||||
std::cout << "multiplying the array by 2:" << std::endl;
|
||||
while (i != i_end)
|
||||
std::cout << *i++ << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
// Here is an example of counting from 0 to 5 using the integer_range class.
|
||||
|
||||
boost::integer_range<int> r(0,5);
|
||||
|
||||
std::cout << "counting to from 0 to 4:" << std::endl;
|
||||
std::copy(r.begin(), r.end(), std::ostream_iterator<int>(std::cout, " "));
|
||||
std::cout << std::endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
629
iterator_adaptors.htm
Normal file
629
iterator_adaptors.htm
Normal file
@ -0,0 +1,629 @@
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||
<title>Header boost/iterator_adaptors.hpp Documentation</title>
|
||||
</head>
|
||||
|
||||
<body bgcolor="#FFFFFF" text="#000000">
|
||||
|
||||
<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
|
||||
align="center" width="277" height="86">
|
||||
|
||||
<h1>Header
|
||||
<a href="../../boost/pending/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a></h1>
|
||||
|
||||
<p>The file <tt>boost/iterator_adaptors.hpp</tt>
|
||||
includes the main <tt>iterator_adaptors</tt> class and several other classes
|
||||
for constructing commonly used iterator adaptors.</p>
|
||||
|
||||
<ul>
|
||||
<li><a href="#iterator_adaptors"><tt>iterator_adaptors</tt></a>.
|
||||
<li><a href="#iterator_adaptor"><tt>iterator_adaptor</tt></a>.
|
||||
<li><a href="#transform_iterator"><tt>transform_iterator</tt></a>
|
||||
<li><a href="#indirect_iterators"><tt>indirect_iterators</tt></a>
|
||||
<li><a href="#reverse_iterators"><tt>reverse_iterators</tt></a>
|
||||
<li><a href="#integer_range"><tt>integer_range</tt></a>
|
||||
</ul>
|
||||
|
||||
|
||||
<!-- put in something about Andrei Alexandrescu's contribution? -->
|
||||
|
||||
<p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave
|
||||
Abrahams</a> started the library, coming up with the idea to use
|
||||
policy classes and how to handle the const/non-const iterator
|
||||
interactions. He also contributed the <tt>indirect_iterators</tt> and
|
||||
<tt>reverse_iterators</tt> classes.<br>
|
||||
|
||||
<a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
|
||||
contributed <tt>transform_iterator</tt>, <tt>integer_range</tt>,
|
||||
and this documentation.
|
||||
|
||||
<h3><a name="iterator_adaptors">The Iterator Adaptors Class</a></h3>
|
||||
|
||||
Implementing standard conforming iterators is a non-trivial task.
|
||||
There are some fine-points such as iterator/const_iterator
|
||||
interactions and there are the myriad of operators that should be
|
||||
implemented but are easily forgotten such as
|
||||
<tt>operator->()</tt>. The purpose of the
|
||||
<tt>iterator_adaptors</tt> class is to make it easier to implement an
|
||||
iterator class, and even easier to extend and adapt existing iterator
|
||||
types. The <tt>iterator_adaptors</tt> class itself is not an adaptor
|
||||
class but a <i>type generator</i>. It generates a pair of adaptor classes,
|
||||
one class for the mutable iterator and one class for the const
|
||||
iterator. The definition of the <tt>iterator_adaptors</tt> class is as
|
||||
follows:
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class Iterator,
|
||||
class ConstIterator,
|
||||
class Traits = std::iterator_traits<Iterator>,
|
||||
class ConstTraits = std::iterator_traits<ConstIterator>,
|
||||
class Policies = default_iterator_policies>
|
||||
struct iterator_adaptors
|
||||
{
|
||||
typedef ... iterator;
|
||||
typedef ... const_iterator;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<p>The <tt>Iterator</tt> and <tt>ConstIterator</tt> template parameters
|
||||
are the iterator types that you want to adapt. The <tt>Traits</tt> and
|
||||
<tt>ConstTraits</tt> must be iterator traits classes. The traits
|
||||
parameters default to the specialization of the
|
||||
<tt>std::iterator_traits</tt> class for the adapted iterators. If you
|
||||
want the traits for your new iterator adaptor (<tt>value_type</tt>,
|
||||
<tt>iterator_category</tt>, etc.) to be the same as the adapted
|
||||
iterator then use the default, otherwise create your own traits
|
||||
classes and pass them in <a href="#1">[1]</a>.
|
||||
|
||||
|
||||
<p>The <tt>Policies</tt> class that you pass in will become the heart of
|
||||
the iterator adaptor. The policy class determines how your new adaptor
|
||||
class will behave. The <tt>Policies</tt> class must implement 3, 4, or
|
||||
7 of the core iterator operations depending on whether you wish the
|
||||
new iterator adaptor class to be a
|
||||
<a href="http://www.sgi.com/Technology/STL/ForwardIterator.html">
|
||||
ForwardIterator</a>,
|
||||
<a href="http://www.sgi.com/Technology/STL/BidirectionalIterator.html">
|
||||
BidirectionalIterator</a>, or <a
|
||||
href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">
|
||||
RandomAccessIterator</a>. Make sure that the
|
||||
<tt>iterator_category</tt> type of the traits class you pass in
|
||||
matches the category of iterator that you want to create. The default
|
||||
policy class, <tt>default_iterator_policies</tt>, implements all 7 of
|
||||
the core operations in the usual way. If you wish to create an
|
||||
iterator adaptor that only changes a few of the iterator's behaviors,
|
||||
then you can have your new policy class inherit from
|
||||
<tt>default_iterator_policies</tt> to avoid retyping the usual
|
||||
behaviours. You should also look at <tt>default_iterator_policies</tt>
|
||||
as the "boiler-plate" for your own policy classes. The
|
||||
following is definition of the <tt>default_iterator_policies</tt>
|
||||
class:
|
||||
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
struct default_iterator_policies
|
||||
{
|
||||
// required for a ForwardIterator
|
||||
template <class Reference, class Iterator>
|
||||
Reference dereference(type<Reference>, const Iterator& x) const
|
||||
{ return *x; }
|
||||
|
||||
template <class Iterator>
|
||||
void increment(Iterator& x) const
|
||||
{ ++x; }
|
||||
|
||||
template <class Iterator1, class Iterator2>
|
||||
bool equal(Iterator1& x, Iterator2& y) const
|
||||
{ return x == y; }
|
||||
|
||||
// required for a BidirectionalIterator
|
||||
template <class Iterator>
|
||||
void decrement(Iterator& x) const
|
||||
{ --x; }
|
||||
|
||||
// required for a RandomAccessIterator
|
||||
template <class Iterator, class DifferenceType>
|
||||
void advance(Iterator& x, DifferenceType n) const
|
||||
{ x += n; }
|
||||
|
||||
template <class Difference, class Iterator1, class Iterator2>
|
||||
Difference distance(type<Difference>, Iterator1& x, Iterator2& y) const
|
||||
{ return y - x; }
|
||||
|
||||
template <class Iterator1, class Iterator2>
|
||||
bool less(Iterator1& x, Iterator2& y) const
|
||||
{ return x < y; }
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<p>
|
||||
The generated iterator adaptor types will have the following
|
||||
constructors.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
<i>iterator</i>(const Iterator& i, const Policies& p = Policies())
|
||||
|
||||
<i>const_iterator</i>(const ConstIterator& i, const Policies& p = Policies())
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<h3><a name="iterator_adaptor">The Iterator Adaptor Class</a></h3>
|
||||
|
||||
This is the class used inside of the <tt>iterator_adaptors</tt> type
|
||||
generator. Use this class directly (instead of using
|
||||
<tt>iterator_adaptors</tt>) when there is no difference between the
|
||||
const and non-const versions of the iterator type. Often this is
|
||||
because there is only a const (read-only) version of the iterator, as
|
||||
is the case for <tt>std::set</tt>'s iterators. Use the same type for
|
||||
the <tt>Iterator</tt> and <tt>NonconstIterator</tt> template
|
||||
arguments.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class Iterator,
|
||||
class Policies = default_iterator_policies,
|
||||
class NonconstIterator = Iterator,
|
||||
class Traits = std::iterator_traits<Iterator> >
|
||||
struct iterator_adaptor;
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
|
||||
<p>
|
||||
Next we will look at some iterator adaptors that are examples of how
|
||||
to use the iterator adaptors class, and that are useful iterator
|
||||
adaptors in their own right.
|
||||
|
||||
<h3><a name="transform_iterator">The Transform Iterator Class</a></h3>
|
||||
|
||||
It is often useful to automatically apply some function to the value
|
||||
returned by dereferencing (<tt>operator*()</tt>) an iterator. The
|
||||
<tt>transform_iterators</tt> class makes it easy to create an iterator
|
||||
adaptor that does just that.
|
||||
|
||||
First let us consider what the <tt>Policies</tt> class for the transform
|
||||
iterator should look like. We are only changing one of the iterator
|
||||
behaviours, so we will inherit from
|
||||
<tt>default_iterator_policies</tt>. In addition, we will need a
|
||||
function object to apply, so we will have a template parameter and a
|
||||
data member for the function object. The function will take one
|
||||
argument (the dereferenced value) and we will need to know the
|
||||
<tt>result_type</tt> of the function, so <a
|
||||
href="http://www.sgi.com/Technology/STL/AdaptableUnaryFunction.html">
|
||||
AdaptableUnaryFunction</a> is the corrent concept to choose for the
|
||||
function object type. Now for the heart of our iterator adaptor, we
|
||||
implement the <tt>dereference</tt> method, applying the function
|
||||
object to <tt>*i</tt>. The <tt>type<Reference></tt> class is
|
||||
there to tell you what the reference type of the iterator is, which is
|
||||
handy when writing generic iterator adaptors such as this one <a
|
||||
href="#2">[2]</a>.
|
||||
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class AdaptableUnaryFunction>
|
||||
struct transform_iterator_policies : public default_iterator_policies
|
||||
{
|
||||
transform_iterator_policies(const AdaptableUnaryFunction& f) : m_f(f) { }
|
||||
|
||||
template <class Reference, class Iterator>
|
||||
Reference dereference(type<Reference>, const Iterator& i) const
|
||||
{ return m_f(*i); }
|
||||
|
||||
AdaptableUnaryFunction m_f;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
Next we need to create the traits class for our new iterator. In some
|
||||
situations you may need to create a separate traits class for the
|
||||
const and non-const iterator types, but here a single traits class
|
||||
will do. The <tt>value_type</tt> and <tt>reference</tt> type of our
|
||||
transform iterator will be the <tt>result_type</tt> of the function
|
||||
object. The <tt>difference_type</tt> and <tt>iterator_category</tt>
|
||||
will be the same as the adapted iterator.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class AdaptableUnaryFunction, class IteratorTraits>
|
||||
struct transform_iterator_traits {
|
||||
typedef typename AdaptableUnaryFunction::result_type value_type;
|
||||
typedef value_type reference;
|
||||
typedef value_type* pointer;
|
||||
typedef typename IteratorTraits::difference_type difference_type;
|
||||
typedef typename IteratorTraits::iterator_category iterator_category;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
The final step is to use the <tt>iterator_adaptor</tt> class to
|
||||
construct our transform iterator. We will use the single iterator
|
||||
adaptor version because we will not need to create both a mutable and
|
||||
const version of the transform iterator. The transform iterator is
|
||||
inherently a read-only iterator. The nicest way to package up our new
|
||||
transform iterator is to create a type generator similar to
|
||||
<tt>iterator_adaptor</tt>. The first template parameter will be the
|
||||
type of the function object. The second parameter will be the adapted
|
||||
iterator type. The third parameter is the trait class for
|
||||
the adapted iterator. Inside the <tt>transform_iterators</tt> class
|
||||
we use the <tt>transform_iterator_traits</tt> class defined above to
|
||||
create the traits class for the new transform iterator. We then use
|
||||
the <tt>iterator_adaptor</tt> class to extract the generated
|
||||
iterator adaptor type.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class AdaptableUnaryFunction,
|
||||
class Iterator,
|
||||
class Traits = std::iterator_traits<Iterator>
|
||||
>
|
||||
struct transform_iterator
|
||||
{
|
||||
typedef transform_iterator_traits<AdaptableUnaryFunction,Traits>
|
||||
TransTraits;
|
||||
typedef iterator_adaptor<Iterator, TransTraits,
|
||||
transform_iterator_policies<AdaptableUnaryFunction> >::type type;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<p>
|
||||
The following is a simple example of how to use the
|
||||
<tt>transform_iterators</tt> class to iterate through a range of
|
||||
numbers, multiplying each of them by 2 when they are dereferenced.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
#include <functional>
|
||||
#include <iostream>
|
||||
#include <boost/iterator_adaptors.hpp>
|
||||
|
||||
int
|
||||
main(int, char*[])
|
||||
{
|
||||
int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
|
||||
|
||||
typedef std::binder1st< std::multiplies<int> > Function;
|
||||
typedef boost::transform_iterator<Function, int*,
|
||||
boost::iterator<std::random_access_iterator_tag, int>
|
||||
>::type doubling_iterator;
|
||||
|
||||
doubling_iterator i(x, std::bind1st(std::multiplies<int>(), 2)),
|
||||
i_end(x + sizeof(x)/sizeof(int), std::bind1st(std::multiplies<int>(), 2));
|
||||
|
||||
std::cout << "multiplying the array by 2:" << std::endl;
|
||||
while (i != i_end)
|
||||
std::cout << *i++ << " ";
|
||||
std::cout << std::endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
|
||||
<h3><a name="indirect_iterators">The Indirect Iterators Class</a></h3>
|
||||
|
||||
It is not all that uncommon to create data structures that consist of
|
||||
pointers to pointers. For such a structure it might be nice to have an
|
||||
iterator that applies a double-dereference inside the
|
||||
<tt>operator*()</tt>. The implementation of this is similar to the
|
||||
<tt>transform_iterators</tt><a href="#3">[3]</a>. We first create a
|
||||
policies class which does a double-dereference in the
|
||||
<tt>dereference()</tt> method. We then create a traits class, this
|
||||
time also including a template parameter for the traits of the second
|
||||
level iterators as well as the first. Lastly we wrap this up in the
|
||||
type generator <tt>indirect_iterators</tt>, using
|
||||
<tt>iterator_adaptors</tt> to do most of the work.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
struct indirect_iterator_policies : public default_iterator_policies
|
||||
{
|
||||
template <class Reference, class Iterator>
|
||||
Reference dereference(type<Reference>, const Iterator& x) const
|
||||
{ return **x; }
|
||||
};
|
||||
|
||||
template <class IndirectIterator,
|
||||
class IndirectTraits = std::iterator_traits<IndirectIterator>,
|
||||
class Traits =
|
||||
std::iterator_traits<typename IndirectTraits::value_type>
|
||||
>
|
||||
struct indirect_traits
|
||||
{
|
||||
typedef typename IndirectTraits::difference_type difference_type;
|
||||
typedef typename Traits::value_type value_type;
|
||||
typedef typename Traits::pointer pointer;
|
||||
typedef typename Traits::reference reference;
|
||||
typedef typename IndirectTraits::iterator_category iterator_category;
|
||||
};
|
||||
|
||||
template <class IndirectIterator, class ConstIndirectIterator,
|
||||
class IndirectTraits =
|
||||
std::iterator_traits<IndirectIterator>,
|
||||
class ConstIndirectTraits =
|
||||
std::iterator_traits<ConstIndirectIterator>,
|
||||
class Traits =
|
||||
std::iterator_traits<typename IndirectTraits::value_type>
|
||||
>
|
||||
struct indirect_iterators
|
||||
{
|
||||
typedef typename IndirectTraits::value_type Iterator;
|
||||
typedef typename Traits::value_type ValueType;
|
||||
typedef iterator_adaptors<IndirectIterator, ConstIndirectIterator,
|
||||
indirect_traits<IndirectIterator, IndirectTraits, Traits>,
|
||||
indirect_traits<ConstIndirectIterator, ConstIndirectTraits, Traits>,
|
||||
indirect_iterator_policies
|
||||
> Adaptors;
|
||||
typedef typename Adaptors::iterator iterator;
|
||||
typedef typename Adaptors::const_iterator const_iterator;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<h3><a name="reverse_iterators">The Reverse Iterators Class</a></h3>
|
||||
|
||||
<p>
|
||||
Yes, there is already a <tt>reverse_iterator</tt> adaptor class
|
||||
defined in the C++ Standard, but using the <tt>iterator_adaptors</tt>
|
||||
class we can re-implement this classic adaptor in a more succinct and
|
||||
elegant fashion. Also, this makes for a good example of using
|
||||
<tt>iterator_adaptors</tt> that is in familiar territory.
|
||||
|
||||
<p>
|
||||
The first step is to create the <tt>Policies</tt> class. As in the
|
||||
<tt>std::reverse_iterator</tt> class, we need to flip all the
|
||||
operations of the iterator. Increment will become decrement, advancing
|
||||
by <tt>n</tt> will become retreating by <tt>n</tt>, etc.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
struct reverse_iterator_policies
|
||||
{
|
||||
template <class Reference, class Iterator>
|
||||
Reference dereference(type<Reference>, const Iterator& x) const
|
||||
{ return *boost::prior(x); }
|
||||
// this is equivalent to { Iterator tmp = x; return *--tmp; }
|
||||
|
||||
template <class Iterator>
|
||||
void increment(Iterator& x) const
|
||||
{ --x; }
|
||||
|
||||
template <class Iterator>
|
||||
void decrement(Iterator& x) const
|
||||
{ ++x; }
|
||||
|
||||
template <class Iterator, class DifferenceType>
|
||||
void advance(Iterator& x, DifferenceType n) const
|
||||
{ x -= n; }
|
||||
|
||||
template <class Difference, class Iterator1, class Iterator2>
|
||||
Difference distance(type<Difference>, Iterator1& x, Iterator2& y) const
|
||||
{ return x - y; }
|
||||
|
||||
template <class Iterator1, class Iterator2>
|
||||
bool equal(Iterator1& x, Iterator2& y) const
|
||||
{ return x == y; }
|
||||
|
||||
template <class Iterator1, class Iterator2>
|
||||
bool less(Iterator1& x, Iterator2& y) const
|
||||
{ return y < x; }
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
Since the traits of the reverse iterator adaptor will be the same as
|
||||
the adapted iterator's traits, we do not need to create new traits
|
||||
classes as was the case for <tt>transform_iterator</tt>. We can skip to
|
||||
the final stage of creating a type generator class for our reverse
|
||||
iterators using the <tt>iterator_adaptor</tt> class.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class Iterator, class ConstIterator,
|
||||
class Traits = std::iterator_traits<Iterator>,
|
||||
class ConstTraits = std::iterator_traits<ConstIterator>
|
||||
>
|
||||
struct reverse_iterators
|
||||
{
|
||||
typedef iterator_adaptors<Iterator,ConstIterator,Traits,ConstTraits,
|
||||
reverse_iterator_policies> Adaptor;
|
||||
typedef typename Adaptor::iterator iterator;
|
||||
typedef typename Adaptor::const_iterator const_iterator;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
A typical use of the <tt>reverse_iterators</tt> class is in
|
||||
user-defined container types. You can use the
|
||||
<tt>reverse_iterators</tt> class to generate the reverse iterators for
|
||||
your container.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
class my_container {
|
||||
...
|
||||
typedef ... iterator;
|
||||
typedef ... const_iterator;
|
||||
|
||||
typedef reverse_iterators<iterator, const_iterator> RevIters;
|
||||
typedef typename RevIters::iterator reverse_iterator;
|
||||
typedef typename RevIters::const_iterator const_reverse_iterator;
|
||||
...
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
|
||||
<h3><a name="integer_range">The Integer Range Class</a></h3>
|
||||
|
||||
The <tt>iterator_adaptors</tt> class can not only be used for adapting
|
||||
iterators, but it can also be used to take a non-iterator type and use
|
||||
it to build an iterator. An especially simple example of this is
|
||||
turning an integer type into an iterator, a counting iterator. The
|
||||
builtin integer types of C++ are almost iterators. They have
|
||||
<tt>operator++()</tt>, <tt>operator--()</tt>, etc. The one operator
|
||||
they are lacking is the <tt>operator*()</tt>, which we will want to
|
||||
simply return the current value of the integer. The following few
|
||||
lines of code implement the policy and traits class for the counting
|
||||
iterator.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
struct counting_iterator_policies : public default_iterator_policies
|
||||
{
|
||||
template <class IntegerType>
|
||||
IntegerType dereference(type<IntegerType>, const IntegerType& i) const
|
||||
{ return i; }
|
||||
};
|
||||
template <class IntegerType>
|
||||
struct counting_iterator_traits {
|
||||
typedef IntegerType value_type;
|
||||
typedef IntegerType reference;
|
||||
typedef value_type* pointer;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef std::random_access_iterator_tag iterator_category;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
Typically we will want to count the integers in some range, so a nice
|
||||
interface would be to have a fake container that represents the range
|
||||
of integers. The following is the definition of such a class called
|
||||
<tt>integer_range</tt>.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
template <class IntegerType>
|
||||
struct integer_range {
|
||||
typedef typename iterator_adaptor<IntegerType,
|
||||
counting_iterator_traits<IntegerType>,
|
||||
counting_iterator_policies >::type iterator;
|
||||
typedef iterator const_iterator;
|
||||
typedef IntegerType value_type;
|
||||
typedef std::ptrdiff_t difference_type;
|
||||
typedef IntegerType reference;
|
||||
typedef IntegerType* pointer;
|
||||
typedef IntegerType size_type;
|
||||
|
||||
integer_range(IntegerType start, IntegerType finish)
|
||||
: m_start(start), m_finish(finish) { }
|
||||
|
||||
iterator begin() const { return iterator(m_start); }
|
||||
iterator end() const { return iterator(m_finish); }
|
||||
size_type size() const { return m_finish - m_start; }
|
||||
bool empty() const { return m_finish == m_start; }
|
||||
void swap(integer_range& x) {
|
||||
std::swap(m_start, x.m_start);
|
||||
std::swap(m_finish, x.m_finish);
|
||||
}
|
||||
protected:
|
||||
IntegerType m_start, m_finish;
|
||||
};
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<p>
|
||||
The following is an example of how to use the
|
||||
<tt>integer_range</tt> class to count from 0 to 4.
|
||||
|
||||
<p>
|
||||
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 COLS=2>
|
||||
<TR><TD WIDTH=30 VALIGN=TOP></TD><TD>
|
||||
<PRE>
|
||||
boost::integer_range<int> r(0,5);
|
||||
|
||||
cout << "counting to from 0 to 4:" << endl;
|
||||
std::copy(r.begin(), r.end(), ostream_iterator<int>(cout, " "));
|
||||
cout << endl;
|
||||
</PRE></TD></TABLE>
|
||||
|
||||
<h3>Challenge</h3>
|
||||
|
||||
<p>
|
||||
There is an unlimited number of ways the the
|
||||
<tt>iterator_adaptors</tt> class can be used to create iterators. One
|
||||
interesting exercise would be to re-implement the iterators of
|
||||
<tt>std::list</tt> and <tt>std::slist</tt> using
|
||||
<tt>iterator_adaptors</tt>, where the adapted <tt>Iterator</tt> types
|
||||
would be node pointers.
|
||||
|
||||
|
||||
<h3>Notes</h3>
|
||||
|
||||
<p>
|
||||
<a name="1">[1]</a>
|
||||
If your compiler does not support partial specialization and hence
|
||||
does not have a working <tt>std::iterator_traits</tt> class, you will
|
||||
not be able to use the defaults and will need to supply your own
|
||||
<tt>Traits</tt> and <tt>ConstTraits</tt> classes.
|
||||
|
||||
<p>
|
||||
<a name="2">[2]</a>
|
||||
The reference type could also be obtained from
|
||||
<tt>std::iterator_traits</tt>, but that is not portable on compilers
|
||||
that do not support partial specialization.
|
||||
|
||||
<p>
|
||||
<a name="3">[3]</a>
|
||||
It would have been more elegant to implement <tt>indirect_iterators</tt>
|
||||
using <tt>transform_iterators</tt>, but for subtle reasons that would require
|
||||
the use of <tt>boost::remove_cv</tt> which is not portable.
|
||||
|
||||
<h3>Implementation Notes</h3>
|
||||
|
||||
The code is somewhat complicated because there are three iterator
|
||||
adaptor class: <tt>forward_iterator_adaptor</tt>,
|
||||
<tt>bidirectional_iterator_adaptor</tt>, and
|
||||
<tt>random_access_iterator_adaptor</tt>. The alternative would be to
|
||||
just have one iterator adaptor equivalent to the
|
||||
<tt>random_access_iterator_adaptor</tt>. The reason for going with
|
||||
the three adaptors is that according to 14.5.3p5 in the C++ Standard,
|
||||
friend functions defined inside a template class body are instantiated
|
||||
when the template class is instantiated. This means that if we only
|
||||
used the one iterator adaptor, then if the adapted iterator did not
|
||||
meet all of the requirements for a
|
||||
<a href="http://www.sgi.com/Technology/STL/RandomAccessIterator.html">
|
||||
RandomAccessIterator</a> then a compiler error should occur. Many
|
||||
current compilers in fact do not instantiate the friend functions
|
||||
unless used, so we could get away with the one iterator adaptor in
|
||||
most cases. However, out of respect for the standard this implementation
|
||||
uses the three adaptors.
|
||||
|
||||
|
||||
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->17 Jun 2000<!--webbot bot="Timestamp" endspan i-checksum="15055" --></p>
|
||||
<p><EFBFBD> Copyright Jeremy Siek 2000. Permission to copy, use,
|
||||
modify, sell and distribute this document is granted provided this copyright
|
||||
notice appears in all copies. This document is provided "as is"
|
||||
without express or implied warranty, and with no claim as to its suitability for
|
||||
any purpose.</p>
|
||||
|
||||
</body>
|
||||
|
||||
</html>
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
|
||||
<a href="../../boost/operators.hpp">boost/operators.hpp</a></h1>
|
||||
<p>Header <a href="http://www.boost.org/boost/operators.hpp">boost/operators.hpp</a>
|
||||
<p>Header <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
|
||||
supplies (in namespace boost) several sets of templates:</p>
|
||||
<ul>
|
||||
<li><a href="#Arithmetic">Arithmetic operators</a>.
|
||||
@ -43,10 +43,10 @@ additional operators, such as operator>, <=, >=, and +. <a href="
|
||||
forms</a> of the templates are also provided to allow interaction with other
|
||||
types.</p>
|
||||
<p><a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>
|
||||
started the library and contributed the arithmetic operators in <a href="http://www.boost.org/boost/operators.hpp">boost/operators.hpp</a>.<br>
|
||||
started the library and contributed the arithmetic operators in <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
|
||||
<a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</a>
|
||||
contributed the <a href="#deref and helpers">dereference operators and iterator
|
||||
helpers</a> in <a href="http://www.boost.org/boost/operators.hpp">boost/operators.hpp</a>.<br>
|
||||
helpers</a> in <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>.<br>
|
||||
<a href="http://www.boost.org/people/aleksey_gurtovoy.htm">Aleksey Gurtovoy</a>
|
||||
contributed the code to support <a href="#chaining">base class chaining</a>
|
||||
while remaining backward-compatible with old versions of the library.<br>
|
||||
@ -60,7 +60,7 @@ x >= y,</code> and <code>x <= y</code>. Moreover, unless your class has
|
||||
really surprising behavior, some of these related operators can be defined in
|
||||
terms of others (e.g. <code>x >= y <b><=></b> !(x < y)</code>).
|
||||
Replicating this boilerplate for multiple classes is both tedious and
|
||||
error-prone. The <a href="http://www.boost.org/boost/operators.hpp">boost/operators.hpp</a>
|
||||
error-prone. The <a href="file:///c:/boost/site/boost/operators.hpp">boost/operators.hpp</a>
|
||||
templates help by generating operators for you at namespace scope based on other
|
||||
operators you've defined in your class.</p>
|
||||
<a name="two_arg">
|
||||
@ -585,7 +585,7 @@ complicated than the old one, we think it's worth it to make the library more
|
||||
useful in real world. Alexy Gurtovoy contributed the code which supports the new
|
||||
usage idiom while allowing the library remain backward-compatible.</p>
|
||||
<hr>
|
||||
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->28 Jun 2000<!--webbot bot="Timestamp" endspan i-checksum="15058" -->
|
||||
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->03 Aug 2000<!--webbot bot="Timestamp" endspan i-checksum="14750" -->
|
||||
</p>
|
||||
<p><EFBFBD> Copyright David Abrahams and Beman Dawes 1999-2000. Permission to copy,
|
||||
use, modify, sell and distribute this document is granted provided this
|
||||
|
||||
138
tie.html
Normal file
138
tie.html
Normal file
@ -0,0 +1,138 @@
|
||||
<HTML>
|
||||
<!--
|
||||
-- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
|
||||
--
|
||||
-- Permission to use, copy, modify, distribute and sell this software
|
||||
-- and its documentation for any purpose is hereby granted without fee,
|
||||
-- provided that the above copyright notice appears in all copies and
|
||||
-- that both that copyright notice and this permission notice appear
|
||||
-- in supporting documentation. We make no
|
||||
-- representations about the suitability of this software for any
|
||||
-- purpose. It is provided "as is" without express or implied warranty.
|
||||
-->
|
||||
<Head>
|
||||
<Title>Boost Tie</Title>
|
||||
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
|
||||
ALINK="#ff0000">
|
||||
<IMG SRC="../../c++boost.gif"
|
||||
ALT="C++ Boost">
|
||||
|
||||
<BR Clear>
|
||||
|
||||
<H1><A NAME="sec:tie"></A>
|
||||
<TT>tie</TT>
|
||||
</H1>
|
||||
|
||||
<P>
|
||||
<PRE>
|
||||
template <class A, class B>
|
||||
tied<A,B> tie(A& a, B& b);
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
This is a utility function that makes it more convenient to work with
|
||||
a function which returns a pair. The effect of the <TT>tie()</TT>
|
||||
function is to allow the assignment of the two values of the pair to
|
||||
two separate variables. The idea for this comes from Jaakko
|
||||
Järvi's Binders [<A
|
||||
HREF="bibliography.html#jaakko_tuple_assign">1</A>].
|
||||
|
||||
<P>
|
||||
|
||||
<H3>Where Defined</H3>
|
||||
|
||||
<P>
|
||||
<a href="../../boost/utility.hpp"><TT>boost/utility.hpp</TT></a>
|
||||
|
||||
<P>
|
||||
|
||||
<H3>Example</H3>
|
||||
|
||||
<P>
|
||||
An example of using the <TT>tie()</TT> function with the
|
||||
<TT>vertices()</TT> function, which returns a pair of
|
||||
type <TT>std::pair<vertex_iterator,vertex_iterator></TT>. The
|
||||
pair of iterators is assigned to the iterator variables <TT>i</TT> and
|
||||
<TT>end</TT>.
|
||||
|
||||
<P>
|
||||
<PRE>
|
||||
graph_traits< adjacency_list<> >::vertex_iterator i, end;
|
||||
for(tie(i,end) = vertices(G); i != end; ++i)
|
||||
// ...
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
Here is another example that uses <TT>tie()</TT> for handling
|
||||
operaitons with <a
|
||||
href="http://www.sgi.com/Technology/STL/set.html"><TT>std::set</TT></a>.
|
||||
|
||||
<P>
|
||||
<PRE>
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
int
|
||||
main(int, char*[])
|
||||
{
|
||||
{
|
||||
typedef std::set<int> SetT;
|
||||
SetT::iterator i, end;
|
||||
bool inserted;
|
||||
|
||||
int vals[5] = { 5, 2, 4, 9, 1 };
|
||||
SetT s(vals, vals + 5);
|
||||
|
||||
// Using tie() with a return value of pair<iterator,bool>
|
||||
|
||||
int new_vals[2] = { 3, 9 };
|
||||
|
||||
for (int k = 0; k < 2; ++k) {
|
||||
boost::tie(i,inserted) = s.insert(new_vals[k]);
|
||||
if (!inserted)
|
||||
std::cout << *i << " was already in the set." << std::endl;
|
||||
else
|
||||
std::cout << *i << " successfully inserted." << std::endl;
|
||||
}
|
||||
}
|
||||
{
|
||||
int* i, *end;
|
||||
int vals[6] = { 5, 2, 4, 4, 9, 1 };
|
||||
std::sort(vals, vals + 6);
|
||||
|
||||
// Using tie() with a return value of pair<iterator,iterator>
|
||||
|
||||
boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
|
||||
std::cout << "There were " << std::distance(i,end)
|
||||
<< " occurances of " << *i << "." << std::endl;
|
||||
// Footnote: of course one would normally just use std::count()
|
||||
// to get this information, but that would spoil the example :)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
</PRE>
|
||||
The output is:
|
||||
<PRE>
|
||||
3 successfully inserted.
|
||||
9 was already in the set.
|
||||
There were 2 occurances of 4.
|
||||
</PRE>
|
||||
|
||||
<br>
|
||||
<HR>
|
||||
<TABLE>
|
||||
<TR valign=top>
|
||||
<TD nowrap>Copyright © 2000</TD><TD>
|
||||
<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
|
||||
Univ.of Notre Dame (<A
|
||||
HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
|
||||
<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
|
||||
<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
|
||||
Univ.of Notre Dame (<A
|
||||
HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
|
||||
</TD></TR></TABLE>
|
||||
|
||||
</BODY>
|
||||
</HTML>
|
||||
61
tie_example.cpp
Normal file
61
tie_example.cpp
Normal file
@ -0,0 +1,61 @@
|
||||
// (C) Copyright Jeremy Siek 2000. 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.
|
||||
//
|
||||
// This is an example demonstrating how to use the tie() function.
|
||||
// The purpose of tie() is to make it easiery to deal with std::pair
|
||||
// return values.
|
||||
//
|
||||
// Contributed by Jeremy Siek
|
||||
//
|
||||
// Sample output
|
||||
//
|
||||
// 3 successfully inserted.
|
||||
// 9 was already in the set.
|
||||
// There were 2 occurances of 4.
|
||||
|
||||
#include <set>
|
||||
#include <algorithm>
|
||||
#include <iostream>
|
||||
#include <boost/utility.hpp>
|
||||
|
||||
int
|
||||
main(int, char*[])
|
||||
{
|
||||
{
|
||||
typedef std::set<int> SetT;
|
||||
SetT::iterator i, end;
|
||||
bool inserted;
|
||||
|
||||
int vals[5] = { 5, 2, 4, 9, 1 };
|
||||
SetT s(vals, vals + 5);
|
||||
|
||||
// Using tie() with a return value of pair<iterator,bool>
|
||||
|
||||
int new_vals[2] = { 3, 9 };
|
||||
|
||||
for (int k = 0; k < 2; ++k) {
|
||||
boost::tie(i,inserted) = s.insert(new_vals[k]);
|
||||
if (!inserted)
|
||||
std::cout << *i << " was already in the set." << std::endl;
|
||||
else
|
||||
std::cout << *i << " successfully inserted." << std::endl;
|
||||
}
|
||||
}
|
||||
{
|
||||
int* i, *end;
|
||||
int vals[6] = { 5, 2, 4, 4, 9, 1 };
|
||||
std::sort(vals, vals + 6);
|
||||
|
||||
// Using tie() with a return value of pair<iterator,iterator>
|
||||
|
||||
boost::tie(i,end) = std::equal_range(vals, vals + 6, 4);
|
||||
std::cout << "There were " << std::distance(i,end)
|
||||
<< " occurances of " << *i << "." << std::endl;
|
||||
// Footnote: of course one would normally just use std::count()
|
||||
// to get this information, but that would spoil the example :)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -25,6 +25,7 @@ divided up into the following sections:</p>
|
||||
|
||||
<pre><a href="#fop">Fundamental type operations</a>
|
||||
<a href="#fp">Fundamental type properties</a>
|
||||
<a href="#misc">Miscellaneous</a>
|
||||
<code> </code><a href="#cv">cv-Qualifiers</a>
|
||||
<code> </code><a href="#ft">Fundamental Types</a>
|
||||
<code> </code><a href="#ct">Compound Types</a>
|
||||
@ -37,7 +38,7 @@ divided up into the following sections:</p>
|
||||
<p>Usage: "class_name<T>::type" performs
|
||||
indicated transformation on type T.</p>
|
||||
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="624">
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="45%"><p align="center">Expression.</p>
|
||||
</td>
|
||||
@ -108,39 +109,75 @@ indicated transformation on type T.</p>
|
||||
indicated property is true, false otherwise. (Note that class_name<T>::value
|
||||
is always defined as a compile time constant).</p>
|
||||
|
||||
<h3><a name="misc"></a>Miscellaneous</h3>
|
||||
|
||||
<table border="1" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td width="37%"><p align="center">Expression</p>
|
||||
</td>
|
||||
<td width="36%"><p align="center">Description</p>
|
||||
</td>
|
||||
<td width="27%"><p align="center">Compiler</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="37%"><div align="center"><center><pre><code>is_same<T,U>::value</code></pre>
|
||||
</center></div></td>
|
||||
<td width="36%"><p align="center">True if T and U are the
|
||||
same type.</p>
|
||||
</td>
|
||||
<td width="27%"><p align="center">P</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="37%"><div align="center"><center><pre>is_convertible<T,U>::value</pre>
|
||||
</center></div></td>
|
||||
<td width="36%"><p align="center">True if type T is
|
||||
convertible to type U.</p>
|
||||
</td>
|
||||
<td width="27%"> </td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="37%"><div align="center"><center><pre>alignment_of<T>::value</pre>
|
||||
</center></div></td>
|
||||
<td width="36%"><p align="center">An integral value
|
||||
representing the minimum alignment requirements of type T
|
||||
(strictly speaking defines a multiple of the type's
|
||||
alignment requirement; for all compilers tested so far
|
||||
however it does return the actual alignment).</p>
|
||||
</td>
|
||||
<td width="27%"> </td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p> </p>
|
||||
|
||||
<h3><a name="cv"></a>cv-Qualifiers</h3>
|
||||
|
||||
<p>The following classes determine what cv-qualifiers are present
|
||||
on a type (see 3.93).</p>
|
||||
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="624">
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="45%"><p align="center">Expression.</p>
|
||||
<td valign="top" width="37%"><p align="center">Expression.</p>
|
||||
</td>
|
||||
<td valign="top" width="45%"><p align="center">Description.</p>
|
||||
<td valign="top" width="37%"><p align="center">Description.</p>
|
||||
</td>
|
||||
<td valign="top" width="33%"><p align="center">Compiler.</p>
|
||||
<td valign="top" width="27%"><p align="center">Compiler.</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" width="45%"><code>is_const<T>::value</code></td>
|
||||
<td valign="top" width="45%">True if type T is top-level
|
||||
<td valign="top" width="37%"><code>is_const<T>::value</code></td>
|
||||
<td valign="top" width="37%">True if type T is top-level
|
||||
const qualified.</td>
|
||||
<td valign="top" width="33%"><p align="center">P</p>
|
||||
<td valign="top" width="27%"><p align="center">P</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" width="45%"><code>is_volatile<T>::value</code></td>
|
||||
<td valign="top" width="45%">True if type T is top-level
|
||||
<td valign="top" width="37%"><code>is_volatile<T>::value</code></td>
|
||||
<td valign="top" width="37%">True if type T is top-level
|
||||
volatile qualified.</td>
|
||||
<td valign="top" width="33%"><p align="center">P</p>
|
||||
</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td valign="top" width="45%"><code>is_same<T,U>::value</code></td>
|
||||
<td valign="top" width="45%">True if T and U are the same
|
||||
type.</td>
|
||||
<td valign="top" width="33%"><p align="center">P</p>
|
||||
<td valign="top" width="27%"><p align="center">P</p>
|
||||
</td>
|
||||
</tr>
|
||||
</table>
|
||||
@ -152,7 +189,7 @@ on a type (see 3.93).</p>
|
||||
<p>The following will only ever be true for cv-unqualified types;
|
||||
these are closely based on the section 3.9 of the C++ Standard.</p>
|
||||
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="624">
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="45%"><p align="center">Expression.</p>
|
||||
</td>
|
||||
@ -291,7 +328,7 @@ these are closely based on the section 3.9 of the C++ Standard.</p>
|
||||
<p>The following will only ever be true for cv-unqualified types,
|
||||
as defined by the Standard. </p>
|
||||
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="624">
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="45%"><p align="center">Expression</p>
|
||||
</td>
|
||||
@ -365,7 +402,7 @@ as defined by the Standard. </p>
|
||||
is true then <code>class_name<cv-qualified-T>::value</code>
|
||||
will also be true.</p>
|
||||
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="624">
|
||||
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||
<tr>
|
||||
<td valign="top" width="45%"><p align="center">Expression</p>
|
||||
</td>
|
||||
@ -420,9 +457,10 @@ will also be true.</p>
|
||||
or class. If the compiler implements the "zero sized
|
||||
empty base classes" optimisation, then is_empty will
|
||||
correctly guess whether T is empty. Relies upon is_class
|
||||
to determine whether T is a class type - as a result will
|
||||
not compile when passed an enumerated type unless there
|
||||
is compiler support for is_enum.</td>
|
||||
to determine whether T is a class type. Screens out enum
|
||||
types by using is_convertible<T,int>, this means
|
||||
that empty classes that overload operator int(), will not
|
||||
be classified as empty.</td>
|
||||
<td valign="top" width="33%"><p align="center">PCD</p>
|
||||
</td>
|
||||
</tr>
|
||||
@ -582,7 +620,7 @@ Hinnant and John Maddock.</p>
|
||||
|
||||
<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
|
||||
Maddock</a>, the latest version of this file can be found at <a
|
||||
href="http://www.boost.org">www.boost.org</a>, and the boost
|
||||
href="http://www.boost.org/">www.boost.org</a>, and the boost
|
||||
discussion list at <a href="http://www.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
@ -4,7 +4,11 @@
|
||||
// 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.
|
||||
|
||||
// standalone test program for <boost/type_traits.hpp>
|
||||
|
||||
/* Release notes:
|
||||
31st July 2000:
|
||||
Added extra tests for is_empty, is_convertible, alignment_of.
|
||||
23rd July 2000:
|
||||
Removed all call_traits tests to call_traits_test.cpp
|
||||
Removed all compressed_pair tests to compressed_pair_tests.cpp
|
||||
@ -16,37 +20,10 @@
|
||||
#include <typeinfo>
|
||||
|
||||
#include <boost/type_traits.hpp>
|
||||
#include "type_traits_test.hpp"
|
||||
|
||||
using namespace boost;
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma option -w-ccc -w-rch -w-eff -w-aus
|
||||
#endif
|
||||
|
||||
//
|
||||
// define tests here
|
||||
unsigned failures = 0;
|
||||
unsigned test_count = 0;
|
||||
|
||||
#define value_test(v, x) ++test_count;\
|
||||
if(v != x){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
|
||||
#define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(is_same<v, x>::value == false){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << typeid(is_same<v, x>).name() << "::value is false" << std::endl; }
|
||||
#else
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(typeid(v) != typeid(x)){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
|
||||
#endif
|
||||
|
||||
// Since there is no compiler support, we should specialize:
|
||||
// is_enum for all enumerations (is_enum implies is_POD)
|
||||
// is_union for all unions
|
||||
@ -160,6 +137,33 @@ template <> struct is_POD<empty_POD_union_UDT>
|
||||
}
|
||||
#endif
|
||||
|
||||
class Base { };
|
||||
|
||||
class Deriverd : public Base { };
|
||||
|
||||
class NonDerived { };
|
||||
|
||||
enum enum1
|
||||
{
|
||||
one_,two_
|
||||
};
|
||||
|
||||
enum enum2
|
||||
{
|
||||
three_,four_
|
||||
};
|
||||
|
||||
struct VB
|
||||
{
|
||||
virtual ~VB(){};
|
||||
};
|
||||
|
||||
struct VD : VB
|
||||
{
|
||||
~VD(){};
|
||||
};
|
||||
|
||||
|
||||
// Steve: All comments that I (Steve Cleary) have added below are prefixed with
|
||||
// "Steve:" The failures that BCB4 has on the tests are due to Borland's
|
||||
// not considering cv-qual's as a part of the type -- they are considered
|
||||
@ -530,6 +534,57 @@ int main()
|
||||
value_test(false, is_POD<empty_UDT>::value)
|
||||
value_test(true, is_POD<enum_UDT>::value)
|
||||
|
||||
value_test(true, (boost::is_convertible<Deriverd,Base>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||
value_test(true, (boost::is_convertible<Base,Base>::value));
|
||||
value_test(false, (boost::is_convertible<Base,Deriverd>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||
value_test(false, (boost::is_convertible<NonDerived,Base>::value));
|
||||
//value_test(false, (boost::is_convertible<boost::noncopyable, boost::noncopyable>::value));
|
||||
value_test(true, (boost::is_convertible<float,int>::value));
|
||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||
value_test(false, (boost::is_convertible<float,void>::value));
|
||||
value_test(false, (boost::is_convertible<void,float>::value));
|
||||
value_test(true, (boost::is_convertible<void,void>::value));
|
||||
#endif
|
||||
value_test(true, (boost::is_convertible<enum1, int>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
|
||||
value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
|
||||
value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
|
||||
value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
|
||||
value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
|
||||
value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
|
||||
value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
|
||||
value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
|
||||
|
||||
value_test(false, (boost::is_convertible<const int *, int*>::value));
|
||||
value_test(false, (boost::is_convertible<const int&, int&>::value));
|
||||
value_test(false, (boost::is_convertible<int*, int[2]>::value));
|
||||
value_test(false, (boost::is_convertible<const int*, int[3]>::value));
|
||||
value_test(true, (boost::is_convertible<const int&, int>::value));
|
||||
value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
|
||||
value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
|
||||
value_test(true, (boost::is_convertible<int *, const int*>::value));
|
||||
value_test(true, (boost::is_convertible<int&, const int&>::value));
|
||||
value_test(true, (boost::is_convertible<int[2], int*>::value));
|
||||
value_test(true, (boost::is_convertible<int[2], const int*>::value));
|
||||
value_test(false, (boost::is_convertible<const int[2], int*>::value));
|
||||
|
||||
align_test(int);
|
||||
align_test(char);
|
||||
align_test(double);
|
||||
align_test(int[4]);
|
||||
align_test(int(*)(int));
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
align_test(char&);
|
||||
align_test(char (&)(int));
|
||||
align_test(char(&)[4]);
|
||||
#endif
|
||||
align_test(int*);
|
||||
//align_test(const int);
|
||||
align_test(VB);
|
||||
align_test(VD);
|
||||
|
||||
std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
|
||||
std::cin.get();
|
||||
return failures;
|
||||
|
||||
106
type_traits_test.hpp
Normal file
106
type_traits_test.hpp
Normal file
@ -0,0 +1,106 @@
|
||||
// boost::compressed_pair test program
|
||||
|
||||
// (C) Copyright John Maddock 2000. 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.
|
||||
|
||||
// common test code for type_traits_test.cpp/call_traits_test.cpp/compressed_pair_test.cpp
|
||||
|
||||
|
||||
#ifndef BOOST_TYPE_TRAITS_TEST_HPP
|
||||
#define BOOST_TYPE_TRAITS_TEST_HPP
|
||||
|
||||
//
|
||||
// this one is here just to suppress warnings:
|
||||
//
|
||||
template <class T>
|
||||
bool do_compare(T i, T j)
|
||||
{
|
||||
return i == j;
|
||||
}
|
||||
|
||||
//
|
||||
// this one is to verify that a constant is indeed a
|
||||
// constant-integral-expression:
|
||||
//
|
||||
template <int>
|
||||
struct ct_checker
|
||||
{
|
||||
};
|
||||
|
||||
#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
|
||||
#define BOOST_DO_JOIN2(X, Y) X ## Y
|
||||
#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
|
||||
|
||||
|
||||
#define value_test(v, x) ++test_count;\
|
||||
typedef ct_checker<(x)> BOOST_JOIN(this_is_a_compile_time_check_, __LINE__);\
|
||||
if(!do_compare((int)v,(int)x)){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
|
||||
#define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
|
||||
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(do_compare(boost::is_same<v, x>::value, false)){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
|
||||
#else
|
||||
#define type_test(v, x) ++test_count;\
|
||||
if(typeid(v) != typeid(x)){\
|
||||
++failures; \
|
||||
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||
std::cout << " expected type was " << #v << std::endl; \
|
||||
std::cout << " " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
|
||||
#endif
|
||||
|
||||
template <class T>
|
||||
struct test_align
|
||||
{
|
||||
struct padded
|
||||
{
|
||||
char c;
|
||||
T t;
|
||||
};
|
||||
static void do_it()
|
||||
{
|
||||
padded p;
|
||||
unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
|
||||
value_test(a, boost::alignment_of<T>::value);
|
||||
}
|
||||
};
|
||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
template <class T>
|
||||
struct test_align<T&>
|
||||
{
|
||||
static void do_it()
|
||||
{
|
||||
//
|
||||
// we can't do the usual test because we can't take the address
|
||||
// of a reference, so check that the result is the same as for a
|
||||
// pointer type instead:
|
||||
value_test(boost::alignment_of<T*>::value, boost::alignment_of<T&>::value);
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#define align_test(T) test_align<T>::do_it()
|
||||
|
||||
//
|
||||
// define tests here
|
||||
unsigned failures = 0;
|
||||
unsigned test_count = 0;
|
||||
|
||||
//
|
||||
// turn off some warnings:
|
||||
#ifdef __BORLANDC__
|
||||
#pragma option -w-8004
|
||||
#endif
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning (disable: 4018)
|
||||
#endif
|
||||
|
||||
|
||||
#endif // BOOST_TYPE_TRAITS_TEST_HPP
|
||||
Reference in New Issue
Block a user