[boost-doc-zh] r409 committed - 翻译 type_traits 库的 qbk 文件并生成 html 目录

Revision: 409
Author: alai04
Date: Wed Jun  2 00:58:52 2010
Log: 翻译 type_traits 库的 qbk 文件并生成 html 目录
http://code.google.com/p/boost-doc-zh/source/detail?r=409

Added:
 /trunk/libs/type_traits/doc/html/boost_typetraits/history.html
Modified:
 /trunk/libs/type_traits/doc/add_const.qbk
 /trunk/libs/type_traits/doc/add_cv.qbk
 /trunk/libs/type_traits/doc/add_pointer.qbk
 /trunk/libs/type_traits/doc/add_reference.qbk
 /trunk/libs/type_traits/doc/add_volatile.qbk
 /trunk/libs/type_traits/doc/aligned_storage.qbk
 /trunk/libs/type_traits/doc/alignment_of.qbk
 /trunk/libs/type_traits/doc/alignment_traits.qbk
 /trunk/libs/type_traits/doc/background.qbk
 /trunk/libs/type_traits/doc/credits.qbk
 /trunk/libs/type_traits/doc/decay.qbk
 /trunk/libs/type_traits/doc/decomposing_func.qbk
 /trunk/libs/type_traits/doc/examples.qbk
 /trunk/libs/type_traits/doc/extent.qbk
 /trunk/libs/type_traits/doc/floating_point_promotion.qbk
 /trunk/libs/type_traits/doc/function_traits.qbk
 /trunk/libs/type_traits/doc/has_new_operator.qbk
 /trunk/libs/type_traits/doc/has_nothrow_assign.qbk
 /trunk/libs/type_traits/doc/has_nothrow_constructor.qbk
 /trunk/libs/type_traits/doc/has_nothrow_copy.qbk
 /trunk/libs/type_traits/doc/has_trivial_assign.qbk
 /trunk/libs/type_traits/doc/has_trivial_constructor.qbk
 /trunk/libs/type_traits/doc/has_trivial_copy.qbk
 /trunk/libs/type_traits/doc/has_trivial_destructor.qbk
 /trunk/libs/type_traits/doc/has_virtual_destructor.qbk
 /trunk/libs/type_traits/doc/history.qbk
 /trunk/libs/type_traits/doc/html/boost_typetraits/background.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html
/trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/category.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/credits.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/examples.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/intro.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_volatile.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/aligned_storage.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/alignment_of.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/decay.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/extent.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/floating_point_promotion.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_new_operator.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_no_throw_def_cons.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_assign.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_constructor.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_copy.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_nothrow_cp_cons.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_assign.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_constructor.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_copy.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_cp_cons.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_def_cons.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_trivial_destructor.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/has_virtual_destructor.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_constant.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/integral_promotion.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_abstract.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_arithmetic.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_array.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_base_of.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_class.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_complex.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_compound.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_const.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_convertible.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_empty.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_enum.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_floating_point.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_function.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_fundamental.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_integral.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_function_pointer.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_object_pointer.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_member_pointer.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_object.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pod.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_pointer.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_polymorphic.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_reference.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_same.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_scalar.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_signed.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_stateless.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_union.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_unsigned.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_virtual_base_of.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_void.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/is_volatile.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/make_signed.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/make_unsigned.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/promote.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/rank.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_all_extents.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_const.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_cv.html
/trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_extent.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_pointer.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_reference.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/remove_volatile.html /trunk/libs/type_traits/doc/html/boost_typetraits/reference/type_with_alignment.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/reference.html
 /trunk/libs/type_traits/doc/html/boost_typetraits/user_defined.html
 /trunk/libs/type_traits/doc/html/index.html
 /trunk/libs/type_traits/doc/integral_constant.qbk
 /trunk/libs/type_traits/doc/integral_promotion.qbk
 /trunk/libs/type_traits/doc/intrinsics.qbk
 /trunk/libs/type_traits/doc/is_abstract.qbk
 /trunk/libs/type_traits/doc/is_arithmetic.qbk
 /trunk/libs/type_traits/doc/is_array.qbk
 /trunk/libs/type_traits/doc/is_base_of.qbk
 /trunk/libs/type_traits/doc/is_class.qbk
 /trunk/libs/type_traits/doc/is_complex.qbk
 /trunk/libs/type_traits/doc/is_compound.qbk
 /trunk/libs/type_traits/doc/is_const.qbk
 /trunk/libs/type_traits/doc/is_convertible.qbk
 /trunk/libs/type_traits/doc/is_empty.qbk
 /trunk/libs/type_traits/doc/is_enum.qbk
 /trunk/libs/type_traits/doc/is_floating_point.qbk
 /trunk/libs/type_traits/doc/is_function.qbk
 /trunk/libs/type_traits/doc/is_fundamental.qbk
 /trunk/libs/type_traits/doc/is_integral.qbk
 /trunk/libs/type_traits/doc/is_member_function_pointer.qbk
 /trunk/libs/type_traits/doc/is_member_object_pointer.qbk
 /trunk/libs/type_traits/doc/is_member_pointer.qbk
 /trunk/libs/type_traits/doc/is_object.qbk
 /trunk/libs/type_traits/doc/is_pod.qbk
 /trunk/libs/type_traits/doc/is_pointer.qbk
 /trunk/libs/type_traits/doc/is_polymorphic.qbk
 /trunk/libs/type_traits/doc/is_reference.qbk
 /trunk/libs/type_traits/doc/is_same.qbk
 /trunk/libs/type_traits/doc/is_scalar.qbk
 /trunk/libs/type_traits/doc/is_signed.qbk
 /trunk/libs/type_traits/doc/is_stateless.qbk
 /trunk/libs/type_traits/doc/is_union.qbk
 /trunk/libs/type_traits/doc/is_unsigned.qbk
 /trunk/libs/type_traits/doc/is_virtual_base_of.qbk
 /trunk/libs/type_traits/doc/is_void.qbk
 /trunk/libs/type_traits/doc/is_volatile.qbk
 /trunk/libs/type_traits/doc/make_signed.qbk
 /trunk/libs/type_traits/doc/make_unsigned.qbk
 /trunk/libs/type_traits/doc/mpl.qbk
 /trunk/libs/type_traits/doc/promote.qbk
 /trunk/libs/type_traits/doc/rank.qbk
 /trunk/libs/type_traits/doc/remove_all_extents.qbk
 /trunk/libs/type_traits/doc/remove_const.qbk
 /trunk/libs/type_traits/doc/remove_cv.qbk
 /trunk/libs/type_traits/doc/remove_extent.qbk
 /trunk/libs/type_traits/doc/remove_pointer.qbk
 /trunk/libs/type_traits/doc/remove_reference.qbk
 /trunk/libs/type_traits/doc/remove_volatile.qbk
 /trunk/libs/type_traits/doc/transform_traits.qbk
 /trunk/libs/type_traits/doc/type_traits.qbk
 /trunk/libs/type_traits/doc/type_with_alignment.qbk
 /trunk/libs/type_traits/doc/user_defined.qbk
 /trunk/libs/type_traits/doc/value_traits.qbk

=======================================
--- /dev/null
+++ /trunk/libs/type_traits/doc/html/boost_typetraits/history.html Wed Jun 2 00:58:52 2010
@@ -0,0 +1,54 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>History &#21382;&#21490;</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="reference/type_with_alignment.html" title="type_with_alignment">
+<link rel="next" href="credits.html" title="Credits &#33635;&#35465;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="credits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.history"></a><a class="link" href="history.html" title="History &#21382;&#21490;"> History &#21382;&#21490;</a>
+</h2></div></div></div>
+<a name="boost_typetraits.history.boost_1_42_0"></a><h5>
+<a name="id4915901"></a>
+ <a class="link" href="history.html#boost_typetraits.history.boost_1_42_0">Boost 1.42.0</a>
+    </h5>
+<div class="itemizedlist"><ul type="disc"><li>
+ Fixed issue <a href="https://svn.boost.org/trac/boost/ticket/3704"; target="_top">#3704</a>.<br> + &#20462;&#22797;&#38382;&#39064; <a href="https://svn.boost.org/trac/boost/ticket/3704"; target="_top">#3704</a>.
+      </li></ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, + Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat + Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
+      Ramey and Jeremy Siek<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="credits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>
=======================================
--- /trunk/libs/type_traits/doc/add_const.qbk   Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/add_const.qbk   Wed Jun  2 00:58:52 2010
@@ -13,19 +13,21 @@
       typedef __below type;
    };

-__type The same type as `T const` for all `T`.
+__type The same type as `T const` for all `T`.  \n
+__type 对于所有的 `T` 与 `T const` 类型相同。

 __std_ref 3.9.3.

__compat If the compiler does not support partial specialization of class-templates then this template will compile, but the member `type` will always be the same as
-type `T` except where __transform_workaround have been applied.
+type `T` except where __transform_workaround have been applied.\n
+__compat 如果编译器不支持类模板的偏特化,这个模板也可以编译,但是成员 `type` 总是和 `T` 类型相同,除非 __transform_workaround 可用。

__header ` #include <boost/type_traits/add_const.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`add_const<int>::type`][`int const`]]

=======================================
--- /trunk/libs/type_traits/doc/add_cv.qbk      Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/add_cv.qbk      Wed Jun  2 00:58:52 2010
@@ -13,19 +13,21 @@
       typedef __below type;
    };

-__type The same type as `T const volatile` for all `T`.
+__type The same type as `T const volatile` for all `T`.  \n
+__type 对于所有的 `T` 与 `T const volatile` 类型相同。

 __std_ref 3.9.3.

__compat If the compiler does not support partial specialization of class-templates then this template will compile, but the member `type` will always be the same as
-type `T` except where __transform_workaround have been applied.
+type `T` except where __transform_workaround have been applied.\n
+__compat 如果编译器不支持类模板的偏特化,这个模板也可以编译,但是成员 `type` 总是和 `T` 类型相同,除非 __transform_workaround 可用。

__header ` #include <boost/type_traits/add_cv.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`add_cv<int>::type`][`int const volatile`]]

=======================================
--- /trunk/libs/type_traits/doc/add_pointer.qbk Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/add_pointer.qbk Wed Jun  2 00:58:52 2010
@@ -13,23 +13,26 @@
       typedef __below type;
    };

-__type The same type as `remove_reference<T>::type*`.
+__type The same type as `remove_reference<T>::type*`.  \n
+__type 与 `remove_reference<T>::type*` 类型相同。

 The rationale for this template
 is that it produces the same type as `TYPEOF(&t)`,
-where `t` is an object of type `T`.
+where `t` is an object of type `T`.\n
+这个模板的基本原理是:当 `t` 是类型 `T` 的一个对象时,它生成和 `TYPEOF(&t)` 一样的类型。

 __std_ref 8.3.1.

__compat If the compiler does not support partial specialization of class-templates then this template will compile, but the member `type` will always be the same as
-type `T` except where __transform_workaround have been applied.
+type `T` except where __transform_workaround have been applied.\n
+__compat 如果编译器不支持类模板的偏特化,这个模板也可以编译,但是成员 `type` 总是和 `T` 类型相同,除非 __transform_workaround 可用。

__header ` #include <boost/type_traits/add_pointer.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`add_pointer<int>::type`][`int*`]]

=======================================
--- /trunk/libs/type_traits/doc/add_reference.qbk       Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/add_reference.qbk       Wed Jun  2 00:58:52 2010
@@ -13,19 +13,21 @@
       typedef __below type;
    };

-__type If `T` is not a reference type then `T&`, otherwise `T`.
+__type If `T` is not a reference type then `T&`, otherwise `T`.\n
+__type 如果 T 不是一个引用类型,则是 T&,否则是 T。

 __std_ref 8.3.2.

__compat If the compiler does not support partial specialization of class-templates then this template will compile, but the member `type` will always be the same as
-type `T` except where __transform_workaround have been applied.
+type `T` except where __transform_workaround have been applied.\n
+__compat 如果编译器不支持类模板的偏特化,这个模板也可以编译,但是成员 `type` 总是和 `T` 类型相同,除非 __transform_workaround 可用。

__header ` #include <boost/type_traits/add_reference.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`add_reference<int>::type`][`int&`]]

=======================================
--- /trunk/libs/type_traits/doc/add_volatile.qbk        Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/add_volatile.qbk        Wed Jun  2 00:58:52 2010
@@ -13,19 +13,21 @@
       typedef __below type;
    };

-__type The same type as `T volatile` for all `T`.
+__type The same type as `T volatile` for all `T`.  \n
+__type 对于所有的 `T`,与 `T volatile` 类型相同。

 __std_ref 3.9.3.

__compat If the compiler does not support partial specialization of class-templates then this template will compile, but the member `type` will always be the same as
-type `T` except where __transform_workaround have been applied.
+type `T` except where __transform_workaround have been applied.\n
+__compat 如果编译器不支持类模板的偏特化,这个模板也可以编译,但是成员 `type` 总是和 `T` 类型相同,除非 __transform_workaround 可用。

__header ` #include <boost/type_traits/add_volatile.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`add_volatile<int>::type`][`int volatile`]]

=======================================
--- /trunk/libs/type_traits/doc/aligned_storage.qbk     Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/aligned_storage.qbk     Wed Jun  2 00:58:52 2010
@@ -14,7 +14,8 @@
    };

 __type a built-in or POD type with size `Size` and an alignment
-that is a multiple of `Align`.
+that is a multiple of `Align`.  \n
+__type 一个大小为 `Size` 并对齐到 `Align` 的倍数的内建或 POD 类型。

__header ` #include <boost/type_traits/aligned_storage.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/alignment_of.qbk        Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/alignment_of.qbk        Wed Jun  2 00:58:52 2010
@@ -11,11 +11,13 @@

 __inherit Class template `alignment_of` inherits from
 `__integral_constant<std::size_t, ALIGNOF(T)>`, where `ALIGNOF(T)` is the
-alignment of type T.
+alignment of type T.  \n
+__inherit 当类型 `T` 对齐到 `ALIGNOF(T)` 时,类模板 `alignment_of` 从 `integral_constant<std::size_t, ALIGNOF(T)>` 继承。

 ['Note: strictly speaking you should only rely on
the value of `ALIGNOF(T)` being a multiple of the true alignment of T, although -in practice it does compute the correct value in all the cases we know about.] +in practice it does compute the correct value in all the cases we know about.\n +注意:严格地说,你应该正好让 `ALIGNOF(T)` 的值成为 T 的真正对齐大小的倍 数,虽然在实践中我们所知道的所有情况下,它都能算出正确的值。]

__header ` #include <boost/type_traits/alignment_of.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/alignment_traits.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/alignment_traits.qbk Wed Jun 2 00:58:52 2010
@@ -5,14 +5,16 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:alignment Synthesizing Types with Specific Alignments]
+[section:alignment Synthesizing Types with Specific Alignments 用指定的对齐 方式组合类型]

Some low level memory management routines need to synthesize a POD type with specific alignment properties. The template `__type_with_alignment` finds the smallest type with a specified alignment, while template `__aligned_storage` creates a type
-with a specific size and alignment.
-
-[*Synopsis]
+with a specific size and alignment.\n
+某些低层内存管理例程需要按照指定的对齐方式组合一个 POD 类型。模板 `__type_with_alignment` +找出符合一个指定的对齐方式的最小类型,模板 `__aligned_storage` 创建一个具有 指定大小和对齐方式的类型。
+
+[*Synopsis 概要]

    template <std::size_t Align>
    struct __type_with_alignment;
=======================================
--- /trunk/libs/type_traits/doc/background.qbk  Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/background.qbk  Wed Jun  2 00:58:52 2010
@@ -5,11 +5,13 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:background Background and Tutorial]
+[section:background Background and Tutorial 背景和指南]

 The following is an updated version of the article "C++ Type traits"
 by John Maddock and Steve Cleary that appeared in the October 2000
-issue of [@http://www.ddj.com Dr Dobb's Journal].
+issue of [@http://www.ddj.com Dr Dobb's Journal].\n
+下面是 John Maddock 和 Steve Cleary 发表在 2000 年 10 月号的 [@http://www.ddj.com Dr Dobb's Journal]
+上的文章 "C++ Type traits" 的修订版。

 Generic programming (writing code which works with any data type meeting a
set of requirements) has become the method of choice for providing reusable code.
@@ -19,7 +21,11 @@
 becomes important - by encapsulating those properties that need to be
 considered on a type by type basis inside a traits class, we can
 minimize the amount of code that has to differ from one type to another,
-and maximize the amount of generic code.
+and maximize the amount of generic code.\n
+泛型编程(写出的代码可以和任何一种符合一系列要求的数据类型一起工作)已经成 为提供可复用代码的高品位选择。 +但是,有时泛型编程中的"泛型"却不够好----有时不同类型之间的区别太大了,无法提 供高效的泛型实现。 +这就是 traits 技术大展身手的时候----通过将那些需要考虑的基于 type by type 的 属性封装在一个 traits +类中,我们可以将不得不在不同类型间有所区别的代码量减到最小,并将泛型代码量 增到最大。

Consider an example: when working with character strings, one common operation is to determine the length of a null terminated string. Clearly it's possible to
@@ -32,7 +38,13 @@
 that works with character strings can simply use `char_traits<>::length` to
 determine the length of a null terminated string, safe in the knowledge
 that specializations of `char_traits` will use the most appropriate method
-available to them.
+available to them.\n
+考虑一个例子:和字符串一起工作时,一种常见操作是测定以 null 结尾的字符串的 长度。 +很显然,写出做这种事情的泛型代码是可能的,但是还有很多更有效率的方法可 用:例如,C 库函数 +strlen 和 wcslen 通常用汇编语言写成,在相应的硬件支持下,比用 C++ 写的泛型 版本快得多。 +C++ 标准库的作者认识到了这一点,于是抽象出 `char` 和 `wchar_t` 的属性放到 类 `char_traits` 中。 +和字符串一起工作的泛型代码只需要简单地使用 `char_traits<>::length` 就可以确 定一个以 null +结尾的字符串的长度,根据经验可以肯定,`char_traits` 的特化使用了对于它们来 说最适合的方法。

 [h4 Type Traits]

@@ -46,7 +58,13 @@
the type __true_type if the type has the specified property and inherits from
 __false_type otherwise. As we will show, these classes can be used in
generic programming to determine the properties of a given type and introduce
-optimizations that are appropriate for that case.
+optimizations that are appropriate for that case.\n
+类 `char_traits` 是收集类型特定属性并包装到一个单独类中的典型示例----Nathan Myers 给出一个术语 /包装类(baggage class)/ +[link background.references \[1\]]。在 Boost type-traits 库中,我们[link background.references \[2\]]写了一套非常详细的 +traits classes(特征类),每一个封装一个 C++ 类型系统的单一特征。例如,某个 类型是一个指针还是一个引用类型? +或者某个类型是否有一个 trivial(非特殊)的构造函数或者有一个 const 修饰 符?这些 type-traits 类共享一个统一的设计: +如果这个类型具有特定的属性,则从类型 __true_type 继承,否则从 __false_type 继承。 +就像我们将要展示的,这些类可以用在泛型编程中,用于确定一个特定类型的属 性,并引入最适合那种情况的优化。

 The type-traits library also contains a set of classes that perform a
 specific transformation on a type; for example, they can remove a
@@ -54,16 +72,22 @@
 performs a transformation defines a single typedef-member `type`
 that is the result of the transformation. All of the type-traits
classes are defined inside namespace `boost`; for brevity, namespace-qualification
-is omitted in most of the code samples given.
-
-[h4 Implementation]
+is omitted in most of the code samples given.\n
+type-traits 库还包含一套可以对某个类型执行特定转换的类,例如,他们可以从一 个类型中移除一个顶层的 const 或 volatile 修饰符。
+每一个执行转换的类都为转换的结果定义了一个单独的 typedef 成员 `type`。
+所有 type-traits 类都定义在名字空间 `boost` 中,为简便起见,在下面给出的大 多数代码示例中省略了名字空间限定。
+
+[h4 Implementation 实现]

There are far too many separate classes contained in the type-traits library to give a full implementation here - see the source code in the Boost library for the full details - however, most of the implementation is fairly repetitive anyway, so here we will just give you a flavor for how some of the classes are
 implemented. Beginning with possibly the simplest class in the library,
-`is_void<T>` inherits from `__true_type` only if `T` is `void`.
+`is_void<T>` inherits from `__true_type` only if `T` is `void`.\n
+有相当多的独立类包含在 type-traits 库中,要在这里给出一个完整的实现是不可能 的----关于完整的细节参见 Boost +库中的源代码----但是,绝大多数实现以各种不同的方式反复出现,所以在这里我们仅 仅给你尝一点关于这些类是如何实现的滋味。 +我们从可能是库中最简单的类 `is_void<T>` 开始,只有当 `T` 为` void`,`is_void<T>` 才从 `__true_type` 继承。

    template <typename T>
    struct __is_void : public __false_type{};
@@ -79,7 +103,12 @@
 defined partial template-class specialization. As an example, consider the
 class `boost::is_pointer<T>`: here we needed a primary version that handles
 all the cases where T is not a pointer, and a partial specialization to
-handle all the cases where T is a pointer:
+handle all the cases where T is a pointer:\n
+这里我们定义了模板类 `__is_void` 的一个主体版本,并提供了一个 `T` 为 `void` 时的完全特化。 +虽然模板类的完全特化是一项重要的技术,但是有时我们需要一个位于完全泛化和完 全特化之间的解决方案。 +这正好就是标准委员会定义的 partial template-class specialization(模板类偏 特化)的用武之地。 +例如,考虑类 `boost::is_pointer<T>`:我们需要一个主体版本用来处理 T 不是一 个指针时的所有情况,和一个偏特化版本用来处理 T
+是一个指针时的所有情况:

    template <typename T>
    struct __is_pointer : public __false_type{};
@@ -95,12 +124,16 @@
 the types that will bind to that partial specialization rather than the
 default template. The rules for what can appear in a partial specialization
are somewhat convoluted, but as a rule of thumb if you can legally write two
-function overloads of the form:
+function overloads of the form:\n
+偏特化的语法多少有些晦涩,而且如果要全面介绍它可能会占据一篇文章的篇幅,和 完全特化一样,为一个类写一个偏特化,你必须先声明主体模板。 +偏特化在类名之后有一个额外的 <...> 用来包含偏特化参数,这些表明这个类型将被 绑定到偏特化版本而不是缺省版本。 +对于什么东西能够出现在偏特化版本中的规则多少有些费解,但是作为一条经验法 则,如果你能写出如下形式的两个合法的函数重载:

    void foo(T);
    void foo(U);

-Then you can also write a partial specialization of the form:
+Then you can also write a partial specialization of the form:\n
+你就能写出如下形式的偏特化:

    template <typename T>
    class c{ /*details*/ };
@@ -109,12 +142,15 @@
    class c<U>{ /*details*/ };

 This rule is by no means foolproof, but it is reasonably simple to remember
-and close enough to the actual rule to be useful for everyday use.
+and close enough to the actual rule to be useful for everyday use.\n
+这个规则相当简单,但是它比较容易记住并非常接近实际规则,适合日常使用。

 As a more complex example of partial specialization consider the class
 `remove_extent<T>`. This class defines a single typedef-member `type` that
 is the same type as T but with any top-level array bounds removed;
-this is an example of a traits class that performs a transformation on a type: +this is an example of a traits class that performs a transformation on a type:\n +举一个更复杂的偏特化的例子,考虑类 `remove_extent<T>`。这个类只定义一个唯一 的 typedef 成员 `type`,它和 T +是同一个类型,但会移除任何顶层数组的界限,这是一个在一个对某个类型执行转换 的 traits 类的例子:

    template <typename T>
    struct __remove_extent
@@ -132,12 +168,17 @@
 partial specialization does not have to match the number in the
 default template. However, the number of parameters that appear after the
 class name do have to match the number and type of the parameters in the
-default template.
-
-[h4 Optimized copy]
+default template.\n
+`__remove_extent` 的目的是:设想一个泛型算法被传递过来一个数组类型作为模板 参数,`__remove_extent` +提供了一个检测这个数组的底层类型的手段。例如 `remove_extent<int[4][5]>::type` 会被检测出类型 `int[5]`。
+这个例子也展示了偏特化中的模板参数的个数和缺省模板中的个数不必相同。
+但是,出现在类名后面的参数的个数和类型必须和缺省模板的参数的个数和类型相 同。
+
+[h4 Optimized copy 优化复制]

 As an example of how the type traits classes can be used, consider the
-standard library algorithm copy:
+standard library algorithm copy:\n
+给一个 type traits 类如何使用的例子,考虑模板库算法 copy:

    template<typename Iter1, typename Iter2>
    Iter2 copy(Iter1 first, Iter1 last, Iter2 out);
@@ -146,18 +187,27 @@
 for all iterator types `Iter1` and `Iter2`; however, there are some
 circumstances when the copy operation can best be performed by a call to
 `memcpy`. In order to implement copy in terms of `memcpy` all of the
-following conditions need to be met:
-
-* Both of the iterator types `Iter1` and `Iter2` must be pointers.
+following conditions need to be met:\n
+很明显,写一个适用于所有迭代器类型 `Iter1` 和 `Iter2` 的泛型版本没有问 题,但是,在一些情形,最好能通过调用 `memcpy` 来执行拷贝操作。
+为了使用 `memcpy` 执行拷贝,需要满足下面的所有条件:
+
+* Both of the iterator types `Iter1` and `Iter2` must be pointers. \n
+  迭代器类型 `Iter1` 和 `Iter2` 必须都是指针。
* Both `Iter1` and `Iter2` must point to the same type - excluding const and
-volatile-qualifiers.
-* The type pointed to by `Iter1` must have a trivial assignment operator.
-
-By trivial assignment operator we mean that the type is either a scalar type[link background.references \[3\]] or:
-
-* The type has no user defined assignment operator.
-* The type does not have any data members that are references.
-* All base classes, and all data member objects must have trivial assignment operators.
+volatile-qualifiers. \n
+ `Iter1` 和 `Iter2` 必须都指向同样的类型---- const 和 volatile 修饰符可不予 考虑。 +* The type pointed to by `Iter1` must have a trivial assignment operator. \n
+  被 `Iter1` 指向的类型必须有一个 trivial(不特殊)的赋值操作符。
+
+By trivial assignment operator we mean that the type is either a scalar type[link background.references \[3\]] or:\n +所谓 trivial(非特殊)的赋值操作符,我们指的是这个类型要么是一个 scalar type(标量类型)[link background.references \[3\]] 要么:
+
+* The type has no user defined assignment operator. \n
+  这个类型没有用户定义的赋值操作符。
+* The type does not have any data members that are references. \n
+  这个类型没有任何一个数据成员是引用。
+* All base classes, and all data member objects must have trivial assignment operators. \n
+  所有的基类,或所有数据成员对象必须有 trivial(非特殊)的赋值操作符。

 If all these conditions are met then a type can be copied using `memcpy`
 rather than using a compiler generated assignment operator. The type-traits
@@ -166,61 +216,87 @@
 This class "just works" for scalar types, but has to be explicitly
specialised for class/struct types that also happen to have a trivial assignment
 operator. In other words if __has_trivial_assign gives the wrong answer,
-it will give the "safe" wrong answer - that trivial assignment is not allowable. +it will give the "safe" wrong answer - that trivial assignment is not allowable.\n +如果这些条件都被满足,那么这个类型就可以用 `memcpy` 执行拷贝,而不使用编译 器生成的赋值操作符。 +type-traits 库提供了一个类 `__has_trivial_assign`,它的意思是只有 T 有一个 trivial(不特殊) +的赋值操作符,`has_trivial_assign<T>::value` 才成立。这个类仅对标量类型能 "正确地工作",除非为具有一个
+trivial(非特殊)的赋值操作符的 class/struct 类型进行显式特化。
+换句话说,如果 __has_trivial_assign 给出一个错误答案,它会给出一个"安全的 "错误答案----那个 trivial(非特殊)的赋值是不被允许的。

The code for an optimized version of copy that uses `memcpy` where appropriate is given in [link boost_typetraits.examples.copy the examples]. The code begins by defining a template function `do_copy` that performs a "slow but safe" copy. The last parameter passed to this function may be either a `__true_type` or a `__false_type`. Following that -there is an overload of do_copy that uses `memcpy`: this time the iterators are required +there is an overload of `do_copy` that uses `memcpy`: this time the iterators are required
 to actually be pointers to the same type, and the final parameter must be a
 `__true_type`.  Finally, the version of `copy` calls `do_copy`, passing
`__has_trivial_assign<value_type>()` as the final parameter: this will dispatch
 to the optimized version where appropriate, otherwise it will call the
-"slow but safe version".
-
-[h4 Was it worth it?]
+"slow but safe version".\n
+使用 `memcpy` 的 copy 的优化版本代码在 [link boost_typetraits.examples.copy 示例] 中给出。
+代码以定义一个模板函数 `do_copy` 开始,这个函数执行一个"慢但是安全"的拷贝。
+传给这个函数的最后一个参数既可能是一个 `__true_type`,也可能是一个 `__false_type`。 +然后有一个使用 `memcpy` 的 `do_copy` 的重载:这时要求迭代器实际上是一个指向 相同类型的指针,而且最后一个参数必须是一个 `__true_type`。 +最后,`copy` 的这个版本调用 `do_copy`,将 `__has_trivial_assign<value_type>()` 作为最后一个参数。
+如果优化版本更合适就会匹配到优化版本,否则就调用"慢但是安全的版本"。
+
+[h4 Was it worth it? 这是值得的吗?]

It has often been repeated in these columns that "premature optimization is the root of all evil" [link background.references \[4\]]. So the question must be asked: was our optimization
 premature? To put this in perspective the timings for our version of copy
-compared a conventional generic copy[link background.references \[5\]] are shown in table 1. +compared a conventional generic copy[link background.references \[5\]] are shown in table 1.\n +有一句名言经常被重复提到:"不成熟的优化是一切罪恶的根源" [link background.references \[4\]]。 +所以必须要问:我们的优化是成熟的吗?我们版本的 copy 和传统泛型 copy [link background.references \[5\]] 的时间比较展示在表1中。

 Clearly the optimization makes a difference in this case; but, to be fair,
 the timings are loaded to exclude cache miss effects - without this
 accurate comparison between algorithms becomes difficult. However, perhaps
-we can add a couple of caveats to the premature optimization rule:
+we can add a couple of caveats to the premature optimization rule:\n
+很明显,在这种情况下优化造成了区别,但是,为了公平,表中的时间排除了缓存失 误的影响 ---- +如果不排除这一点,算法的精确比较是很困难的。无论如何,也许我们可以增加一些 告诫,作为判别不成熟优化的法则:

*If you use the right algorithm for the job in the first place then optimization
-will not be required; in some cases, memcpy is the right algorithm.
+will not be required; in some cases, memcpy is the right algorithm. \n
+ 如果你一上来就使用了对于这个任务正确的算法,那么就不需要优化,在某些情况 下,memcpy 是正确的算法。
 *If a component is going to be reused in many places by many people then
optimizations may well be worthwhile where they would not be so for a single
 case - in other words, the likelihood that the optimization will be
 absolutely necessary somewhere, sometime is that much higher.
 Just as importantly the perceived value of the stock implementation will be
 higher: there is no point standardizing an algorithm if users reject it on
-the grounds that there are better, more heavily optimized versions available.
-
-[table Time taken to copy 1000 elements using `copy<const T*, T*>` (times in micro-seconds)
-
-[[Version] [T] [Time]]
-[["Optimized" copy] [char] [0.99]]
-[[Conventional copy] [char] [8.07]]
-[["Optimized" copy] [int] [2.52]]
-[[Conventional copy] [int] [8.02]]
+the grounds that there are better, more heavily optimized versions available. \n + 如果一个组件被很多人在很多地方复用,那么优化就是值得的,即使对其中的单独一 种情况来说也许没有必要 ----
+ 换句话说,优化在是某地是绝对必要的这种可能性还是比较高的。
+ 一个常备实现的可感知价值应该比较高,这是非常重要的:如果用户当场拒绝一个算 法,而使用更好的,
+ 优化度更高的版本,那么标准化这个算法就是毫无道理的。
+
+[table Time taken to copy 1000 elements using `copy<const T*, T*>` (times in micro-seconds)
+使用 `copy<const T*, T*>` 拷贝1000个元素花费的时间(微秒)
+
+[[Version 版本] [T] [Time 时间]]
+[["Optimized" copy "优化"复制] [char] [0.99]]
+[[Conventional copy 正常复制] [char] [8.07]]
+[["Optimized" copy "优化"复制] [int] [2.52]]
+[[Conventional copy 正常复制] [int] [8.02]]
 ]

-[h4 Pair of References]
+[h4 Pair of References 引用的 Pair]
 The optimized copy example shows how type traits may be used to perform
optimization decisions at compile-time. Another important usage of type traits
 is to allow code to compile that otherwise would not do so unless excessive
 partial specialization is used. This is possible by delegating partial
 specialization to the type traits classes. Our example for this form of
-usage is a pair that can hold references [link background.references \[6\]]. +usage is a pair that can hold references [link background.references \[6\]].\n
+优化拷贝示例展示了 type traits 如何被用于编译时的优化决策。
+type traits 的另一个重要用途是是允许那些如果不使用额外的偏特化就无法编译的 代码能够编译。
+通过将偏特化委托给 type traits 类,就可能做到这一点。
+我们为这种使用方式提供的示例是一个可以持有引用的 pair [link background.references \[6\]]。

 First, let us examine the definition of `std::pair`, omitting the
comparison operators, default constructor, and template copy constructor for
-simplicity:
+simplicity:\n
+首先,我们先检查一下 `std::pair` 的定义,为了简单,我们忽略比较操作符,缺省 构造函数和模板拷贝构造函数:

    template <typename T1, typename T2>
    struct pair
@@ -239,10 +315,12 @@
 constructor would require taking a reference to a reference, which is
currently illegal [link background.references \[7\]]. Let us consider what the constructor's parameters
 would have to be in order to allow "pair" to hold non-reference types,
-references, and constant references:
-
-[table Required Constructor Argument Types
-[[Type of `T1`] [Type of parameter to initializing constructor]]
+references, and constant references:\n
+现在,这个 "pair" 不能持有引用作为它的当前支点,因为这样一来构造函数就要接 受一个引用的引用,这在当前是非法的 +[link background.references \[7\]]。我们来考虑一下为了让 "pair" 持有非引用 类型,引用,和常引用,构造函数的参数必须是什么样的:
+
+[table Required Constructor Argument Types 要求的构造函数参数类型
+[[Type of `T1`] [Type of parameter to initializing constructor 传给初始构造 函数的参数的类型]]
 [[T] [const T &]]
 [[T &] [T &]]
 [[const T &] [const T &]]
@@ -252,9 +330,11 @@
 single mapping that allows us to determine the type of parameter from the
 type of the contained class. The type traits classes provide a
 transformation __add_reference, which adds a reference to its type,
-unless it is already a reference.
-
-[table Using add_reference to synthesize the correct constructor type
+unless it is already a reference.\n
+和 type traits 类允许我们创建一个单一映射,以便我们我可从 contained class 的类型确定参数的类型有些类似。 +type traits 类提供了一个转换 __add_reference,它可以为一个类型加上引用,除 非它已经是一个引用。
+
+[table Using add_reference to synthesize the correct constructor type 使用 add_reference 合成正确的构造函数型 [[Type of `T1`] [Type of `const T1`] [Type of `add_reference<const T1>::type`]]
 [[T] [const T] [const T &]]
 [[T &] [T & \[8\]] [T &]]
@@ -262,7 +342,8 @@
 ]

 This allows us to build a primary template definition for `pair` that can
-contain non-reference types, reference types, and constant reference types:
+contain non-reference types, reference types, and constant reference types:\n +这就允许我们创建一个可以包含非引用类型,引用类型,和常引用类型的 `pair` 的 主模板的定义:

    template <typename T1, typename T2>
    struct pair
@@ -280,7 +361,8 @@

 Add back in the standard comparison operators, default constructor,
 and template copy constructor (which are all the same), and you have a
-`std::pair` that can hold reference types!
+`std::pair` that can hold reference types!\n
+再加上标准的比较操作符,缺省构造函数,和模板拷贝构造函数(都和原来的一样 ),你就有了一个能够持有引用类型的 `std::pair`!

This same extension could have been done using partial template specialization
 of `pair`, but to specialize `pair` in this way would require three partial
@@ -289,9 +371,12 @@
 any of these partial specializations, instead of a brute-force partial
 specialization approach. Using type traits in this fashion allows
 programmers to delegate partial specialization to the type traits classes,
-resulting in code that is easier to maintain and easier to understand.
-
-[h4 Conclusion]
+resulting in code that is easier to maintain and easier to understand.\n
+同样的扩展可以使用 `pair` 的模板偏特化来做到,但要这样特化 `pair`,一共需要 三个偏特化,外加主模板。 +type traits 允许我们定义一个单一的主模板,它可以调整自己像变魔术一样变成以 上任何一个偏特化,而不需要强制的偏特化步骤。 +以这种方式使用 type traits 允许程序员将偏特化委托给 type traits 类,使得代 码易于维护和理解。
+
+[h4 Conclusion 结论]

 We hope that in this article we have been able to give you some idea of
 what type-traits are all about. A more complete listing of the available
@@ -299,23 +384,39 @@
 type traits. Templates have enabled C++ uses to take the advantage of the
 code reuse that generic programming brings; hopefully this article has
 shown that generic programming does not have to sink to the lowest common
-denominator, and that templates can be optimal as well as generic.
-
-[h4 Acknowledgements]
+denominator, and that templates can be optimal as well as generic.\n
+我们希望我们能在这篇文章中给你一些关于 type-traits 是什么的概念。
+boost 文档中有一个可用类的更完整的列表,那里还有一些使用 type traits 的更进 一步的示例。 +模板使得 C++ 能够利用泛型编程带来的代码复用的好处,同时也希望这篇文章向你展 示泛型编程并非最不常用的特性,而且模板可以和泛型一样精彩。
+
+[h4 Acknowledgements 鸣谢]

 The authors would like to thank Beman Dawes and Howard Hinnant for their
-helpful comments when preparing this article.
-
-[h4 [#background.references]References]
+helpful comments when preparing this article.\n
+感谢 Beman Dawes 和 Howard Hinnant 在这篇文章准备过程中提出的帮助性建议。
+
+[h4 [#background.references]References 参考资料]

 # Nathan C. Myers, C++ Report, June 1995.
-# The type traits library is based upon contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org. -# A scalar type is an arithmetic type (i.e. a built-in integer or floating point type), an enumeration type, a pointer, a pointer to member, or a const- or volatile-qualified version of one of these types. -# This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg 268. -# The test code is available as part of the boost utility library (see algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all optimisations turned on, tests were conducted on a 400MHz Pentium II machine running Microsoft Windows 98. -# John Maddock and Howard Hinnant have submitted a "compressed_pair" library to Boost, which uses a technique similar to the one described here to hold references. Their pair also uses type traits to determine if any of the types are empty, and will derive instead of contain to conserve space -- hence the name "compressed". -# This is actually an issue with the C++ Core Language Working Group (issue #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow a "reference to a reference to T" to mean the same thing as a "reference to T", but only in template instantiation, in a method similar to multiple cv-qualifiers. -# For those of you who are wondering why this shouldn't be const-qualified, remember that references are always implicitly constant (for example, you can't re-assign a reference). Remember also that "const T &" is something completely different. For this reason, cv-qualifiers on template type arguments that are references are ignored. +# The type traits library is based upon contributions by Steve Cleary, Beman Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org. \n + type traits 库基于 Steve Cleary,Beman Dawes,Howard Hinnant 和 John Maddock 的贡献:它可以在 www.boost.org 找到。 +# A scalar type is an arithmetic type (i.e. a built-in integer or floating point type), an enumeration type, a pointer, a pointer to member, or a const- or volatile-qualified version of one of these types. \n + 一个 scalar type(标量类型)是一个算术类型(也就是说,一个内建整数或浮点 数类型),一个枚举类型, + 一个指针,一个成员指针,或一个上述类型的带有 const- 或 volatile- 修饰的版 本。 +# This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg 268. \n
+  这句引言出自 Donald Knuth, ACM Computing Surveys, December 1974, pg 268。
+# The test code is available as part of the boost utility library (see algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all optimisations turned on, tests were conducted on a 400MHz Pentium II machine running Microsoft Windows 98. \n + 测试代码成为 boost utility 库的一部分(参见 algo_opt_examples.cpp),代码 由 gcc 2.95 编译,并打开全部优化,测试在一台运行
+  Microsoft Windows 98 的 400 MHz Pentium II 机器上进行。
+# John Maddock and Howard Hinnant have submitted a "compressed_pair" library to Boost, which uses a technique similar to the one described here to hold references. Their pair also uses type traits to determine if any of the types are empty, and will derive instead of contain to conserve space -- hence the name "compressed". \n + John Maddock 和 Howard Hinnant 为 Boost 提交了一个 "compressed_pair" 库,使用了一种类似于这里描述的用以持有引用的技术。 + 它们的 pair 也使用 type traits,用来判断如果任何类型为空,就用派生代替包 含以节约空间----因此名为 "compressed"。 +# This is actually an issue with the C++ Core Language Working Group (issue #106), submitted by Bjarne Stroustrup. The tentative resolution is to allow a "reference to a reference to T" to mean the same thing as a "reference to T", but only in template instantiation, in a method similar to multiple cv-qualifiers. \n + 这实际上是 C++ 核心语言工作组的一个议题 (issue #106),由 Bjarne Stroustrup 提交。 + 暂定的解决方案是允许一个"T 的引用的引用"和"T 的引用"意味着同样的东西,但 是这仅局限于模板实例化或一个方法中,这就类似于多个 cv 修饰符。 +# For those of you who are wondering why this shouldn't be const-qualified, remember that references are always implicitly constant (for example, you can't re-assign a reference). Remember also that "const T &" is something completely different. For this reason, cv-qualifiers on template type arguments that are references are ignored.\n + 你可能会觉得奇怪,为什么这里不应该被 const 修饰,记住引用总是隐含常量性的 (例如,你不能为一个引用再赋值)。 + 同时,还要记住 "const T &" 是完全不同的东西。因此,在模板类型参数是引用的 时候,cv 修饰符是被忽略的。

 [endsect]

=======================================
--- /trunk/libs/type_traits/doc/credits.qbk     Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/credits.qbk     Wed Jun  2 00:58:52 2010
@@ -5,37 +5,50 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:credits Credits]
+[section:credits Credits 荣誉]

 This documentation was pulled together by John Maddock, using
 [@../../../../doc/html/quickbook.html Boost.Quickbook]
-and [@../../../../doc/html/boostbook.html Boost.DocBook].
+and [@../../../../doc/html/boostbook.html Boost.DocBook].\n
+本文档由 John Maddock 协助完成,使用了 [@../../../../doc/html/quickbook.html Boost.Quickbook] 和
+[@../../../../doc/html/boostbook.html Boost.DocBook] 工具。

 The original version of this library was created by Steve Cleary,
 Beman Dawes, Howard Hinnant, and John Maddock.  John Maddock is the
-current maintainer of the library.
+current maintainer of the library.\n
+此库的原始版本由 Steve Cleary,Beman Dawes,Howard Hinnant 和 John Maddock 创建,当前主要由 John Maddock 维护。

 This version of type traits library is based on contributions by
 Adobe Systems Inc, David Abrahams, Steve Cleary,
 Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus,
-Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek.
+Itay Maman, John Maddock, Thorsten Ottosen, Robert Ramey and Jeremy Siek.\n
+本版 type traits 库基于 Adobe Systems Inc David Abrahams,Steve Cleary,Beman Dawes, +Aleksey Gurtovoy,Howard Hinnant,Jesse Jones,Mat Marcus,Itay Maman,John Maddock,
+Thorsten Ottosen,Robert Ramey 和 Jeremy Siek 的捐赠。

 Mat Marcus and Jesse Jones invented, and
[@http://opensource.adobe.com/project4/project.shtml published a paper describing],
-the partial specialization workarounds used in this library.
-
-Aleksey Gurtovoy added MPL integration to the library.
+the partial specialization workarounds used in this library.\n
+此库中使用的偏特化 workarounds 由 Mat Marcus 和 Jesse Jones 做出并 [@http://opensource.adobe.com/project4/project.shtml 撰文介绍]。
+
+Aleksey Gurtovoy added MPL integration to the library.\n
+Aleksey Gurtovoy 将 MPL 结合到此库中。

 The __is_convertible template is based on code originally devised by
 Andrei Alexandrescu, see
 "[@http://www.cuj.com/experts/1810/alexandr.htm?topic=experts
-Generic<Programming>: Mappings between Types and Values]".
+Generic<Programming>: Mappings between Types and Values]".\n
+__is_convertible 模板所基于的代码最初由 Andrei Alexandrescu 做出,参见
+"[@http://www.cuj.com/experts/1810/alexandr.htm?topic=experts
+Generic<Programming>: Mappings between Types and Values]"。

 The latest version of this library and documentation can be found at
 [@http://www.boost.org www.boost.org]. Bugs, suggestions and discussion
 should be directed to boost@xxxxxxxxxxxxxxx
 (see [@http://www.boost.org/more/mailing_lists.htm#main
-www.boost.org/more/mailing_lists.htm#main] for subscription details).
+www.boost.org/more/mailing_lists.htm#main] for subscription details).\n
+此库的最新版本和文档可以在 [@http://www.boost.org www.boost.org] 找到。 bugs,建议和讨论请提交到 boost@xxxxxxxxxxxxxxx(关于订阅的细节参见 [@http://www.boost.org/more/mailing_lists.htm#main
+www.boost.org/more/mailing_lists.htm#main])。

 [endsect]

=======================================
--- /trunk/libs/type_traits/doc/decay.qbk       Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/decay.qbk       Wed Jun  2 00:58:52 2010
@@ -15,15 +15,17 @@

 __type Let `U` be the result of `remove_reference<T>::type`, then if `U` is
an array type, the result is `remove_extent<U>::type*`, otherwise if `U` is a
-function type then the result is `U*`, otherwise the result is `U`.
+function type then the result is `U*`, otherwise the result is `U`.\n
+__type 设 `U` 为 `remove_reference<T>::type` 的结果,则若 `U` 为数组类 型,则结果为 `remove_extent<U>*`,
+否则若 `U` 为函数类型则结果为 `U*`,否则结果为 `U`。

 __std_ref 3.9.1.

__header ` #include <boost/type_traits/decay.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`decay<int[2][3]>::type`][`int[3]*`]]

=======================================
--- /trunk/libs/type_traits/doc/decomposing_func.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/decomposing_func.qbk Wed Jun 2 00:58:52 2010
@@ -5,11 +5,13 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:function Decomposing Function Types]
+[section:function Decomposing Function Types 解析函数类型]

The class template __function_traits extracts information from function types (see also __is_function). This traits class allows you to tell how many arguments -a function takes, what those argument types are, and what the return type is. +a function takes, what those argument types are, and what the return type is.\n
+类模板 __function_traits 从函数类型(参见 __is_function)中提取信息。
+这个 traits 类允许你知道一个函数持有多少个参数,那些参数的类型是什么,以及 返回类型是什么。

 [*Synopsis]

=======================================
--- /trunk/libs/type_traits/doc/examples.qbk    Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/examples.qbk    Wed Jun  2 00:58:52 2010
@@ -5,18 +5,21 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:examples Examples]
-
-[section:copy An Optimized Version of std::copy]
+[section:examples Examples 示例]
+
+[section:copy An Optimized Version of std::copy  一个优化版本的std::copy]

 Demonstrates a version of `std::copy` that uses `__has_trivial_assign` to
 determine whether to use `memcpy` to optimise the copy operation
-(see [@../../examples/copy_example.cpp copy_example.cpp]):
+(see [@../../examples/copy_example.cpp copy_example.cpp]):\n
+示范了一个 `std::copy` 的版本,它使用 `__has_trivial_assign` 测定是否可以 用 `memcpy` 来优化拷贝操作(参见
+[@../../examples/copy_example.cpp copy_example.cpp]):

    //
    // opt::copy
    // same semantics as std::copy
    // calls memcpy where appropriate.
+   // 和 std::copy 语义相同,适当时调用 memcpy
    //

    namespace detail{
@@ -50,6 +53,8 @@
       // We can copy with memcpy if T has a trivial assignment operator,
       // and if the iterator arguments are actually pointers (this last
       // requirement we detect with overload resolution):
+ // 如果 T 具有平凡的赋值操作符且迭代器参数为真正的指针,我们可以用 memcpy 来复制
+      // (我们用重载决议来检测后一个要求):
       //
       typedef typename std::iterator_traits<I1>::value_type value_type;
return detail::copy_imp(first, last, out, boost::__has_trivial_assign<value_type>());
@@ -58,15 +63,18 @@

 [endsect]

-[section:fill An Optimised Version of std::fill]
+[section:fill An Optimised Version of std::fill 一个优化版本的std::fill]

 Demonstrates a version of `std::fill` that uses `__has_trivial_assign` to
 determine whether to use `memset` to optimise the fill operation
-(see [@../../examples/fill_example.cpp fill_example.cpp]):
+(see [@../../examples/fill_example.cpp fill_example.cpp]):\n
+示范了一个 `std::fill` 的版本,它使用 `__has_trivial_assign` 测定是否可以 用 `memset` 来优化填充操作(参见
+[@../../examples/fill_example.cpp fill_example.cpp]):

    //
    // fill
    // same as std::fill, but uses memset where appropriate
+   // 与 std::fill 相同,不过会在适当时使用 memset
    //
    namespace detail{

@@ -94,6 +102,7 @@
       //
       // We can do an optimised fill if T has a trivial assignment
       // operator and if it's size is one:
+ // 如果 T 具有平凡的赋值操作符且它的大小为1,则我们可以进行优化的 fill:
       //
       typedef boost::__integral_constant<bool,
::boost::__has_trivial_assign<T>::value && (sizeof(T) == 1)> truth_type;
@@ -103,16 +112,19 @@

 [endsect]

-[section:destruct An Example that Omits Destructor Calls For Types with Trivial Destructors] +[section:destruct An Example that Omits Destructor Calls For Types with Trivial Destructors 对于带有 trivial(非特殊)的析构函数的类型忽略析构函数调 用的一个示例]

 Demonstrates a simple algorithm that uses `__has_trivial_destruct` to
 determine whether to destructors need to be called
-(see [@../../examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]): +(see [@../../examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]):\n +示范了一个简单算法,它使用 `__has_trivial_destruct` 测定是否需要调用析构函 数(参见 +[@../../examples/trivial_destructor_example.cpp trivial_destructor_example.cpp]):

    //
    // algorithm destroy_array:
    // The reverse of std::unitialized_copy, takes a block of
    // initialized memory and calls destructors on all objects therein.
+ // 与 std::unitialized_copy 相反,接受一块已初始化的内存并对其中的所有对 象调用析构函数。
    //

    namespace detail{
@@ -143,7 +155,7 @@

 [endsect]

-[section:iter An improved Version of std::iter_swap]
+[section:iter An improved Version of std::iter_swap 一个改进版本的 std::iter_swap]

 Demonstrates a version of `std::iter_swap` that use type traits to
 determine whether an it's arguments are proxying iterators or not,
@@ -153,12 +165,17 @@
 then takes special care over the swap to ensure that the algorithm
 works correctly for both proxying iterators, and even iterators of
 different types
-(see [@../../examples/iter_swap_example.cpp iter_swap_example.cpp]):
+(see [@../../examples/iter_swap_example.cpp iter_swap_example.cpp]):\n
+示范了一个 `std::iter_swap` 的版本,它使用 type traits 测定它的参数是否是 proxying iterators, +如果它们不是,就仅仅对它的解引用后的参数做一次 `std::swap`(和 `std::iter_swap` 所做的一样), +反之,如果它们是 proxying iterators,就特别关照它们的交换,以确保对两个 proxying iterators, +甚至不同类型的 iterators 所做的操作正确(参见 [@../../examples/iter_swap_example.cpp iter_swap_example.cpp]):

    //
    // iter_swap:
    // tests whether iterator is a proxying iterator or not, and
    // uses optimal form accordingly:
+   // 测试迭代器是否为代理迭代器,并采用相应的优化形式:
    //
    namespace detail{

@@ -185,6 +202,7 @@
       //
       // See is both arguments are non-proxying iterators,
       // and if both iterator the same type:
+      // 检查两个参数是否均为非代理迭代器,且两个迭代器为相同类型:
       //
       typedef typename std::iterator_traits<I1>::reference r1_t;
       typedef typename std::iterator_traits<I2>::reference r2_t;
@@ -200,12 +218,15 @@

 [endsect]

-[section:to_double Convert Numeric Types and Enums to double]
+[section:to_double Convert Numeric Types and Enums to double 将数字类型和枚 举类型转换为double]

 Demonstrates a conversion of
[@../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types
 Numeric Types]
-and enum types to double:
+and enum types to double:\n
+示范将
+[@../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types
+数字类型] 和枚举类型转换为 double:

     template<class T>
     inline double to_double(T const& value)
=======================================
--- /trunk/libs/type_traits/doc/extent.qbk      Mon May 31 02:08:39 2010
+++ /trunk/libs/type_traits/doc/extent.qbk      Wed Jun  2 00:58:52 2010
@@ -10,10 +10,13 @@
    struct extent : public __integral_constant<std::size_t, EXTENT(T,N)> {};

__inherit Class template extent inherits from `__integral_constant<std::size_t, EXTENT(T,N)>`, -where `EXTENT(T,N)` is the number of elements in the N'th array dimension of type `T`. +where `EXTENT(T,N)` is the number of elements in the N'th array dimension of type `T`.\n +__inherit 当 `EXTENT(T,N)` 是类型为 `T` 的第 N 个数组维的元素的个数时,类模 板 extent 从
+`integral_constant<std::size_t,EXTENT(T,N)>` 继承。

If `T` is not a (built-in) array type, or if `N > __rank<T>::value`, or if the N'th array bound
-is incomplete, then `EXTENT(T,N)` is zero.
+is incomplete, then `EXTENT(T,N)` is zero.\n
+如果 `T` 不是一个(内建)数组类型,或者 `N > rank<T>::value`,或者第 N 个数组 的绑定是不完全的,那么 `EXTENT(T,N)` 为 0。

__header ` #include <boost/type_traits/extent.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/floating_point_promotion.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/floating_point_promotion.qbk Wed Jun 2 00:58:52 2010
@@ -15,15 +15,16 @@

 __type If floating point promotion can be applied to an rvalue of type `T`,
then applies floating point promotion to `T` and keeps cv-qualifiers of `T`,
-otherwise leaves `T` unchanged.
+otherwise leaves `T` unchanged.\n
+__type 如果类型为 `T` 的右值可以提升为浮点数,则对 `T` 进行浮点数提供并保 持 `T` 的cv限定符,否则 `T` 保持不变。

 __std_ref 4.6.

__header ` #include <boost/type_traits/floating_point_promotion.hpp>` or ` #include <boost/type_traits.hpp>`

-[table Examples
-
-[ [Expression] [Result Type]]
+[table Examples 示例
+
+[ [Expression 表达式] [Result Type 结果类型]]

 [[`floating_point_promotion<float const>::type`][`double const`]]

=======================================
--- /trunk/libs/type_traits/doc/function_traits.qbk     Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/function_traits.qbk     Wed Jun  2 00:58:52 2010
@@ -16,39 +16,52 @@
       typedef __below           __argN;
    };

-The class template function_traits will only compile if:
-
-* The compiler supports partial specialization of class templates.
+The class template function_traits will only compile if:\n
+这个类模板仅在以下情况可编译:
+
+* The compiler supports partial specialization of class templates.\n
+  编译器支持类模板的偏特化时。
* The template argument `F` is a /function type/, note that this ['[*is not]]
-the same thing as a /pointer to a function/.
+the same thing as a /pointer to a function/.\n
+ 模板参数 `F` 是一个 /函数类型/,注意这和一个 /指向函数的指针/ ['不是]一样 的东西。

 [tip
 function_traits is intended to introspect only C++ functions of the
 form R (), R( A1 ), R ( A1, ... etc. ) and not function pointers or
 class member functions. To convert a function pointer type to a suitable
-type use __remove_pointer.]
-
-[table Function Traits Members
-[[Member] [Description]]
+type use __remove_pointer.\n
+function_traits 只能用于形如 R (), R( A1 ), R ( A1, ... 等等)的C++函数,而 非函数指针或类成员函数。
+要将函数指针转换为适用的类型,请使用 __remove_pointer。]
+
+[table Function Traits Members 成员
+[[Member 成员] [Description 说明]]
 [[`function_traits<F>::arity`]
- [An integral constant expression that gives the number of arguments accepted by the function type `F`.]] + [An integral constant expression that gives the number of arguments accepted by the function type `F`.\n + 一个给出 function type(函数类型)`F` 接收的参数的个数的 integral constant expression(整常表达式)。]]
 [[`function_traits<F>::result_type`]
-   [The type returned by function type `F`.]]
+   [The type returned by function type `F`.\n
+   function type(函数类型)`F` 的返回类型。]]
 [[`function_traits<F>::__argN`]
- [The '''<replaceable>N</replaceable>th''' argument type of function type `F`, where `1 <= N <= arity` of `F`.]] + [The '''<replaceable>N</replaceable>th''' argument type of function type `F`, where `1 <= N <= arity` of `F`.\n + 当 `1 <= N <= arity` of `F` 时,function type(函数类型)F 的 第 '''<replaceable>N</replaceable>''' 个参数类型。]]
 ]

-[table Examples
-[[Expression] [Result]]
-[[`function_traits<void (void)>::arity`] [An integral constant expression that has the value 0.]] -[[`function_traits<long (int)>::arity`] [An integral constant expression that has the value 1.]] -[[`function_traits<long (int, long, double, void*)>::arity`] [An integral constant expression that has the value 4.]]
+[table Examples 示例
+[[Expression 表达式] [Result 结果]]
+[[`function_traits<void (void)>::arity`] [An integral constant expression that has the value 0.\n
+一个值为 0 的 integral constant expression(整常表达式)。]]
+[[`function_traits<long (int)>::arity`] [An integral constant expression that has the value 1.\n
+一个值为 1 的 integral constant expression(整常表达式)。]]
+[[`function_traits<long (int, long, double, void*)>::arity`] [An integral constant expression that has the value 4.\n
+一个值为 4 的 integral constant expression(整常表达式)。]]
 [[`function_traits<void (void)>::result_type`] [The type `void`.]]
 [[`function_traits<long (int)>::result_type`] [The type `long`.]]
 [[`function_traits<long (int)>::arg1_type`] [The type `int`.]]
[[`function_traits<long (int, long, double, void*)>::arg4_type`] [The type `void*`.]] -[[`function_traits<long (int, long, double, void*)>::arg5_type`] [A compiler error: there is no `arg5_type` since there are only four arguments.]] -[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.]] +[[`function_traits<long (int, long, double, void*)>::arg5_type`] [A compiler error: there is no `arg5_type` since there are only four arguments.\n
+一个编译器错误:没有 `arg5_type` 因为只有 4 个参数。]]
+[[`function_traits<long (*)(void)>::arity`] [A compiler error: argument type is a /function pointer/, and not a /function type/.\n +一个编译器错误:参数类型是一个 /function pointer/,而不是一个 /function type/。]]

 ]

=======================================
--- /trunk/libs/type_traits/doc/has_new_operator.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_new_operator.qbk Wed Jun 2 00:58:52 2010
@@ -10,11 +10,13 @@
    struct has_new_operator : public __tof {};

__inherit If T is a (possibly cv-qualified) type with an overloaded new-operator
-then inherits from __true_type, otherwise inherits from __false_type.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有重载的 new 操作符的类型(可能带有cv-限定),则继承 自 __true_type,否则继承自 __false_type。

__compat Not usable with compilers that do not support "substitution failure is not an error" (in which case BOOST_NO_SFINAE will be defined), also known to be broken with
-the Borland/Codegear compiler.
+the Borland/Codegear compiler.\n
+__compat 不能用于不支持"替代失败并非错误"的编译器(这种情况下会定义 BOOST_NO_SFINAE),已知对于 Borland/Codegear 编译器不可用。

 __std_ref 12.5.

@@ -22,7 +24,8 @@

 __examples

-Given:
+Given:\n
+给定:

        class A { void* operator new(std::size_t); };
        class B { void* operator new(std::size_t, const std::nothrow&); };
@@ -31,7 +34,8 @@
        class E { void* operator new[](std::size_t, const std::nothrow&); };
        class F { void* operator new[](std::size_t, void*); };

-Then:
+Then:\n
+则:

 [:`has_new_operator<A>` inherits from `__true_type`.]

=======================================
--- /trunk/libs/type_traits/doc/has_nothrow_assign.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_nothrow_assign.qbk Wed Jun 2 00:58:52 2010
@@ -12,16 +12,21 @@

__inherit If T is a (possibly cv-qualified) type with a non-throwing assignment-operator then inherits from __true_type, otherwise inherits from __false_type. Type `T`
-must be a complete type.
+must be a complete type.\n
+__inherit 如果 T 是一个带有不抛异常的赋值操作符的(可能被 cv 修饰的)类 型,则从 __true_type 继承,否则从 __false_type 继承。
+类型 `T `必须是一个完整类型。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于函数类型。

 Without some (as yet unspecified) help from the compiler,
 `has_nothrow_assign` will never report that a class or struct has a
non-throwing assignment-operator; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler support to ensure that this
-trait "just works".
+trait "just works".\n
+没有来自编译器的某些(未加规定的)帮助,`has_nothrow_assign` 绝不会报告一 个 class 或 struct 有一个不抛异常的赋值操作符,如果 +sub-optimal 可能,这总是安全的。当前(2005 年 5 月)只有 Visual C++ 8 具有 确保这个 trait "正常工作"所必须的编译器支持。

__header ` #include <boost/type_traits/has_nothrow_assign.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/has_nothrow_constructor.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_nothrow_constructor.qbk Wed Jun 2 00:58:52 2010
@@ -15,18 +15,24 @@

__inherit If T is a (possibly cv-qualified) type with a non-throwing default-constructor then inherits from __true_type, otherwise inherits from __false_type. Type `T`
-must be a complete type.
-
-These two traits are synonyms for each other.
+must be a complete type.\n
+__inherit 如果 T 是一个带有不抛异常的缺省构造函数的(可能被 cv 修饰的)类 型,则从 __true_type 继承,否则从 __false_type 继承。
+类型 `T` 必须是一个完整类型。
+
+These two traits are synonyms for each other.\n
+这两个 traits 是相互同义的。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于函数类型。

 Without some (as yet unspecified) help from the compiler,
 `has_nothrow_constructor` will never report that a class or struct has a
non-throwing default-constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
-trait "just works".
+trait "just works".\n
+没有来自编译器的某些(未加规定的)帮助,`has_nothrow_assign` 绝不会报告一 个 class 或 struct 有一个不抛异常的缺省构造函数,如果 +sub-optimal 可能,这总是安全的。当前(2005 年 5 月)只有 Visual C++ 8 具有 确保这个 trait "正常工作"所必须的编译器 __intrinsics。

__header ` #include <boost/type_traits/has_nothrow_constructor.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/has_nothrow_copy.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_nothrow_copy.qbk Wed Jun 2 00:58:52 2010
@@ -15,18 +15,24 @@

__inherit If T is a (possibly cv-qualified) type with a non-throwing copy-constructor then inherits from __true_type, otherwise inherits from __false_type. Type `T`
-must be a complete type.
-
-These two traits are synonyms for each other.
+must be a complete type.\n
+__inherit 如果 T 是一个带有不抛异常的拷贝构造函数的(可能被 cv 修饰的)类 型,则从 __true_type 继承,否则从 __false_type 继承。
+类型 `T `必须是一个完整类型。
+
+These two traits are synonyms for each other.\n
+这两个 traits 是相互同义的。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于函数类型。

 Without some (as yet unspecified) help from the compiler,
 `has_nothrow_copy` will never report that a class or struct has a
non-throwing copy-constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only Visual C++ 8 has the necessary compiler __intrinsics to ensure that this
-trait "just works".
+trait "just works".\n
+没有来自编译器的某些(未加规定的)帮助,`has_nothrow_assign` 绝不会报告一 个 class 或 struct 有一个不抛异常的拷贝构造函数,如果 +sub-optimal 可能,这总是安全的。当前(2005 年 5 月)只有 Visual C++ 8 具有 确保这个 trait "正常工作"所必须的编译器 __intrinsics。

__header ` #include <boost/type_traits/has_nothrow_copy.hpp>` or ` #include <boost/type_traits.hpp>`

=======================================
--- /trunk/libs/type_traits/doc/has_trivial_assign.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_trivial_assign.qbk Wed Jun 2 00:58:52 2010
@@ -10,20 +10,28 @@
    struct has_trivial_assign : public __tof {};

__inherit If T is a (possibly cv-qualified) type with a trivial assignment-operator
-then inherits from __true_type, otherwise inherits from __false_type.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有 trivial(非特殊)的赋值操作符的(可能被 cv 修饰 的)类型,则从 __true_type 继承,否则从 __false_type 继承。
+类型 `T` 必须是一个完整类型。

If a type has a trivial assignment-operator then the operator has the same effect
 as copying the bits of one object to the other:
-calls to the operator can be safely replaced with a call to `memcpy`.
+calls to the operator can be safely replaced with a call to `memcpy`.\n
+如果一个类型有一个 trivial(非特殊)的赋值操作符,则这个操作符的作用就好像 将一个对象的字节逐个地拷贝到另一个:
+对这个操作符的调用可以安全地替换为对 `memcpy` 的调用。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于函数类型。

 Without some (as yet unspecified) help from the compiler,
has_trivial_assign will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
-user-defined classes with trivial constructors.
+user-defined classes with trivial constructors.\n
+没有来自编译器的某些(未加规定的)帮助,`has_nothrow_assign` 绝不会报告一 个 class 或 struct 有一个
+trivial(非特殊)的赋值操作符,如果 sub-optimal 可能,这总是安全的。
+当前(2005 年 5 月)只有 Visual C++ 8 具有探测带有 trivial(非特殊)的赋值 操作符的用户自定义类所必须的编译器 __intrinsics。

 __std_ref 12.8p11.

=======================================
--- /trunk/libs/type_traits/doc/has_trivial_constructor.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_trivial_constructor.qbk Wed Jun 2 00:58:52 2010
@@ -14,24 +14,33 @@
    struct has_trivial_default_constructor : public __tof {};

__inherit If T is a (possibly cv-qualified) type with a trivial default-constructor
-then inherits from __true_type, otherwise inherits from __false_type.
-
-These two traits are synonyms for each other.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有 trivial(非特殊)的缺省构造函数的(可能被 cv 修 饰的)类型,则从 __true_type 继承,否则从 __false_type 继承。
+
+These two traits are synonyms for each other.\n
+这两个 traits 互为同义词。

If a type has a trivial default-constructor then the constructor have no effect: calls to the constructor can be safely omitted. Note that using meta-programming to omit a call to a single trivial-constructor call is of no benefit whatsoever. However, if loops and/or exception handling code can also be omitted, then some
-benefit in terms of code size and speed can be obtained.
+benefit in terms of code size and speed can be obtained.\n
+如果一个类型有一个 trivial(非特殊)的缺省构造函数,则这个构造函数没什么作 用:对这个构造函数的调用可以安全地忽略。 +注意,使用元编程如果只是单独忽略对一个 trivial(非特殊)构造函数的调用没有 任何好处。 +但是,如果循环和/或异常处理代码也可以被忽略,则可以获得代码大小和速度方面的 好处。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于 function types(函数类型)。

 Without some (as yet unspecified) help from the compiler,
has_trivial_constructor will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
-user-defined classes with trivial constructors.
+user-defined classes with trivial constructors.\n
+没有来自编译器的某些(未加规定的)帮助,has_trivial_constructor 绝不会报告 一个用户自定义 class 或 struct 有一个
+trivial(非特殊)的构造函数,如果 sub-optimal 可能,这总是安全的。
+当前(2005 年 5 月)只有 MWCW 9 和 Visual C++ 8 具有探测带有 trivial(非特 殊)的构造函数的用户自定义类所必须的编译器 __intrinsics。

 __std_ref 12.1p6.

=======================================
--- /trunk/libs/type_traits/doc/has_trivial_copy.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_trivial_copy.qbk Wed Jun 2 00:58:52 2010
@@ -14,22 +14,28 @@
    struct has_trivial_copy_constructor : public __tof {};

__inherit If T is a (possibly cv-qualified) type with a trivial copy-constructor
-then inherits from __true_type, otherwise inherits from __false_type.
-
-These two traits are synonyms for each other.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有 trivial(非特殊)的拷贝构造函数的(可能被 cv 修 饰的)类型,则从 __true_type 继承,否则从 __false_type 继承。
+
+These two traits are synonyms for each other.\n
+这两个 traits 互为同义词。

If a type has a trivial copy-constructor then the constructor has the same effect
 as copying the bits of one object to the other:
-calls to the constructor can be safely replaced with a call to `memcpy`.
+calls to the constructor can be safely replaced with a call to `memcpy`.\n
+如果一个类型有一个 trivial(非特殊)的拷贝构造函数,则这个构造函数的作用就 好像将一个对象的字节逐个地拷贝到另一个:
+对这个构造函数的调用可以安全地替换为对 `memcpy` 的调用。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于 function types(函数类型)。

 Without some (as yet unspecified) help from the compiler,
has_trivial_copy will never report that a user-defined class or struct has a trivial constructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
-user-defined classes with trivial constructors.
+user-defined classes with trivial constructors.\n
+没有来自编译器的某些(未加规定的)帮助,has_trivial_copy 绝不会报告一个用户 自定义 class 或 struct 有一个 trivial(非特殊)的拷贝构造函数,如果 sub-optimal 可能,这总是安全的。当前(2005 年 5 月)只有 MWCW 9 和 Visual C++ 8 具有探测带有 trivial(非特殊)的拷贝构造函数的用户自定义类所必须的编译 器 __intrinsics。

 __std_ref 12.8p6.

=======================================
--- /trunk/libs/type_traits/doc/has_trivial_destructor.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_trivial_destructor.qbk Wed Jun 2 00:58:52 2010
@@ -10,22 +10,28 @@
    struct has_trivial_destructor : public __tof {};

 __inherit If T is a (possibly cv-qualified) type with a trivial destructor
-then inherits from __true_type, otherwise inherits from __false_type.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有 trivial(非特殊)的析构函数的(可能被 cv 修饰的 )类型,则从 __true_type 继承,否则从 __false_type 继承。

 If a type has a trivial destructor then the destructor has no effect:
calls to the destructor can be safely omitted. Note that using meta-programming to omit a call to a single trivial-constructor call is of no benefit whatsoever. However, if loops and/or exception handling code can also be omitted, then some
-benefit in terms of code size and speed can be obtained.
+benefit in terms of code size and speed can be obtained.\n
+如果一个类型有一个 trivial(非特殊)的析构函数,则这个析构函数没什么作 用:对这个析构函数的调用可以安全地忽略。 +注意,使用元编程如果只是单独忽略对一个 trivial(非特殊)析构函数的调用没有 任何好处。 +但是,如果循环和/或异常处理代码也可以被忽略,则可以获得代码大小和速度方面的 好处。

 __compat If the compiler does not support partial-specialization of class
-templates, then this template can not be used with function types.
+templates, then this template can not be used with function types.\n
+__compat 如果编译器不支持类模板的偏特化,则这个模板不能用于 function types(函数类型)。

 Without some (as yet unspecified) help from the compiler,
has_trivial_destructor will never report that a user-defined class or struct has a trivial destructor; this is always safe, if possibly sub-optimal. Currently (May 2005) only MWCW 9 and Visual C++ 8 have the necessary compiler __intrinsics to detect
-user-defined classes with trivial constructors.
+user-defined classes with trivial constructors.\n
+没有来自编译器的某些(未加规定的)帮助,has_trivial_destructor 绝不会报告一 个用户自定义 class 或 struct 有一个 trivial(非特殊)的析构函数,如果 sub-optimal 可能,这总是安全的。当前(2005 年 5 月)只有 MWCW 9 和 Visual C++ 8 具有探测带有 trivial(非特殊)的析构函数的用户自定义类所必须的编译器 __intrinsics。

 __std_ref 12.4p3.

=======================================
--- /trunk/libs/type_traits/doc/has_virtual_destructor.qbk Mon Feb 8 22:59:49 2010 +++ /trunk/libs/type_traits/doc/has_virtual_destructor.qbk Wed Jun 2 00:58:52 2010
@@ -10,7 +10,8 @@
    struct has_virtual_destructor : public __tof {};

 __inherit If T is a (possibly cv-qualified) type with a virtual destructor
-then inherits from __true_type, otherwise inherits from __false_type.
+then inherits from __true_type, otherwise inherits from __false_type.\n
+__inherit 如果 T 是一个带有虚拟析构函数的(可能被 cv 修饰的)类型,则从 __true_type 继承,否则从 __false_type 继承。

 __compat This trait is provided for completeness, since it's part of the
 Technical Report on C++ Library Extensions.  However, there is currently no
@@ -18,7 +19,10 @@
 always inherits from __false_type, and has to be explicitly specialized for
types with virtual destructors unless the compiler used has compiler __intrinsics that enable the trait to do the right thing: currently (May 2005) only Visual C++
-8 and GCC-4.3 have the necessary __intrinsics.
+8 and GCC-4.3 have the necessary __intrinsics.\n
+__compat 这个 trait 被完全提供,因为它是 C++ 库扩展技术报告的一部分。然 而,现在还没有可移植地实现这个 trait 的方法。 +所提供的缺省版本总是从 __false_type 继承,而且必须为带有虚拟析构函数的类型 进行显式特化,除非使用可以让这个 trait +做对事情的编译器 __intrinsics:目前(2005 年 5 月)只有 Visual C++ 8 具有必 要的 __intrinsics。

 __std_ref 12.4.

=======================================
--- /trunk/libs/type_traits/doc/history.qbk     Mon Feb  8 22:59:49 2010
+++ /trunk/libs/type_traits/doc/history.qbk     Wed Jun  2 00:58:52 2010
@@ -5,11 +5,12 @@
   http://www.boost.org/LICENSE_1_0.txt).
 ]

-[section:history History]
+[section:history History 历史]

 [h4 Boost 1.42.0]

-* Fixed issue [@https://svn.boost.org/trac/boost/ticket/3704 #3704].
+* Fixed issue [@https://svn.boost.org/trac/boost/ticket/3704 #3704].\n
+  修复问题 [@https://svn.boost.org/trac/boost/ticket/3704 #3704].


 [endsect]
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/background.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/background.html Wed Jun 2 00:58:52 2010
@@ -1,391 +1,497 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Background and Tutorial</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="prev" href="intro.html" title="Introduction">
-
-  <link rel="next" href="category.html" title="Type Traits by Category">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Background and Tutorial &#32972;&#26223;&#21644;&#25351;&#21335;</title> +<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="prev" href="intro.html" title="Introduction &#31616;&#20171;">
+<link rel="next" href="category.html" title="Type Traits by Category Type Traits&#20998;&#31867;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="intro.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial">背景和指南</a>
-</h2>
-</div>
-</div>
-</div>
-
-<p>下面是 John Maddock 和 Steve Cleary 发表在 2000 年 10 月号的 <a href="http://www.ddj.com/"; target="_top">Dr Dobb's Journal</a> 上的文 章 "C++ Type
-traits" 的修订版。</p>
-
-<p>泛型编程(写出的代码可以和任何一种符合一系列要求的数据类型一起工作)已经 成为提供可复用代码的高品位选择。但是,有时泛型编程中的&ldquo;泛型&rdquo;却不 够好&mdash;&mdash;有时不同类型之间的区别太大了,无法提供高效的泛型实现。这就 -traits 技术大展身手的时候&mdash;&mdash;通过将那些需要考虑的基于 type by type 的属性封装在一个 traits -类中,我们可以将不得不在不同类型间有所区别的代码量减到最小,并将泛型代码量 增到最大。</p>
-
-<p>考虑一个例子:和字符串一起工作时,一种常见操作是测定以 null
-结尾的字符串的长度。很显然,写出做这种事情的泛型代码是可能的,但是还有很多 更有效率的方法可用:例如,C 库函数 <code class="computeroutput"><span class="identifier">strlen</span></code> 和 <code class="computeroutput"><span class="identifier">wcslen</span></code> -通常用汇编语言写成,在相应的硬件支持下,比用 C++ 写的泛型版本快得多。C++ 标 准库的作者认识到了这一点,于是抽象出 <code class="computeroutput"><span class="keyword">char</span></code> 和 <code class="computeroutput"><span class="keyword">wchar_t</span></code> 的属性放到类 <code class="computeroutput"><span class="identifier">char_traits</span></code> -中。和字符串一起工作的泛型代码只需要简单地使用 <code class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></code> 就可以确定一个以 null 结尾的字符串的 长度,根据经验可以肯定,<code class="computeroutput"><span class="identifier">char_traits</span></code>
-的特化使用了对于它们来说最适合的方法。</p>
-<a name="boost_typetraits.background.type_traits"></a>
-<h5>
-<a name="id2586461"></a>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.background"></a><a class="link" href="background.html" title="Background and Tutorial &#32972;&#26223;&#21644;&#25351;&#21335;"> Background and Tutorial &#32972;&#26223;&#21644;&#25351;&#21335;</a>
+</h2></div></div></div>
+<p>
+      The following is an updated version of the article "C++ Type traits"
+ by John Maddock and Steve Cleary that appeared in the October 2000 issue of + <a href="http://www.ddj.com"; target="_top">Dr Dobb's Journal</a>.<br> &#19979;&#38754;&#26159; + John Maddock &#21644; Steve Cleary &#21457;&#34920;&#22312; 2000 &#24180; 10 &#26376;&#21495;&#30340; <a href="http://www.ddj.com"; target="_top">Dr + Dobb's Journal</a> &#19978;&#30340;&#25991;&#31456; "C++ Type traits" &#30340;&#20462;&#35746;&#29256;&#12290;
+    </p>
+<p>
+ Generic programming (writing code which works with any data type meeting a + set of requirements) has become the method of choice for providing reusable
+      code. However, there are times in generic programming when "generic"
+ just isn't good enough - sometimes the differences between types are too large + for an efficient generic implementation. This is when the traits technique + becomes important - by encapsulating those properties that need to be considered + on a type by type basis inside a traits class, we can minimize the amount of + code that has to differ from one type to another, and maximize the amount of + generic code.<br> &#27867;&#22411;&#32534;&#31243;&#65288;&#20889;&#20986;&#30340;&#20195;&#30721;&#21487;&#20197;&#21644;&#20219;&#20309;&#19968;&#31181;&#31526;&#21512;&#19968;&#31995;&#21015;&#35201;&#27714;&#30340;&#25968;&#25454;&#31867;&#22411;&#19968;&#36215;&#24037;&#20316;&#65289;&#24050;&#32463;&#25104;&#20026;&#25552;&#20379;&#21487;&#22797;&#29992;&#20195;&#30721;&#30340;&#39640;&#21697;&#20301;&#36873;&#25321;&#12290; + &#20294;&#26159;&#65292;&#26377;&#26102;&#27867;&#22411;&#32534;&#31243;&#20013;&#30340;&#8220;&#27867;&#22411;&#8221;&#21364;&#19981;&#22815;&#22909;&#8212;&#8212;&#26377;&#26102;&#19981;&#21516;&#31867;&#22411;&#20043;&#38388;&#30340;&#21306;&#21035;&#22826;&#22823;&#20102;&#65292;&#26080;&#27861;&#25552;&#20379;&#39640;&#25928;&#30340;&#27867;&#22411;&#23454;&#29616;&#12290; + &#36825;&#23601;&#26159; traits &#25216;&#26415;&#22823;&#23637;&#36523;&#25163;&#30340;&#26102;&#20505;&#8212;&#8212;&#36890;&#36807;&#23558;&#37027;&#20123;&#38656;&#35201;&#32771;&#34385;&#30340;&#22522;&#20110; + type by type &#30340;&#23646;&#24615;&#23553;&#35013;&#22312;&#19968;&#20010; traits &#31867;&#20013;&#65292;&#25105;&#20204;&#21487;&#20197;&#23558;&#19981;&#24471;&#19981;&#22312;&#19981;&#21516;&#31867;&#22411;&#38388;&#26377;&#25152;&#21306;&#21035;&#30340;&#20195;&#30721;&#37327;&#20943;&#21040;&#26368;&#23567;&#65292;&#24182;&#23558;&#27867;&#22411;&#20195;&#30721;&#37327;&#22686;&#21040;&#26368;&#22823;&#12290;
+    </p>
+<p>
+ Consider an example: when working with character strings, one common operation + is to determine the length of a null terminated string. Clearly it's possible + to write generic code that can do this, but it turns out that there are much + more efficient methods available: for example, the C library functions <code class="computeroutput"><span class="identifier">strlen</span></code> and <code class="computeroutput"><span class="identifier">wcslen</span></code> + are usually written in assembler, and with suitable hardware support can be + considerably faster than a generic version written in C++. The authors of the + C++ standard library realized this, and abstracted the properties of <code class="computeroutput"><span class="keyword">char</span></code> and <code class="computeroutput"><span class="keyword">wchar_t</span></code> + into the class <code class="computeroutput"><span class="identifier">char_traits</span></code>. + Generic code that works with character strings can simply use <code class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></code> to determine the length of a null + terminated string, safe in the knowledge that specializations of <code class="computeroutput"><span class="identifier">char_traits</span></code> will use the most appropriate + method available to them.<br> &#32771;&#34385;&#19968;&#20010;&#20363;&#23376;&#65306;&#21644;&#23383;&#31526;&#20018;&#19968;&#36215;&#24037;&#20316;&#26102;&#65292;&#19968;&#31181;&#24120;&#35265;&#25805;&#20316;&#26159;&#27979;&#23450;&#20197; + null &#32467;&#23614;&#30340;&#23383;&#31526;&#20018;&#30340;&#38271;&#24230;&#12290; &#24456;&#26174;&#28982;&#65292;&#20889;&#20986;&#20570;&#36825;&#31181;&#20107;&#24773;&#30340;&#27867;&#22411;&#20195;&#30721;&#26159;&#21487;&#33021;&#30340;&#65292;&#20294;&#26159;&#36824;&#26377;&#24456;&#22810;&#26356;&#26377;&#25928;&#29575;&#30340;&#26041;&#27861;&#21487;&#29992;&#65306;&#20363;&#22914;&#65292;C + &#24211;&#20989;&#25968; strlen &#21644; wcslen &#36890;&#24120;&#29992;&#27719;&#32534;&#35821;&#35328;&#20889;&#25104;&#65292;&#22312;&#30456;&#24212;&#30340;&#30828;&#20214;&#25903;&#25345;&#19979;&#65292;&#27604;&#29992; + C++ &#20889;&#30340;&#27867;&#22411;&#29256;&#26412;&#24555;&#24471;&#22810;&#12290; C++ &#26631;&#20934;&#24211;&#30340;&#20316;&#32773;&#35748;&#35782;&#21040;&#20102;&#36825;&#19968;&#28857;&#65292;&#20110;&#26159;&#25277;&#35937;&#20986; + <code class="computeroutput"><span class="keyword">char</span></code> &#21644; <code class="computeroutput"><span class="keyword">wchar_t</span></code> + &#30340;&#23646;&#24615;&#25918;&#21040;&#31867; <code class="computeroutput"><span class="identifier">char_traits</span></code> + &#20013;&#12290; &#21644;&#23383;&#31526;&#20018;&#19968;&#36215;&#24037;&#20316;&#30340;&#27867;&#22411;&#20195;&#30721;&#21482;&#38656;&#35201;&#31616;&#21333;&#22320;&#20351;&#29992; <code class="computeroutput"><span class="identifier">char_traits</span><span class="special">&lt;&gt;::</span><span class="identifier">length</span></code> &#23601;&#21487;&#20197;&#30830;&#23450;&#19968;&#20010;&#20197; null &#32467;&#23614;&#30340;&#23383;&#31526;&#20018;&#30340;&#38271;&#24230;&#65292;&#26681;&#25454;&#32463;&#39564;&#21487;&#20197;&#32943;&#23450;&#65292;<code class="computeroutput"><span class="identifier">char_traits</span></code> &#30340;&#29305;&#21270;&#20351;&#29992;&#20102;&#23545;&#20110;&#23427;&#20204;&#26469;&#35828;&#26368;&#36866;&#21512;&#30340;&#26041;&#27861;&#12290;
+    </p>
+<a name="boost_typetraits.background.type_traits"></a><h5>
+<a name="id4809486"></a>
<a class="link" href="background.html#boost_typetraits.background.type_traits">Type Traits</a>
     </h5>
-
-<p>类 <code class="computeroutput"><span class="identifier">char_traits</span></code> -是收集类型特定属性并包装到一个单独类中的典型示例&mdash;&mdash;Nathan Myers 给出一个术语 <span class="emphasis"><em>baggage -class</em></span><a href="background.html#background.references">[1]</a>(包装类)。在 -Boost type-traits 库中,我们<a href="background.html#background.references">[2]</a>写了一套非常详细的 traits -classes(特征类),每一个封装一个 C++ 类型系统的单一特征。例如,某个类型是 一个指针还是一个引用类型?或者某个类型是否有一个 -trivial(非特殊)的构造函数或者有一个 const 修饰符?这些 type-traits 类共享 一个统一的设计:如果这个类型具有特定的属性,则从类型 <a title=" integral_constant" href="reference/integral_constant.html">true_type</a> 继 承,否则从 <a title=" integral_constant" href="reference/integral_constant.html">false_type</a> -继承。就像我们将要展示的,这些类可以用在泛型编程中,用于确定一个特定类型的 属性,并引入最适合那种情况的优化。</p>
-
-<p>type-traits 库还包含一套可以对某个类型执行特定转换的类,例如,他们可以从 一个类型中移除一个顶层的 const 或 volatile -修饰符。每一个执行转换的类都为转换的结果定义了一个单独的 typedef 成员 <code class="computeroutput"><span class="identifier">type</span></code>。所 有 type-traits 类都定义在名字空间 <code class="computeroutput"><span class="identifier">boost</span></code>
-中,为简便起见,在下面给出的大多数代码示例中省略了名字空间限定。</p>
-<a name="boost_typetraits.background.implementation"></a>
-<h5>
-<a name="id2585291"></a><a class="link" href="background.html#boost_typetraits.background.implementation">实现</a>
+<p>
+ Class <code class="computeroutput"><span class="identifier">char_traits</span></code> is a classic + example of a collection of type specific properties wrapped up in a single + class - what Nathan Myers termed a <span class="emphasis"><em>baggage class</em></span><a class="link" href="background.html#background.references">[1]</a>. In the Boost type-traits library, + we<a class="link" href="background.html#background.references">[2]</a> have written a set of very + specific traits classes, each of which encapsulate a single trait from the + C++ type system; for example, is a type a pointer or a reference type? Or does + a type have a trivial constructor, or a const-qualifier? The type-traits classes + share a unified design: each class inherits from a the type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + if the type has the specified property and inherits from <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + otherwise. As we will show, these classes can be used in generic programming + to determine the properties of a given type and introduce optimizations that + are appropriate for that case.<br> &#31867; <code class="computeroutput"><span class="identifier">char_traits</span></code> + &#26159;&#25910;&#38598;&#31867;&#22411;&#29305;&#23450;&#23646;&#24615;&#24182;&#21253;&#35013;&#21040;&#19968;&#20010;&#21333;&#29420;&#31867;&#20013;&#30340;&#20856;&#22411;&#31034;&#20363;&#8212;&#8212;Nathan + Myers &#32473;&#20986;&#19968;&#20010;&#26415;&#35821; /&#21253;&#35013;&#31867;(baggage class)/ <a class="link" href="background.html#background.references">[1]</a>&#12290;&#22312; + Boost type-traits &#24211;&#20013;&#65292;&#25105;&#20204;<a class="link" href="background.html#background.references">[2]</a>&#20889;&#20102;&#19968;&#22871;&#38750;&#24120;&#35814;&#32454;&#30340; + traits classes&#65288;&#29305;&#24449;&#31867;&#65289;&#65292;&#27599;&#19968;&#20010;&#23553;&#35013;&#19968;&#20010; C++ &#31867;&#22411;&#31995;&#32479;&#30340;&#21333;&#19968;&#29305;&#24449;&#12290;&#20363;&#22914;&#65292;&#26576;&#20010;&#31867;&#22411;&#26159;&#19968;&#20010;&#25351;&#38024;&#36824;&#26159;&#19968;&#20010;&#24341;&#29992;&#31867;&#22411;&#65311; + &#25110;&#32773;&#26576;&#20010;&#31867;&#22411;&#26159;&#21542;&#26377;&#19968;&#20010; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26500;&#36896;&#20989;&#25968;&#25110;&#32773;&#26377;&#19968;&#20010; + const &#20462;&#39280;&#31526;&#65311;&#36825;&#20123; type-traits &#31867;&#20849;&#20139;&#19968;&#20010;&#32479;&#19968;&#30340;&#35774;&#35745;&#65306; &#22914;&#26524;&#36825;&#20010;&#31867;&#22411;&#20855;&#26377;&#29305;&#23450;&#30340;&#23646;&#24615;&#65292;&#21017;&#20174;&#31867;&#22411; + <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + &#32487;&#25215;&#65292;&#21542;&#21017;&#20174; <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + &#32487;&#25215;&#12290; &#23601;&#20687;&#25105;&#20204;&#23558;&#35201;&#23637;&#31034;&#30340;&#65292;&#36825;&#20123;&#31867;&#21487;&#20197;&#29992;&#22312;&#27867;&#22411;&#32534;&#31243;&#20013;&#65292;&#29992;&#20110;&#30830;&#23450;&#19968;&#20010;&#29305;&#23450;&#31867;&#22411;&#30340;&#23646;&#24615;&#65292;&#24182;&#24341;&#20837;&#26368;&#36866;&#21512;&#37027;&#31181;&#24773;&#20917;&#30340;&#20248;&#21270;&#12290;
+    </p>
+<p>
+ The type-traits library also contains a set of classes that perform a specific + transformation on a type; for example, they can remove a top-level const or + volatile qualifier from a type. Each class that performs a transformation defines + a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of the transformation. All of the type-traits classes are + defined inside namespace <code class="computeroutput"><span class="identifier">boost</span></code>; + for brevity, namespace-qualification is omitted in most of the code samples + given.<br> type-traits &#24211;&#36824;&#21253;&#21547;&#19968;&#22871;&#21487;&#20197;&#23545;&#26576;&#20010;&#31867;&#22411;&#25191;&#34892;&#29305;&#23450;&#36716;&#25442;&#30340;&#31867;&#65292;&#20363;&#22914;&#65292;&#20182;&#20204;&#21487;&#20197;&#20174;&#19968;&#20010;&#31867;&#22411;&#20013;&#31227;&#38500;&#19968;&#20010;&#39030;&#23618;&#30340; + const &#25110; volatile &#20462;&#39280;&#31526;&#12290; &#27599;&#19968;&#20010;&#25191;&#34892;&#36716;&#25442;&#30340;&#31867;&#37117;&#20026;&#36716;&#25442;&#30340;&#32467;&#26524;&#23450;&#20041;&#20102;&#19968;&#20010;&#21333;&#29420;&#30340; + typedef &#25104;&#21592; <code class="computeroutput"><span class="identifier">type</span></code>&#12290; &#25152;&#26377; + type-traits &#31867;&#37117;&#23450;&#20041;&#22312;&#21517;&#23383;&#31354;&#38388; <code class="computeroutput"><span class="identifier">boost</span></code> + &#20013;&#65292;&#20026;&#31616;&#20415;&#36215;&#35265;&#65292;&#22312;&#19979;&#38754;&#32473;&#20986;&#30340;&#22823;&#22810;&#25968;&#20195;&#30721;&#31034;&#20363;&#20013;&#30465;&#30053;&#20102;&#21517;&#23383;&#31354;&#38388;&#38480;&#23450;&#12290;
+    </p>
+<a name="boost_typetraits.background.implementation_______"></a><h5>
+<a name="id4809695"></a>
+ <a class="link" href="background.html#boost_typetraits.background.implementation_______">Implementation
+      &#23454;&#29616;</a>
     </h5>
-
-<p>有相当多的独立类包含在 type-traits 库中,要在这里给出一个完整的实现是不 可能的&mdash;&mdash;关于完整的细节参见 Boost -库中的源代码&mdash;&mdash;但是,绝大多数实现以各种不同的方式反复出现,所以 在这里我们仅仅给你尝一点关于这些类是如何实现的滋味。我们从可能是库中最简单的 类 <code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> 开始,只 有当 <span class="identifier">T</span> 为 <code class="computeroutput"><span class="keyword">void</span></code>,<code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> 才从 <code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">true_type</a></code>
-继承。</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
-
-<span class="keyword">template</span> <span class="special">&lt;&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
+<p>
+ There are far too many separate classes contained in the type-traits library + to give a full implementation here - see the source code in the Boost library + for the full details - however, most of the implementation is fairly repetitive + anyway, so here we will just give you a flavor for how some of the classes + are implemented. Beginning with possibly the simplest class in the library, + <code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> inherits + from <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + only if <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="keyword">void</span></code>.<br> &#26377;&#30456;&#24403;&#22810;&#30340;&#29420;&#31435;&#31867;&#21253;&#21547;&#22312; + type-traits &#24211;&#20013;&#65292;&#35201;&#22312;&#36825;&#37324;&#32473;&#20986;&#19968;&#20010;&#23436;&#25972;&#30340;&#23454;&#29616;&#26159;&#19981;&#21487;&#33021;&#30340;&#8212;&#8212;&#20851;&#20110;&#23436;&#25972;&#30340;&#32454;&#33410;&#21442;&#35265; + Boost &#24211;&#20013;&#30340;&#28304;&#20195;&#30721;&#8212;&#8212;&#20294;&#26159;&#65292;&#32477;&#22823;&#22810;&#25968;&#23454;&#29616;&#20197;&#21508;&#31181;&#19981;&#21516;&#30340;&#26041;&#24335;&#21453;&#22797;&#20986;&#29616;&#65292;&#25152;&#20197;&#22312;&#36825;&#37324;&#25105;&#20204;&#20165;&#20165;&#32473;&#20320;&#23581;&#19968;&#28857;&#20851;&#20110;&#36825;&#20123;&#31867;&#26159;&#22914;&#20309;&#23454;&#29616;&#30340;&#28363;&#21619;&#12290; + &#25105;&#20204;&#20174;&#21487;&#33021;&#26159;&#24211;&#20013;&#26368;&#31616;&#21333;&#30340;&#31867; <code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> + &#24320;&#22987;&#65292;&#21482;&#26377;&#24403; <code class="computeroutput"><span class="identifier">T</span></code> &#20026;<code class="computeroutput"> + <span class="keyword">void</span></code>&#65292;<code class="computeroutput"><span class="identifier">is_void</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> + &#25165;&#20174; <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>
+      &#32487;&#25215;&#12290;
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;&gt;</span>
+<span class="keyword">struct</span> <a class="link" href="reference/is_void.html" title="is_void">is_void</a><span class="special">&lt;</span><span class="keyword">void</span><span class="special">&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
 </pre>
-
-<p>这里我们定义了模板类 <code class="computeroutput"><a title=" is_void" href="reference/is_void.html">is_void</a></code> 的一个主体版本,并提供了一 -<code class="computeroutput"><span class="identifier">T</span></code> 为 <code class="computeroutput"><span class="keyword">void</span></code> -时的完全特化。虽然模板类的完全特化是一项重要的技术,但是有时我们需要一个位 于完全泛化和完全特化之间的解决方案。这正好就是标准委员会定义的 partial -template-class specialization(部分模板类特化)(也可译为模板类偏特化,以 后,如果原文为 partial -specialization 的,一律译为&ldquo;偏特化&rdquo;&mdash;&mdash;译者注)的用武 之地。例如,考虑类 <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>:我们需 要一个主体版本用来处理 T -不是一个指针时的所有情况,和一个偏特化版本用来处理 T 是一个指针时的所有情 况:</p> -<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
+<p>
+ Here we define a primary version of the template class <code class="computeroutput"><a class="link" href="reference/is_void.html" title="is_void">is_void</a></code>, + and provide a full-specialization when <code class="computeroutput"><span class="identifier">T</span></code> + is <code class="computeroutput"><span class="keyword">void</span></code>. While full specialization + of a template class is an important technique, sometimes we need a solution + that is halfway between a fully generic solution, and a full specialization. + This is exactly the situation for which the standards committee defined partial + template-class specialization. As an example, consider the class <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>: + here we needed a primary version that handles all the cases where T is not + a pointer, and a partial specialization to handle all the cases where T is + a pointer:<br> &#36825;&#37324;&#25105;&#20204;&#23450;&#20041;&#20102;&#27169;&#26495;&#31867; <code class="computeroutput"><a class="link" href="reference/is_void.html" title="is_void">is_void</a></code> + &#30340;&#19968;&#20010;&#20027;&#20307;&#29256;&#26412;&#65292;&#24182;&#25552;&#20379;&#20102;&#19968;&#20010; <code class="computeroutput"><span class="identifier">T</span></code> + &#20026; <code class="computeroutput"><span class="keyword">void</span></code> &#26102;&#30340;&#23436;&#20840;&#29305;&#21270;&#12290; + &#34429;&#28982;&#27169;&#26495;&#31867;&#30340;&#23436;&#20840;&#29305;&#21270;&#26159;&#19968;&#39033;&#37325;&#35201;&#30340;&#25216;&#26415;&#65292;&#20294;&#26159;&#26377;&#26102;&#25105;&#20204;&#38656;&#35201;&#19968;&#20010;&#20301;&#20110;&#23436;&#20840;&#27867;&#21270;&#21644;&#23436;&#20840;&#29305;&#21270;&#20043;&#38388;&#30340;&#35299;&#20915;&#26041;&#26696;&#12290; + &#36825;&#27491;&#22909;&#23601;&#26159;&#26631;&#20934;&#22996;&#21592;&#20250;&#23450;&#20041;&#30340; partial template-class specialization&#65288;&#27169;&#26495;&#31867;&#20559;&#29305;&#21270;&#65289;&#30340;&#29992;&#27494;&#20043;&#22320;&#12290; + &#20363;&#22914;&#65292;&#32771;&#34385;&#31867; <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>&#65306;&#25105;&#20204;&#38656;&#35201;&#19968;&#20010;&#20027;&#20307;&#29256;&#26412;&#29992;&#26469;&#22788;&#29702; + T &#19981;&#26159;&#19968;&#20010;&#25351;&#38024;&#26102;&#30340;&#25152;&#26377;&#24773;&#20917;&#65292;&#21644;&#19968;&#20010;&#20559;&#29305;&#21270;&#29256;&#26412;&#29992;&#26469;&#22788;&#29702; + T &#26159;&#19968;&#20010;&#25351;&#38024;&#26102;&#30340;&#25152;&#26377;&#24773;&#20917;&#65306;
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">{};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*&gt;</span> <span class="special">:</span> <span class="keyword">public</span> <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a><span class="special">{};</span>
 </pre>
-
-<p>偏特化的语法多少有些晦涩,而且如果要全面介绍它可能会占据一篇文章的篇 幅,和完全特化一样,为一个类写一个偏特化,你必须先声明主体模板。偏特化在类名 之后有一个额外的
-&lt;...&gt;
-用来包含偏特化参数,这些表明这个类型将被绑定到偏特化版本而不是缺省版本。对 于什么东西能够出现在偏特化版本中的规则多少有些费解,但是作为一条经验法则,如 果你能写出如下形式的两个合法的函数重载:</p>
+<p>
+ The syntax for partial specialization is somewhat arcane and could easily occupy + an article in its own right; like full specialization, in order to write a + partial specialization for a class, you must first declare the primary template. + The partial specialization contains an extra &lt;...&gt; after the class name + that contains the partial specialization parameters; these define the types + that will bind to that partial specialization rather than the default template. + The rules for what can appear in a partial specialization are somewhat convoluted, + but as a rule of thumb if you can legally write two function overloads of the + form:<br> &#20559;&#29305;&#21270;&#30340;&#35821;&#27861;&#22810;&#23569;&#26377;&#20123;&#26214;&#28073;&#65292;&#32780;&#19988;&#22914;&#26524;&#35201;&#20840;&#38754;&#20171;&#32461;&#23427;&#21487;&#33021;&#20250;&#21344;&#25454;&#19968;&#31687;&#25991;&#31456;&#30340;&#31687;&#24133;&#65292;&#21644;&#23436;&#20840;&#29305;&#21270;&#19968;&#26679;&#65292;&#20026;&#19968;&#20010;&#31867;&#20889;&#19968;&#20010;&#20559;&#29305;&#21270;&#65292;&#20320;&#24517;&#39035;&#20808;&#22768;&#26126;&#20027;&#20307;&#27169;&#26495;&#12290; + &#20559;&#29305;&#21270;&#22312;&#31867;&#21517;&#20043;&#21518;&#26377;&#19968;&#20010;&#39069;&#22806;&#30340; &lt;...&gt; &#29992;&#26469;&#21253;&#21547;&#20559;&#29305;&#21270;&#21442;&#25968;&#65292;&#36825;&#20123;&#34920;&#26126;&#36825;&#20010;&#31867;&#22411;&#23558;&#34987;&#32465;&#23450;&#21040;&#20559;&#29305;&#21270;&#29256;&#26412;&#32780;&#19981;&#26159;&#32570;&#30465;&#29256;&#26412;&#12290; + &#23545;&#20110;&#20160;&#20040;&#19996;&#35199;&#33021;&#22815;&#20986;&#29616;&#22312;&#20559;&#29305;&#21270;&#29256;&#26412;&#20013;&#30340;&#35268;&#21017;&#22810;&#23569;&#26377;&#20123;&#36153;&#35299;&#65292;&#20294;&#26159;&#20316;&#20026;&#19968;&#26465;&#32463;&#39564;&#27861;&#21017;&#65292;&#22914;&#26524;&#20320;&#33021;&#20889;&#20986;&#22914;&#19979;&#24418;&#24335;&#30340;&#20004;&#20010;&#21512;&#27861;&#30340;&#20989;&#25968;&#37325;&#36733;&#65306;
+    </p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">T</span><span class="special">);</span> <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">U</span><span class="special">);</span>
 </pre>
-
-<p>你就能写出如下形式的偏特化:
+<p>
+ Then you can also write a partial specialization of the form:<br> &#20320;&#23601;&#33021;&#20889;&#20986;&#22914;&#19979;&#24418;&#24335;&#30340;&#20559;&#29305;&#21270;&#65306;
     </p>
-
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">c</span><span class="special">{</span> <span class="comment">/*details*/</span> <span class="special">};</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">class</span> <span class="identifier">c</span><span class="special">&lt;</span><span class="identifier">U</span><span class="special">&gt;{</span> <span class="comment">/*details*/</span> <span class="special">};</span>
 </pre>
-
-<p>这个规则相当简单,但是它比较容易记住并非常接近实际规则,适合日常使用。 </p>
-
-<p>举一个更复杂的偏特化的例子,考虑类 <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>。这个类只定义一个唯一的 -typedef 成员 <code class="computeroutput"><span class="identifier">type</span></code>,它和 T 是同一个类型,但会移除任何顶层 数组的界限,这是一个在一个对某个类型执行转换的
-traits 类的例子:</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a>
+<p>
+ This rule is by no means foolproof, but it is reasonably simple to remember + and close enough to the actual rule to be useful for everyday use.<br> &#36825;&#20010;&#35268;&#21017;&#30456;&#24403;&#31616;&#21333;&#65292;&#20294;&#26159;&#23427;&#27604;&#36739;&#23481;&#26131;&#35760;&#20303;&#24182;&#38750;&#24120;&#25509;&#36817;&#23454;&#38469;&#35268;&#21017;&#65292;&#36866;&#21512;&#26085;&#24120;&#20351;&#29992;&#12290;
+    </p>
+<p>
+ As a more complex example of partial specialization consider the class <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>. This + class defines a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code> + that is the same type as T but with any top-level array bounds removed; this + is an example of a traits class that performs a transformation on a type:<br> + &#20030;&#19968;&#20010;&#26356;&#22797;&#26434;&#30340;&#20559;&#29305;&#21270;&#30340;&#20363;&#23376;&#65292;&#32771;&#34385;&#31867; <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>&#12290;&#36825;&#20010;&#31867;&#21482;&#23450;&#20041;&#19968;&#20010;&#21807;&#19968;&#30340; + typedef &#25104;&#21592; <code class="computeroutput"><span class="identifier">type</span></code>&#65292;&#23427;&#21644; + T &#26159;&#21516;&#19968;&#20010;&#31867;&#22411;&#65292;&#20294;&#20250;&#31227;&#38500;&#20219;&#20309;&#39030;&#23618;&#25968;&#32452;&#30340;&#30028;&#38480;&#65292;&#36825;&#26159;&#19968;&#20010;&#22312;&#19968;&#20010;&#23545;&#26576;&#20010;&#31867;&#22411;&#25191;&#34892;&#36716;&#25442;&#30340;
+      traits &#31867;&#30340;&#20363;&#23376;&#65306;
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a> <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>

-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]&gt;</span> +<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">[</span><span class="identifier">N</span><span class="special">]&gt;</span> <span class="special">{</span> <span class="keyword">typedef</span> <span class="identifier">T</span> <span class="identifier">type</span><span class="special">;</span> <span class="special">};</span>
 </pre>
-
-<p><code class="computeroutput"><a title=" remove_extent" href="reference/remove_extent.html">remove_extent</a></code> -的目的是:设想一个泛型算法被传递过来一个数组类型作为模板参数,<code class="computeroutput"><a title=" remove_extent" href="reference/remove_extent.html">remove_extent</a></code> -提供了一个检测这个数组的底层类型的手段。例如 <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></code> 会 被检测出类型 <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>。这个例子也展示 了偏特化中的模板参数的个数和缺省模板中的个数不必相同。但是,出现在类名后面的 参数的个数和类型必须和缺省模板的参数的个数和类型相同。</p>
-<a name="boost_typetraits.background.optimized_copy"></a>
-<h5>
-<a name="id2636072"></a>
- <a class="link" href="background.html#boost_typetraits.background.optimized_copy">优化拷贝 </a>
+<p>
+ The aim of <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + is this: imagine a generic algorithm that is passed an array type as a template + parameter, <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + provides a means of determining the underlying type of the array. For example + <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></code> would evaluate to the type <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>. This example also shows that the number of + template parameters in a partial specialization does not have to match the + number in the default template. However, the number of parameters that appear + after the class name do have to match the number and type of the parameters + in the default template.<br> <code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + &#30340;&#30446;&#30340;&#26159;&#65306;&#35774;&#24819;&#19968;&#20010;&#27867;&#22411;&#31639;&#27861;&#34987;&#20256;&#36882;&#36807;&#26469;&#19968;&#20010;&#25968;&#32452;&#31867;&#22411;&#20316;&#20026;&#27169;&#26495;&#21442;&#25968;&#65292;<code class="computeroutput"><a class="link" href="reference/remove_extent.html" title="remove_extent">remove_extent</a></code> + &#25552;&#20379;&#20102;&#19968;&#20010;&#26816;&#27979;&#36825;&#20010;&#25968;&#32452;&#30340;&#24213;&#23618;&#31867;&#22411;&#30340;&#25163;&#27573;&#12290;&#20363;&#22914; <code class="computeroutput"><span class="identifier">remove_extent</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">[</span><span class="number">4</span><span class="special">][</span><span class="number">5</span><span class="special">]&gt;::</span><span class="identifier">type</span></code> &#20250;&#34987;&#26816;&#27979;&#20986;&#31867;&#22411; <code class="computeroutput"><span class="keyword">int</span><span class="special">[</span><span class="number">5</span><span class="special">]</span></code>&#12290; &#36825;&#20010;&#20363;&#23376;&#20063;&#23637;&#31034;&#20102;&#20559;&#29305;&#21270;&#20013;&#30340;&#27169;&#26495;&#21442;&#25968;&#30340;&#20010;&#25968;&#21644;&#32570;&#30465;&#27169;&#26495;&#20013;&#30340;&#20010;&#25968;&#19981;&#24517;&#30456;&#21516;&#12290; + &#20294;&#26159;&#65292;&#20986;&#29616;&#22312;&#31867;&#21517;&#21518;&#38754;&#30340;&#21442;&#25968;&#30340;&#20010;&#25968;&#21644;&#31867;&#22411;&#24517;&#39035;&#21644;&#32570;&#30465;&#27169;&#26495;&#30340;&#21442;&#25968;&#30340;&#20010;&#25968;&#21644;&#31867;&#22411;&#30456;&#21516;&#12290;
+    </p>
+<a name="boost_typetraits.background.optimized_copy_____________"></a><h5>
+<a name="id4807498"></a>
+ <a class="link" href="background.html#boost_typetraits.background.optimized_copy_____________">Optimized
+      copy &#20248;&#21270;&#22797;&#21046;</a>
     </h5>
-
-<p>给一个 type traits 类如何使用的例子,考虑模板库算法 copy:</p>
+<p>
+ As an example of how the type traits classes can be used, consider the standard + library algorithm copy:<br> &#32473;&#19968;&#20010; type traits &#31867;&#22914;&#20309;&#20351;&#29992;&#30340;&#20363;&#23376;&#65292;&#32771;&#34385;&#27169;&#26495;&#24211;&#31639;&#27861;
+      copy&#65306;
+    </p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Iter1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Iter2</span><span class="special">&gt;</span> <span class="identifier">Iter2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">Iter1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iter1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">Iter2</span> <span class="identifier">out</span><span class="special">);</span>
 </pre>
-
-<p>很明显,写一个适用于所有迭代器类型 <code class="computeroutput"><span class="identifier">Iter1</span></code> 和 <code class="computeroutput"><span class="identifier">Iter2</span></code> 的泛型版 本没有问题,但是,在一些情形,最好能通过调用 <code class="computeroutput"><span class="identifier">memcpy</span></code> 来执行 拷贝操作。为了使用
-<code class="computeroutput"><span class="identifier">memcpy</span></code>
-执行拷贝,需要满足下面的所有条件:</p>
-
-<div class="itemizedlist">
-<ul type="disc">
- <li>迭代器类型 <code class="computeroutput"><span class="identifier">Iter1</span></code> -和 <code class="computeroutput"><span class="identifier">Iter2</span></code> 必须都是指针。
-  </li>
- <li><code class="computeroutput"><span class="identifier">Iter1</span></code> 和 - <code class="computeroutput"><span class="identifier">Iter2</span></code>
-必须都指向同样的类型&mdash;&mdash; const 和 volatile 修饰符可不予考虑。
-  </li>
- <li>被 <code class="computeroutput"><span class="identifier">Iter1</span></code>
-指向的类型必须有一个 trivial(不特殊)的赋值操作符。 </li>
-</ul>
-</div>
-
-<p>所谓 trivial(非特殊)的赋值操作符,我们指的是这个类型要么是一个 scalar type(标量类型)<a href="background.html#background.references">[3]</a> 要 么:</p>
-
-<div class="itemizedlist">
-<ul type="disc">
-  <li>这个类型没有用户定义的赋值操作符。
-  </li>
-  <li>这个类型没有任何一个数据成员是引用。
-  </li>
- <li>所有的基类,或所有数据成员对象必须有 trivial(非特殊)的赋值操作符。 </li>
-</ul>
-</div>
-
-<p>如果这些条件都被满足,那么这个类型就可以用 <code class="computeroutput"><span class="identifier">memcpy</span></code> 执行拷 贝,而不使用编译器生成的赋值操作符。type-traits 库提供了一个类 -<code class="computeroutput"><a title=" has_trivial_assign" href="reference/has_trivial_assign.html">has_trivial_assign</a></code>,它的 意思是只有 -T 有一个 trivial(不特殊)的赋值操作符,<code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> 才 成立。这个类仅对标量类型能&ldquo;正确地工作&rdquo;,除非为具有一个 -trivial(非特殊)的赋值操作符的 class/struct 类型进行显式特化。换句话说,如 果 <a title=" has_trivial_assign" href="reference/has_trivial_assign.html">has_trivial_assign</a> -给出一个错误答案,它会给出一个&ldquo;安全的&rdquo;错误答案&mdash;&mdash;那 个 trivial(非特殊)的赋值是不被允许的。</p>
-
-<p>使用 <code class="computeroutput"><span class="identifier">memcpy</span></code> 的 -copy 的优化版本代码在<a title=" An Optimized Version of std::copy" href="examples/copy.html">示例</a>中给出。代码以定义一个模板函数 <code class="computeroutput"><span class="identifier">do_copy</span></code> -开始,这个函数执行一个&ldquo;慢但是安全&rdquo;的拷贝。传给这个函数的最后一 个参数既可能是一个 <code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">true_type</a></code>,也可能是一个 -<code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">false_type</a></code>。然后有一个使 -<code class="computeroutput"><span class="identifier">memcpy</span></code> 的 do_copy -的重载:这时要求迭代器实际上是一个指向相同类型的指针,而且最后一个参数必须 是一个 <code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">true_type</a></code>。最后,<code class="computeroutput"><span class="identifier">copy</span></code> 的这个版 本调用 <code class="computeroutput"><span class="identifier">do_copy</span></code>,将 <code class="computeroutput"><a title=" has_trivial_assign" href="reference/has_trivial_assign.html">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;()</span></code> 作为最后一个参数。如果优化版本更合适就 会匹配到优化版本,否则就调用&ldquo;慢但是安全的版本&rdquo;。</p>
-<a name="boost_typetraits.background.was_it_worth_it_"></a>
-<h5>
-<a name="id2636516"></a>
- <a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_">这是值得 的吗?</a>
+<p>
+ Obviously, there's no problem writing a generic version of copy that works + for all iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code> + and <code class="computeroutput"><span class="identifier">Iter2</span></code>; however, there are + some circumstances when the copy operation can best be performed by a call + to <code class="computeroutput"><span class="identifier">memcpy</span></code>. In order to implement + copy in terms of <code class="computeroutput"><span class="identifier">memcpy</span></code> all + of the following conditions need to be met:<br> &#24456;&#26126;&#26174;&#65292;&#20889;&#19968;&#20010;&#36866;&#29992;&#20110;&#25152;&#26377;&#36845;&#20195;&#22120;&#31867;&#22411; + <code class="computeroutput"><span class="identifier">Iter1</span></code> &#21644; <code class="computeroutput"><span class="identifier">Iter2</span></code> + &#30340;&#27867;&#22411;&#29256;&#26412;&#27809;&#26377;&#38382;&#39064;&#65292;&#20294;&#26159;&#65292;&#22312;&#19968;&#20123;&#24773;&#24418;&#65292;&#26368;&#22909;&#33021;&#36890;&#36807;&#35843;&#29992; + <code class="computeroutput"><span class="identifier">memcpy</span></code> &#26469;&#25191;&#34892;&#25335;&#36125;&#25805;&#20316;&#12290; + &#20026;&#20102;&#20351;&#29992; <code class="computeroutput"><span class="identifier">memcpy</span></code> &#25191;&#34892;&#25335;&#36125;&#65292;&#38656;&#35201;&#28385;&#36275;&#19979;&#38754;&#30340;&#25152;&#26377;&#26465;&#20214;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Both of the iterator types <code class="computeroutput"><span class="identifier">Iter1</span></code> + and <code class="computeroutput"><span class="identifier">Iter2</span></code> must be pointers. + <br> &#36845;&#20195;&#22120;&#31867;&#22411; <code class="computeroutput"><span class="identifier">Iter1</span></code> + &#21644; <code class="computeroutput"><span class="identifier">Iter2</span></code> &#24517;&#39035;&#37117;&#26159;&#25351;&#38024;&#12290;
+      </li>
+<li>
+ Both <code class="computeroutput"><span class="identifier">Iter1</span></code> and <code class="computeroutput"><span class="identifier">Iter2</span></code> must point to the same type - excluding + const and volatile-qualifiers. <br><code class="computeroutput"><span class="identifier">Iter1</span></code> + &#21644; <code class="computeroutput"><span class="identifier">Iter2</span></code> &#24517;&#39035;&#37117;&#25351;&#21521;&#21516;&#26679;&#30340;&#31867;&#22411;&#8212;&#8212; + const &#21644; volatile &#20462;&#39280;&#31526;&#21487;&#19981;&#20104;&#32771;&#34385;&#12290;
+      </li>
+<li>
+ The type pointed to by <code class="computeroutput"><span class="identifier">Iter1</span></code> + must have a trivial assignment operator. <br> &#34987; <code class="computeroutput"><span class="identifier">Iter1</span></code> + &#25351;&#21521;&#30340;&#31867;&#22411;&#24517;&#39035;&#26377;&#19968;&#20010; trivial&#65288;&#19981;&#29305;&#27530;&#65289;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#12290;
+      </li>
+</ul></div>
+<p>
+ By trivial assignment operator we mean that the type is either a scalar type<a class="link" href="background.html#background.references">[3]</a> or:<br> &#25152;&#35859; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#65292;&#25105;&#20204;&#25351;&#30340;&#26159;&#36825;&#20010;&#31867;&#22411;&#35201;&#20040;&#26159;&#19968;&#20010; + scalar type&#65288;&#26631;&#37327;&#31867;&#22411;&#65289;<a class="link" href="background.html#background.references">[3]</a>
+      &#35201;&#20040;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ The type has no user defined assignment operator. <br> &#36825;&#20010;&#31867;&#22411;&#27809;&#26377;&#29992;&#25143;&#23450;&#20041;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#12290;
+      </li>
+<li>
+ The type does not have any data members that are references. <br> &#36825;&#20010;&#31867;&#22411;&#27809;&#26377;&#20219;&#20309;&#19968;&#20010;&#25968;&#25454;&#25104;&#21592;&#26159;&#24341;&#29992;&#12290;
+      </li>
+<li>
+ All base classes, and all data member objects must have trivial assignment + operators. <br> &#25152;&#26377;&#30340;&#22522;&#31867;&#65292;&#25110;&#25152;&#26377;&#25968;&#25454;&#25104;&#21592;&#23545;&#35937;&#24517;&#39035;&#26377; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#12290;
+      </li>
+</ul></div>
+<p>
+ If all these conditions are met then a type can be copied using <code class="computeroutput"><span class="identifier">memcpy</span></code> rather than using a compiler generated + assignment operator. The type-traits library provides a class <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code>, + such that <code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is true only if T has a trivial assignment
+      operator. This class "just works" for scalar types, but has to be
+ explicitly specialised for class/struct types that also happen to have a trivial + assignment operator. In other words if <a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a>
+      gives the wrong answer, it will give the "safe" wrong answer - that
+ trivial assignment is not allowable.<br> &#22914;&#26524;&#36825;&#20123;&#26465;&#20214;&#37117;&#34987;&#28385;&#36275;&#65292;&#37027;&#20040;&#36825;&#20010;&#31867;&#22411;&#23601;&#21487;&#20197;&#29992; + <code class="computeroutput"><span class="identifier">memcpy</span></code> &#25191;&#34892;&#25335;&#36125;&#65292;&#32780;&#19981;&#20351;&#29992;&#32534;&#35793;&#22120;&#29983;&#25104;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#12290; + type-traits &#24211;&#25552;&#20379;&#20102;&#19968;&#20010;&#31867; <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code>&#65292;&#23427;&#30340;&#24847;&#24605;&#26159;&#21482;&#26377; + T &#26377;&#19968;&#20010; trivial&#65288;&#19981;&#29305;&#27530;&#65289; &#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#65292;<code class="computeroutput"><span class="identifier">has_trivial_assign</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> &#25165;&#25104;&#31435;&#12290;&#36825;&#20010;&#31867;&#20165;&#23545;&#26631;&#37327;&#31867;&#22411;&#33021;&#8220;&#27491;&#30830;&#22320;&#24037;&#20316;&#8221;&#65292;&#38500;&#38750;&#20026;&#20855;&#26377;&#19968;&#20010; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#30340; class/struct &#31867;&#22411;&#36827;&#34892;&#26174;&#24335;&#29305;&#21270;&#12290; + &#25442;&#21477;&#35805;&#35828;&#65292;&#22914;&#26524; <a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a> + &#32473;&#20986;&#19968;&#20010;&#38169;&#35823;&#31572;&#26696;&#65292;&#23427;&#20250;&#32473;&#20986;&#19968;&#20010;&#8220;&#23433;&#20840;&#30340;&#8221;&#38169;&#35823;&#31572;&#26696;&#8212;&#8212;&#37027;&#20010; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#36171;&#20540;&#26159;&#19981;&#34987;&#20801;&#35768;&#30340;&#12290;
+    </p>
+<p>
+ The code for an optimized version of copy that uses <code class="computeroutput"><span class="identifier">memcpy</span></code> + where appropriate is given in <a class="link" href="examples/copy.html" title="An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy">the + examples</a>. The code begins by defining a template function <code class="computeroutput"><span class="identifier">do_copy</span></code> that performs a "slow but safe" + copy. The last parameter passed to this function may be either a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + or a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code>. + Following that there is an overload of <code class="computeroutput"><span class="identifier">do_copy</span></code> + that uses <code class="computeroutput"><span class="identifier">memcpy</span></code>: this time + the iterators are required to actually be pointers to the same type, and the + final parameter must be a <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>. + Finally, the version of <code class="computeroutput"><span class="identifier">copy</span></code> + calls <code class="computeroutput"><span class="identifier">do_copy</span></code>, passing <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;()</span></code> as the final parameter: this will dispatch + to the optimized version where appropriate, otherwise it will call the "slow + but safe version".<br> &#20351;&#29992; <code class="computeroutput"><span class="identifier">memcpy</span></code> + &#30340; copy &#30340;&#20248;&#21270;&#29256;&#26412;&#20195;&#30721;&#22312; <a class="link" href="examples/copy.html" title="An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy">&#31034;&#20363;</a> + &#20013;&#32473;&#20986;&#12290; &#20195;&#30721;&#20197;&#23450;&#20041;&#19968;&#20010;&#27169;&#26495;&#20989;&#25968; <code class="computeroutput"><span class="identifier">do_copy</span></code> + &#24320;&#22987;&#65292;&#36825;&#20010;&#20989;&#25968;&#25191;&#34892;&#19968;&#20010;&#8220;&#24930;&#20294;&#26159;&#23433;&#20840;&#8221;&#30340;&#25335;&#36125;&#12290; &#20256;&#32473;&#36825;&#20010;&#20989;&#25968;&#30340;&#26368;&#21518;&#19968;&#20010;&#21442;&#25968;&#26082;&#21487;&#33021;&#26159;&#19968;&#20010; + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>&#65292;&#20063;&#21487;&#33021;&#26159;&#19968;&#20010; + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code>&#12290; + &#28982;&#21518;&#26377;&#19968;&#20010;&#20351;&#29992; <code class="computeroutput"><span class="identifier">memcpy</span></code> + &#30340; <code class="computeroutput"><span class="identifier">do_copy</span></code> &#30340;&#37325;&#36733;&#65306;&#36825;&#26102;&#35201;&#27714;&#36845;&#20195;&#22120;&#23454;&#38469;&#19978;&#26159;&#19968;&#20010;&#25351;&#21521;&#30456;&#21516;&#31867;&#22411;&#30340;&#25351;&#38024;&#65292;&#32780;&#19988;&#26368;&#21518;&#19968;&#20010;&#21442;&#25968;&#24517;&#39035;&#26159;&#19968;&#20010; + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code>&#12290; + &#26368;&#21518;&#65292;<code class="computeroutput"><span class="identifier">copy</span></code> &#30340;&#36825;&#20010;&#29256;&#26412;&#35843;&#29992; + <code class="computeroutput"><span class="identifier">do_copy</span></code>&#65292;&#23558; <code class="computeroutput"><a class="link" href="reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;()</span></code> &#20316;&#20026;&#26368;&#21518;&#19968;&#20010;&#21442;&#25968;&#12290; &#22914;&#26524;&#20248;&#21270;&#29256;&#26412;&#26356;&#21512;&#36866;&#23601;&#20250;&#21305;&#37197;&#21040;&#20248;&#21270;&#29256;&#26412;&#65292;&#21542;&#21017;&#23601;&#35843;&#29992;&#8220;&#24930;&#20294;&#26159;&#23433;&#20840;&#30340;&#29256;&#26412;&#8221;&#12290;
+    </p>
+<a name="boost_typetraits.background.was_it_worth_it_______________________"></a><h5>
+<a name="id4808360"></a>
+ <a class="link" href="background.html#boost_typetraits.background.was_it_worth_it_______________________">Was + it worth it? &#36825;&#26159;&#20540;&#24471;&#30340;&#21527;&#65311;</a>
     </h5>
-
-<p>有一句名言经常被重复提到:&ldquo;不成熟的优化是一切罪恶的根源&rdquo; <a href="background.html#background.references">[4]</a>。所以必须要问:我们的优 化是成熟的吗?我们版本的 -copy 和传统泛型 copy <a href="background.html#background.references">[5]</a> 的时间比较展示在
-table 1 中。</p>
-
-<p>很明显,在这种情况下优化造成了区别,但是,为了公平,表中的时间排除了缓存 失误的影响&mdash;&mdash;如果不排除这一点,算法的精确比较是很困难的。无论如 何,也许我们可以增加一些告诫,作为判别不成熟优化的法则:</p>
-
-<div class="itemizedlist">
-<ul type="disc">
- <li>如果你一上来就使用了对于这个任务正确的算法,那么就不需要优化,在某些 情况下,memcpy 是正确的算法。
-  </li>
- <li>如果一个组件被很多人在很多地方复用,那么优化就是值得的,即使对其中的 单独一种情况来说也许没有必要&mdash;&mdash;换句话 -说,优化在是某地是绝对必要的这种可能性还是比较高的。一个常备实现的可感知价 值应该比较高,这是非常重要的:如果用户当场拒绝一个算法,而使用更好的,
-优化度更高的版本,那么标准化这个算法就是毫无道理的。</li>
-</ul>
-</div>
+<p>
+ It has often been repeated in these columns that "premature optimization + is the root of all evil" <a class="link" href="background.html#background.references">[4]</a>. + So the question must be asked: was our optimization premature? To put this + in perspective the timings for our version of copy compared a conventional + generic copy<a class="link" href="background.html#background.references">[5]</a> are shown in table + 1.<br> &#26377;&#19968;&#21477;&#21517;&#35328;&#32463;&#24120;&#34987;&#37325;&#22797;&#25552;&#21040;&#65306;&#8220;&#19981;&#25104;&#29087;&#30340;&#20248;&#21270;&#26159;&#19968;&#20999;&#32618;&#24694;&#30340;&#26681;&#28304;&#8221; + <a class="link" href="background.html#background.references">[4]</a>&#12290; &#25152;&#20197;&#24517;&#39035;&#35201;&#38382;&#65306;&#25105;&#20204;&#30340;&#20248;&#21270;&#26159;&#25104;&#29087;&#30340;&#21527;&#65311;&#25105;&#20204;&#29256;&#26412;&#30340; + copy &#21644;&#20256;&#32479;&#27867;&#22411; copy <a class="link" href="background.html#background.references">[5]</a> + &#30340;&#26102;&#38388;&#27604;&#36739;&#23637;&#31034;&#22312;&#34920;1&#20013;&#12290;
+    </p>
+<p>
+ Clearly the optimization makes a difference in this case; but, to be fair, + the timings are loaded to exclude cache miss effects - without this accurate + comparison between algorithms becomes difficult. However, perhaps we can add + a couple of caveats to the premature optimization rule:<br> &#24456;&#26126;&#26174;&#65292;&#22312;&#36825;&#31181;&#24773;&#20917;&#19979;&#20248;&#21270;&#36896;&#25104;&#20102;&#21306;&#21035;&#65292;&#20294;&#26159;&#65292;&#20026;&#20102;&#20844;&#24179;&#65292;&#34920;&#20013;&#30340;&#26102;&#38388;&#25490;&#38500;&#20102;&#32531;&#23384;&#22833;&#35823;&#30340;&#24433;&#21709; + &#8212;&#8212; &#22914;&#26524;&#19981;&#25490;&#38500;&#36825;&#19968;&#28857;&#65292;&#31639;&#27861;&#30340;&#31934;&#30830;&#27604;&#36739;&#26159;&#24456;&#22256;&#38590;&#30340;&#12290;&#26080;&#35770;&#22914;&#20309;&#65292;&#20063;&#35768;&#25105;&#20204;&#21487;&#20197;&#22686;&#21152;&#19968;&#20123;&#21578;&#35819;&#65292;&#20316;&#20026;&#21028;&#21035;&#19981;&#25104;&#29087;&#20248;&#21270;&#30340;&#27861;&#21017;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ If you use the right algorithm for the job in the first place then optimization + will not be required; in some cases, memcpy is the right algorithm. <br> + &#22914;&#26524;&#20320;&#19968;&#19978;&#26469;&#23601;&#20351;&#29992;&#20102;&#23545;&#20110;&#36825;&#20010;&#20219;&#21153;&#27491;&#30830;&#30340;&#31639;&#27861;&#65292;&#37027;&#20040;&#23601;&#19981;&#38656;&#35201;&#20248;&#21270;&#65292;&#22312;&#26576;&#20123;&#24773;&#20917;&#19979;&#65292;memcpy
+        &#26159;&#27491;&#30830;&#30340;&#31639;&#27861;&#12290;
+      </li>
+<li>
+ If a component is going to be reused in many places by many people then optimizations + may well be worthwhile where they would not be so for a single case - in + other words, the likelihood that the optimization will be absolutely necessary + somewhere, sometime is that much higher. Just as importantly the perceived + value of the stock implementation will be higher: there is no point standardizing + an algorithm if users reject it on the grounds that there are better, more + heavily optimized versions available. <br> &#22914;&#26524;&#19968;&#20010;&#32452;&#20214;&#34987;&#24456;&#22810;&#20154;&#22312;&#24456;&#22810;&#22320;&#26041;&#22797;&#29992;&#65292;&#37027;&#20040;&#20248;&#21270;&#23601;&#26159;&#20540;&#24471;&#30340;&#65292;&#21363;&#20351;&#23545;&#20854;&#20013;&#30340;&#21333;&#29420;&#19968;&#31181;&#24773;&#20917;&#26469;&#35828;&#20063;&#35768;&#27809;&#26377;&#24517;&#35201; + &#8212;&#8212; &#25442;&#21477;&#35805;&#35828;&#65292;&#20248;&#21270;&#22312;&#26159;&#26576;&#22320;&#26159;&#32477;&#23545;&#24517;&#35201;&#30340;&#36825;&#31181;&#21487;&#33021;&#24615;&#36824;&#26159;&#27604;&#36739;&#39640;&#30340;&#12290; + &#19968;&#20010;&#24120;&#22791;&#23454;&#29616;&#30340;&#21487;&#24863;&#30693;&#20215;&#20540;&#24212;&#35813;&#27604;&#36739;&#39640;&#65292;&#36825;&#26159;&#38750;&#24120;&#37325;&#35201;&#30340;&#65306;&#22914;&#26524;&#29992;&#25143;&#24403;&#22330;&#25298;&#32477;&#19968;&#20010;&#31639;&#27861;&#65292;&#32780;&#20351;&#29992;&#26356;&#22909;&#30340;&#65292; + &#20248;&#21270;&#24230;&#26356;&#39640;&#30340;&#29256;&#26412;&#65292;&#37027;&#20040;&#26631;&#20934;&#21270;&#36825;&#20010;&#31639;&#27861;&#23601;&#26159;&#27627;&#26080;&#36947;&#29702;&#30340;&#12290;
+      </li>
+</ul></div>
 <div class="table">
-<a name="id2636577"></a>
-<p class="title"><b>表&nbsp;1.1. 使用 `copy&lt;const
-    T*, T*&gt;` 拷贝1000个元素花费的时间(微秒)</b></p>
-
-<div class="table-contents">
-<table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const
-    T*, T*&gt;` (times in micro-seconds)">
-
-  <colgroup><col><col><col></colgroup>
-  <thead><tr>
-
-    <th>
-
-    <p>版本
-          </p>
-
-          </th>
-
-    <th>
-
-    <p>
-            T
-          </p>
-
-          </th>
-
-    <th>
-
-    <p>时间
-          </p>
-
-          </th>
-
-  </tr>
-  </thead>
-  <tbody>
-
-    <tr>
-
-      <td>
-
-      <p>
-            "Optimized" copy
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            char
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            0.99
-          </p>
-
-          </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
-            Conventional copy
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            char
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            8.07
-          </p>
-
-          </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
-            "Optimized" copy
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            int
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            2.52
-          </p>
-
-          </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
-            Conventional copy
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            int
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            8.02
-          </p>
-
-          </td>
-
-    </tr>
-
-  </tbody>
-</table>
+<a name="id4859984"></a><p class="title"><b>Table&#160;1.1.&#160;Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
+      in micro-seconds)</b></p>
+<div class="table-contents"><table class="table" summary="Time taken to copy 1000 elements using `copy&lt;const T*, T*&gt;` (times
+      in micro-seconds)">
+<colgroup>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                Version &#29256;&#26412;
+              </p>
+            </th>
+<th>
+              <p>
+                T
+              </p>
+            </th>
+<th>
+              <p>
+                Time &#26102;&#38388;
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                "Optimized" copy "&#20248;&#21270;"&#22797;&#21046;
+              </p>
+            </td>
+<td>
+              <p>
+                char
+              </p>
+            </td>
+<td>
+              <p>
+                0.99
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                Conventional copy &#27491;&#24120;&#22797;&#21046;
+              </p>
+            </td>
+<td>
+              <p>
+                char
+              </p>
+            </td>
+<td>
+              <p>
+                8.07
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                "Optimized" copy "&#20248;&#21270;"&#22797;&#21046;
+              </p>
+            </td>
+<td>
+              <p>
+                int
+              </p>
+            </td>
+<td>
+              <p>
+                2.52
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                Conventional copy &#27491;&#24120;&#22797;&#21046;
+              </p>
+            </td>
+<td>
+              <p>
+                int
+              </p>
+            </td>
+<td>
+              <p>
+                8.02
+              </p>
+            </td>
+</tr>
+</tbody>
+</table></div>
 </div>
-
-</div>
-
-<br class="table-break">
-<a name="boost_typetraits.background.pair_of_references"></a>
-<h5>
-<a name="id2636715"></a>
- <a class="link" href="background.html#boost_typetraits.background.pair_of_references">引用 的 Pair</a> +<br class="table-break"><a name="boost_typetraits.background.pair_of_references___________pair"></a><h5>
+<a name="id4860143"></a>
+ <a class="link" href="background.html#boost_typetraits.background.pair_of_references___________pair">Pair
+      of References &#24341;&#29992;&#30340; Pair</a>
     </h5>
-
-<p>优化拷贝示例展示了 type traits 如何被用于编译时的优化决策。type traits
-的另一个重要用途是是允许那些如果不使用额外的偏特化就无法编译的代码能够编 译。通过将偏特化委托给 type traits -类,就可能做到这一点。我们为这种使用方式提供的示例是一个可以持有引用的 pair <a href="background.html#background.references">[6]</a>。</p>
-
-<p>首先,我们先检查一下 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>
-的定义,为了简单,我们忽略比较操作符,缺省构造函数和模板拷贝构造函数:</p>
-<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span> <br><span class="keyword">struct</span> <span class="identifier">pair</span> <br><span class="special">{</span>
+<p>
+ The optimized copy example shows how type traits may be used to perform optimization + decisions at compile-time. Another important usage of type traits is to allow + code to compile that otherwise would not do so unless excessive partial specialization + is used. This is possible by delegating partial specialization to the type + traits classes. Our example for this form of usage is a pair that can hold + references <a class="link" href="background.html#background.references">[6]</a>.<br> &#20248;&#21270;&#25335;&#36125;&#31034;&#20363;&#23637;&#31034;&#20102; + type traits &#22914;&#20309;&#34987;&#29992;&#20110;&#32534;&#35793;&#26102;&#30340;&#20248;&#21270;&#20915;&#31574;&#12290; type traits &#30340;&#21478;&#19968;&#20010;&#37325;&#35201;&#29992;&#36884;&#26159;&#26159;&#20801;&#35768;&#37027;&#20123;&#22914;&#26524;&#19981;&#20351;&#29992;&#39069;&#22806;&#30340;&#20559;&#29305;&#21270;&#23601;&#26080;&#27861;&#32534;&#35793;&#30340;&#20195;&#30721;&#33021;&#22815;&#32534;&#35793;&#12290; + &#36890;&#36807;&#23558;&#20559;&#29305;&#21270;&#22996;&#25176;&#32473; type traits &#31867;&#65292;&#23601;&#21487;&#33021;&#20570;&#21040;&#36825;&#19968;&#28857;&#12290; &#25105;&#20204;&#20026;&#36825;&#31181;&#20351;&#29992;&#26041;&#24335;&#25552;&#20379;&#30340;&#31034;&#20363;&#26159;&#19968;&#20010;&#21487;&#20197;&#25345;&#26377;&#24341;&#29992;&#30340; + pair <a class="link" href="background.html#background.references">[6]</a>&#12290;
+    </p>
+<p>
+ First, let us examine the definition of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>, omitting + the comparison operators, default constructor, and template copy constructor + for simplicity:<br> &#39318;&#20808;&#65292;&#25105;&#20204;&#20808;&#26816;&#26597;&#19968;&#19979; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code> &#30340;&#23450;&#20041;&#65292;&#20026;&#20102;&#31616;&#21333;&#65292;&#25105;&#20204;&#24573;&#30053;&#27604;&#36739;&#25805;&#20316;&#31526;&#65292;&#32570;&#30465;&#26500;&#36896;&#20989;&#25968;&#21644;&#27169;&#26495;&#25335;&#36125;&#26500;&#36896;&#20989;&#25968;&#65306;
+    </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T2</span><span class="special">&gt;</span>
+<span class="keyword">struct</span> <span class="identifier">pair</span>
+<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">T1</span> <span class="identifier">first_type</span><span class="special">;</span> <span class="keyword">typedef</span> <span class="identifier">T2</span> <span class="identifier">second_type</span><span class="special">;</span>

@@ -396,241 +502,176 @@
<span class="special">:</span><span class="identifier">first</span><span class="special">(</span><span class="identifier">nfirst</span><span class="special">),</span> <span class="identifier">second</span><span class="special">(</span><span class="identifier">nsecond</span><span class="special">)</span> <span class="special">{</span> <span class="special">}</span>
 <span class="special">};</span>
 </pre>
-
-<p>现在,这个 "pair" 不能持有引用作为它的当前支点,因为这样一来构造函数就要 接受一个引用的引用,这在当前是非法的 <a href="background.html#background.references">[7]</a>。我们来考虑一下为了 让 "pair"
-持有非引用类型,引用,和常引用,构造函数的参数必须是什么样的:</p>
+<p>
+ Now, this "pair" cannot hold references as it currently stands, because + the constructor would require taking a reference to a reference, which is currently + illegal <a class="link" href="background.html#background.references">[7]</a>. Let us consider what + the constructor's parameters would have to be in order to allow "pair" + to hold non-reference types, references, and constant references:<br> &#29616;&#22312;&#65292;&#36825;&#20010; + "pair" &#19981;&#33021;&#25345;&#26377;&#24341;&#29992;&#20316;&#20026;&#23427;&#30340;&#24403;&#21069;&#25903;&#28857;&#65292;&#22240;&#20026;&#36825;&#26679;&#19968;&#26469;&#26500;&#36896;&#20989;&#25968;&#23601;&#35201;&#25509;&#21463;&#19968;&#20010;&#24341;&#29992;&#30340;&#24341;&#29992;&#65292;&#36825;&#22312;&#24403;&#21069;&#26159;&#38750;&#27861;&#30340; + <a class="link" href="background.html#background.references">[7]</a>&#12290;&#25105;&#20204;&#26469;&#32771;&#34385;&#19968;&#19979;&#20026;&#20102;&#35753; + "pair" &#25345;&#26377;&#38750;&#24341;&#29992;&#31867;&#22411;&#65292;&#24341;&#29992;&#65292;&#21644;&#24120;&#24341;&#29992;&#65292;&#26500;&#36896;&#20989;&#25968;&#30340;&#21442;&#25968;&#24517;&#39035;&#26159;&#20160;&#20040;&#26679;&#30340;&#65306;
+    </p>
 <div class="table">
-<a name="id2637023"></a>
-<p class="title"><b>表&nbsp;1.2. 要求的构造函数参数类型</b></p>
-
-<div class="table-contents">
-<table class="table" summary="Required Constructor Argument Types">
-
-  <colgroup><col><col></colgroup>
-  <thead><tr>
-
-    <th>
-
- <p> <code class="computeroutput"><span class="identifier">T1</span></code> - 的类型<code class="computeroutput"><span class="identifier"></span></code>
-          </p>
-
-          </th>
-
-    <th>
-
-    <p>传给初始构造函数的参数的类型
-          </p>
-
-          </th>
-
-  </tr>
-  </thead>
-  <tbody>
-
-    <tr>
-
-      <td>
-
-      <p>
-            T
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            const T &amp;
-          </p>
-
-          </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
-            T &amp;
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            T &amp;
-          </p>
-
-          </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
-            const T &amp;
-          </p>
-
-          </td>
-
-      <td>
-
-      <p>
-            const T &amp;
-          </p>
-
-          </td>
-
-    </tr>
-
-  </tbody>
-</table>
+<a name="id4860509"></a><p class="title"><b>Table&#160;1.2.&#160;Required Constructor Argument Types &#35201;&#27714;&#30340;&#26500;&#36896;&#20989;&#25968;&#21442;&#25968;&#31867;&#22411;</b></p> +<div class="table-contents"><table class="table" summary="Required Constructor Argument Types &#35201;&#27714;&#30340;&#26500;&#36896;&#20989;&#25968;&#21442;&#25968;&#31867;&#22411;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+ Type of <code class="computeroutput"><span class="identifier">T1</span></code>
+              </p>
+            </th>
+<th>
+              <p>
+ Type of parameter to initializing constructor &#20256;&#32473;&#21021;&#22987;&#26500;&#36896;&#20989;&#25968;&#30340;&#21442;&#25968;&#30340;&#31867;&#22411;
+              </p>
+            </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+              <p>
+                T
+              </p>
+            </td>
+<td>
+              <p>
+                const T &amp;
+              </p>
+            </td>
+</tr>
+<tr>
+<td>
+              <p>
+                T &amp;
+              </p>
+            </td>
+<td>
+              <p>
+                T &amp;
***The diff for this file has been truncated for email.***
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/alignment.html Wed Jun 2 00:58:52 2010
@@ -1,105 +1,65 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-
-
-  <title>Synthesizing Types with Specific Alignments</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../category.html" title="Type Traits by Category">
-
- <link rel="prev" href="transform.html" title="Type Traits that Transform One Type to Another">
-
-  <link rel="next" href="function.html" title="Decomposing Function Types">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Synthesizing Types with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> +<link rel="prev" href="transform.html" title="Type Traits that Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits"> +<link rel="next" href="function.html" title="Decomposing Function Types &#35299;&#26512;&#20989;&#25968;&#31867;&#22411;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="transform.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.category.alignment"></a><a class="link" href="alignment.html" title="Synthesizing Types with Specific Alignments"> &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>&#26576;&#20123;&#20302;&#23618;&#20869;&#23384;&#31649;&#29702;&#20363;&#31243;&#38656;&#35201;&#25353;&#29031;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#19968;&#20010; POD (Plain Old Data) &#31867;&#22411;&#12290;&#27169;&#26495; <code class="computeroutput"><a title=" type_with_alignment" href="../reference/type_with_alignment.html">type_with_alignment</a></code> -&#25214;&#20986;&#31526;&#21512;&#19968;&#20010;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#30340;&#26368;&#23567;&#31867;&#22411;&#65292;&#27169;&#26495; <code class="computeroutput"><a title=" aligned_storage" href="../reference/aligned_storage.html">aligned_storage</a></code>
-&#21019;&#24314;&#19968;&#20010;&#20855;&#26377;&#25351;&#23450;&#22823;&#23567;&#21644;&#23545;&#40784;&#26041;&#24335;&#30340;&#31867;&#22411;&#12290;</p>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.alignment"></a><a class="link" href="alignment.html" title="Synthesizing Types with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;"> Synthesizing Types + with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;</a>
+</h3></div></div></div>
 <p>
-        <span class="bold"><strong>&#27010;&#35201;</strong></span>
+ Some low level memory management routines need to synthesize a POD type with + specific alignment properties. The template <code class="computeroutput"><a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a></code> + finds the smallest type with a specified alignment, while template <code class="computeroutput"><a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a></code> + creates a type with a specific size and alignment.<br> &#26576;&#20123;&#20302;&#23618;&#20869;&#23384;&#31649;&#29702;&#20363;&#31243;&#38656;&#35201;&#25353;&#29031;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#19968;&#20010; + POD &#31867;&#22411;&#12290;&#27169;&#26495; <code class="computeroutput"><a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a></code> + &#25214;&#20986;&#31526;&#21512;&#19968;&#20010;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#30340;&#26368;&#23567;&#31867;&#22411;&#65292;&#27169;&#26495; <code class="computeroutput"><a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a></code> + &#21019;&#24314;&#19968;&#20010;&#20855;&#26377;&#25351;&#23450;&#22823;&#23567;&#21644;&#23545;&#40784;&#26041;&#24335;&#30340;&#31867;&#22411;&#12290;
       </p>
-
+<p>
+ <span class="bold"><strong>Synopsis &#27010;&#35201;</strong></span>
+      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../reference/type_with_alignment.html" title="type_with_alignment">type_with_alignment</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Size</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../reference/aligned_storage.html" title="aligned_storage">aligned_storage</a><span class="special">;</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="transform.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="function.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/function.html Wed Jun 2 00:58:52 2010
@@ -1,102 +1,62 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Decomposing Function Types</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../category.html" title="Type Traits by Category">
-
- <link rel="prev" href="alignment.html" title="Synthesizing Types with Specific Alignments">
-
- <link rel="next" href="../user_defined.html" title="User Defined Specializations">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Decomposing Function Types &#35299;&#26512;&#20989;&#25968;&#31867;&#22411;</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> +<link rel="prev" href="alignment.html" title="Synthesizing Types with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;"> +<link rel="next" href="../user_defined.html" title="User Defined Specializations &#29992;&#25143;&#23450;&#20041;&#29305;&#21270;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types"> 解析函数类型</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>类模板 <a title=" function_traits" href="../reference/function_traits.html">function_traits</a> -从函数类型(参见 <a title=" is_function" href="../reference/is_function.html">is_function</a>)中提取信息。这个 -traits 类允许你知道一个函数持有多少个参数,那些参数的类型是什么,以及返回类 型是什么。</p>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.function"></a><a class="link" href="function.html" title="Decomposing Function Types &#35299;&#26512;&#20989;&#25968;&#31867;&#22411;"> Decomposing Function
+      Types &#35299;&#26512;&#20989;&#25968;&#31867;&#22411;</a>
+</h3></div></div></div>
 <p>
-        <span class="bold"><strong>概要</strong></span>
+ The class template <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a> + extracts information from function types (see also <a class="link" href="../reference/is_function.html" title="is_function">is_function</a>). + This traits class allows you to tell how many arguments a function takes, + what those argument types are, and what the return type is.<br> &#31867;&#27169;&#26495; + <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a> + &#20174;&#20989;&#25968;&#31867;&#22411;&#65288;&#21442;&#35265; <a class="link" href="../reference/is_function.html" title="is_function">is_function</a>&#65289;&#20013;&#25552;&#21462;&#20449;&#24687;&#12290; + &#36825;&#20010; traits &#31867;&#20801;&#35768;&#20320;&#30693;&#36947;&#19968;&#20010;&#20989;&#25968;&#25345;&#26377;&#22810;&#23569;&#20010;&#21442;&#25968;&#65292;&#37027;&#20123;&#21442;&#25968;&#30340;&#31867;&#22411;&#26159;&#20160;&#20040;&#65292;&#20197;&#21450;&#36820;&#22238;&#31867;&#22411;&#26159;&#20160;&#20040;&#12290;
       </p>
-
+<p>
+        <span class="bold"><strong>Synopsis</strong></span>
+      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Align</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../reference/function_traits.html" title="function_traits">function_traits</a><span class="special">;</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="alignment.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../user_defined.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/transform.html Wed Jun 2 00:58:52 2010
@@ -1,67 +1,43 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Type Traits that Transform One Type to Another</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../category.html" title="Type Traits by Category">
-
- <link rel="prev" href="value_traits/relate.html" title="Relationships Between Two Types">
-
- <link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Type Traits that Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> +<link rel="prev" href="value_traits/relate.html" title="Relationships Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;"> +<link rel="next" href="alignment.html" title="Synthesizing Types with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="value_traits/relate.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.category.transform"></a><a class="link" href="transform.html" title="Type Traits that Transform One Type to Another"> 将一种类型转换成另一种的 Type Traits</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>下面的模板基于一些良好定义的规则,将某种类型转换成另一种,每一个模板只有 一个单独的名为 <code class="computeroutput"><span class="identifier">type</span></code> 的成员,它是将转换应用到模板参数 <code class="computeroutput"><span class="identifier">T</span></code> 上之后 得到的结果。</p>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.transform"></a><a class="link" href="transform.html" title="Type Traits that Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits"> Type Traits that + Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits</a>
+</h3></div></div></div>
 <p>
-        <span class="bold"><strong>概要:</strong></span>
+ The following templates transform one type to another, based upon some well-defined + rule. Each template has a single member called <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of applying the transformation to the template argument + <code class="computeroutput"><span class="identifier">T</span></code>.<br> &#19979;&#38754;&#30340;&#27169;&#26495;&#22522;&#20110;&#19968;&#20123;&#33391;&#22909;&#23450;&#20041;&#30340;&#35268;&#21017;&#65292;&#23558;&#26576;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#65292;&#27599;&#19968;&#20010;&#27169;&#26495;&#21482;&#26377;&#19968;&#20010;&#21333;&#29420;&#30340;&#21517;&#20026; + <code class="computeroutput"><span class="identifier">type</span></code> &#30340;&#25104;&#21592;&#65292;&#23427;&#26159;&#23558;&#36716;&#25442;&#24212;&#29992;&#21040;&#27169;&#26495;&#21442;&#25968; + <code class="computeroutput"><span class="identifier">T</span></code> &#19978;&#20043;&#21518;&#24471;&#21040;&#30340;&#32467;&#26524;&#12290;
       </p>
-
+<p>
+ <span class="bold"><strong>Synopsis &#27010;&#35201;:</strong></span>
+      </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../reference/add_const.html" title="add_const">add_const</a><span class="special">;</span>

@@ -116,21 +92,42 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../reference/remove_volatile.html" title="remove_volatile">remove_volatile</a><span class="special">;</span>
 </pre>
-
-<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a>
-<h5>
-<a name="id2640926"></a>
- <a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">不 标准编译器的变通方法:</a> +<a name="boost_typetraits.category.transform.broken_compiler_workarounds_"></a><h5>
+<a name="id4864833"></a>
+ <a class="link" href="transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">Broken
+        Compiler Workarounds:</a>
       </h5>
-
-<p>对于所有这些模板,都要求对模板类偏特化的支持,这是正确实现这些转换的需 要。另一方面,实践表明这一类模板中的大多数都非常有用,并经常会成为实 -现某些泛型库的基础。这些模板的这一需求通常是将那些库移植到还不支持这一语言 特性的编译器中的最重要的限制因素之一。因为那些编译器中的一部分暂时还会 -吧被使用,而且至少其中之一还广为流传,这就决定了这个库在可能的情况下应该提 供 workarounds(workaround -一般指变通方案,规避措施等,没有对应的中文术语,故保留原文不译 &mdash;&mdash;译者注)。</p> -<p>workaround 背后的最基本的想法是为所有基本类型,以及它们的所有第一和第二 级 cv-[un] -修饰的派生指针类型手工定义所有类型转换模板的完全特化,并提供一个用户层次的 宏为所有用户定义类型 T 定义所需要的全部显式特化。</p>
-
-<p>第一部分保证这样的代码可以成功编译:</p>
+<a name="boost_typetraits.category.transform.____________________________________"></a><h5>
+<a name="id4864853"></a>
+ <a class="link" href="transform.html#boost_typetraits.category.transform.____________________________________">&#19981;&#26631;&#20934;&#32534;&#35793;&#22120;&#30340;&#21464;&#36890;&#26041;&#27861;&#65306;</a>
+      </h5>
+<p>
+ For all of these templates support for partial specialization of class templates + is required to correctly implement the transformation. On the other hand, + practice shows that many of the templates from this category are very useful, + and often essential for implementing some generic libraries. Lack of these + templates is often one of the major limiting factors in porting those libraries + to compilers that do not yet support this language feature. As some of these + compilers are going to be around for a while, and at least one of them is + very wide-spread, it was decided that the library should provide workarounds + where possible. <br> &#23545;&#20110;&#25152;&#26377;&#36825;&#20123;&#27169;&#26495;&#65292;&#37117;&#35201;&#27714;&#23545;&#27169;&#26495;&#31867;&#20559;&#29305;&#21270;&#30340;&#25903;&#25345;&#65292;&#36825;&#26159;&#27491;&#30830;&#23454;&#29616;&#36825;&#20123;&#36716;&#25442;&#30340;&#38656;&#35201;&#12290; + &#21478;&#19968;&#26041;&#38754;&#65292;&#23454;&#36341;&#34920;&#26126;&#36825;&#19968;&#31867;&#27169;&#26495;&#20013;&#30340;&#22823;&#22810;&#25968;&#37117;&#38750;&#24120;&#26377;&#29992;&#65292;&#24182;&#32463;&#24120;&#20250;&#25104;&#20026;&#23454;&#29616;&#26576;&#20123;&#27867;&#22411;&#24211;&#30340;&#22522;&#30784;&#12290; + &#36825;&#20123;&#27169;&#26495;&#30340;&#36825;&#19968;&#38656;&#27714;&#36890;&#24120;&#26159;&#23558;&#37027;&#20123;&#24211;&#31227;&#26893;&#21040;&#36824;&#19981;&#25903;&#25345;&#36825;&#19968;&#35821;&#35328;&#29305;&#24615;&#30340;&#32534;&#35793;&#22120;&#20013;&#30340;&#26368;&#37325;&#35201;&#30340;&#38480;&#21046;&#22240;&#32032;&#20043;&#19968;&#12290; + &#22240;&#20026;&#37027;&#20123;&#32534;&#35793;&#22120;&#20013;&#30340;&#19968;&#37096;&#20998;&#26242;&#26102;&#36824;&#20250;&#21543;&#34987;&#20351;&#29992;&#65292;&#32780;&#19988;&#33267;&#23569;&#20854;&#20013;&#20043;&#19968;&#36824;&#24191;&#20026;&#27969;&#20256;&#65292;&#36825;&#23601;&#20915;&#23450;&#20102;&#36825;&#20010;&#24211;&#22312;&#21487;&#33021;&#30340;&#24773;&#20917;&#19979;&#24212;&#35813;&#25552;&#20379;&#21464;&#36890;&#26041;&#26696;(workaround)&#12290;
+      </p>
+<p>
+ The basic idea behind the workaround is to manually define full specializations + of all type transformation templates for all fundamental types, and all their + 1st and 2nd rank cv-[un]qualified derivative pointer types, and to provide + a user-level macro that will define all the explicit specializations needed + for any user-defined type T. <br> workaround &#32972;&#21518;&#30340;&#26368;&#22522;&#26412;&#30340;&#24819;&#27861;&#26159;&#20026;&#25152;&#26377;&#22522;&#26412;&#31867;&#22411;&#65292;&#20197;&#21450;&#23427;&#20204;&#30340;&#25152;&#26377;&#31532;&#19968;&#21644;&#31532;&#20108;&#32423; + cv-[un] &#20462;&#39280;&#30340;&#27966;&#29983;&#25351;&#38024;&#31867;&#22411;&#25163;&#24037;&#23450;&#20041;&#25152;&#26377;&#31867;&#22411;&#36716;&#25442;&#27169;&#26495;&#30340;&#23436;&#20840;&#29305;&#21270;&#65292;&#24182;&#25552;&#20379;&#19968;&#20010;&#29992;&#25143;&#23618;&#27425;&#30340;&#23439;&#20026;&#25152;&#26377;&#29992;&#25143;&#23450;&#20041;&#31867;&#22411; + T &#23450;&#20041;&#25152;&#38656;&#35201;&#30340;&#20840;&#37096;&#26174;&#24335;&#29305;&#21270;&#12290;
+      </p>
+<p>
+ The first part guarantees the successful compilation of something like this:<br> + &#31532;&#19968;&#37096;&#20998;&#20445;&#35777;&#36825;&#26679;&#30340;&#20195;&#30721;&#21487;&#20197;&#25104;&#21151;&#32534;&#35793;&#65306;
+      </p>
<pre class="programlisting"><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span> <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span> <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">volatile</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
@@ -140,47 +137,45 @@
 <span class="special">...</span>
<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="keyword">char</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">*</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
 </pre>
-
-<p>第二部分为库用户提供一种机制,可以让上面的代码不仅仅你对 <code class="computeroutput"><span class="keyword">char</span></code>,<code class="computeroutput"><span class="keyword">int</span></code> 或其它内建类 型有效,并同样可以用于它们自己的类型:</p>
+<p>
+ and the second part provides the library's users with a mechanism to make + the above code work not only for <code class="computeroutput"><span class="keyword">char</span></code>, + <code class="computeroutput"><span class="keyword">int</span></code> or other built-in type, + but for their own types as well:<br> &#31532;&#20108;&#37096;&#20998;&#20026;&#24211;&#29992;&#25143;&#25552;&#20379;&#19968;&#31181;&#26426;&#21046;&#65292;&#21487;&#20197;&#35753;&#19978;&#38754;&#30340;&#20195;&#30721;&#19981;&#20165;&#20165;&#20320;&#23545; + <code class="computeroutput"><span class="keyword">char</span></code>&#65292;<code class="computeroutput"><span class="keyword">int</span></code> + &#25110;&#20854;&#23427;&#20869;&#24314;&#31867;&#22411;&#26377;&#25928;&#65292;&#24182;&#21516;&#26679;&#21487;&#20197;&#29992;&#20110;&#23427;&#20204;&#33258;&#24049;&#30340;&#31867;&#22411;&#65306;
+      </p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">myspace</span><span class="special">{</span> <span class="keyword">struct</span> <span class="identifier">MyClass</span> <span class="special">{};</span>
 <span class="special">}</span>
-<span class="comment">// declare this at global scope:<br></span><span class="identifier">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span><span class="special">(</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">)</span> -<span class="comment">// transformations on myspace::MyClass now work:<br></span><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
+<span class="comment">// declare this at global scope:
+</span><span class="identifier">BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION</span><span class="special">(</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">)</span>
+<span class="comment">// transformations on myspace::MyClass now work:
+</span><span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span> <span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">((</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span><span class="special">,</span> <span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">myspace</span><span class="special">::</span><span class="identifier">MyClass</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">));</span>
-<span class="comment">// etc.<br></span></pre>
-
-<p>注意,宏 BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION
-在那些支持偏特化的编译器上什么都不会求出。</p>
+<span class="comment">// etc.
+</span></pre>
+<p>
+ Note that the macro BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION evaluates + to nothing on those compilers that <span class="bold"><strong>do</strong></span> support + partial specialization.<br> &#27880;&#24847;&#65292;&#23439; BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION + &#22312;&#37027;&#20123;&#25903;&#25345;&#20559;&#29305;&#21270;&#30340;&#32534;&#35793;&#22120;&#19978;&#20160;&#20040;&#37117;&#19981;&#20250;&#27714;&#20986;&#12290;
+      </p>
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="value_traits/relate.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="alignment.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/primary.html Wed Jun 2 00:58:52 2010
@@ -1,156 +1,105 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>Categorizing a Type</title>
- <link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
- <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
-
-
-
- <link rel="prev" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
-
-
-
-  <link rel="next" href="properties.html" title="General Type Properties">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Categorizing a Type &#23545;&#31867;&#22411;&#20998;&#31867;</title>
+<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits"> +<link rel="prev" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits"> +<link rel="next" href="properties.html" title="General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;">
 </head>
-
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../../boost.png" height="86" width="277"></td>
-
-
- <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h4 class="title">
-<a name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type"> 对类型分类</a>
-</h4>
-
-</div>
-
-</div>
-
-</div>
-
-
-<p>这些 traits 某个类型 <code class="computeroutput"><span class="identifier">T</span></code> 是哪&ldquo;种&rdquo;类型。它们又分为两 组:primary traits 全都是互斥的,而
-composite traits 是一个或更多个 primary traits 的合成。</p>
-
-
-<p>对于任何给定类型,只能有一个 primary type trait 从 <a title=" integral_constant" href="../../reference/integral_constant.html">true_type</a> -继承,所有其它的都从 <a title=" integral_constant" href="../../reference/integral_constant.html">false_type</a>
-继承,换句话说,这些 traits 是互斥的。</p>
-
-
-<p>这就意味着对于内建类型,在任何时候,<code class="computeroutput"><a title=" is_integral" href="../../reference/is_integral.html">is_integral</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> 和 <code class="computeroutput"><a title=" is_floating_point" href="../../reference/is_floating_point.html">is_floating_point</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> 都 只有一个为 -true,如果你要检查一个行为&ldquo;类似&rdquo;整数或浮点数类型的用户定义类类 型,那么就使用 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span> <span class="keyword">template</span></code> 来代替。</p>
-
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_typetraits.category.value_traits.primary"></a><a class="link" href="primary.html" title="Categorizing a Type &#23545;&#31867;&#22411;&#20998;&#31867;"> Categorizing
+        a Type &#23545;&#31867;&#22411;&#20998;&#31867;</a>
+</h4></div></div></div>
 <p>
-          <span class="bold"><strong>概要:</strong></span>
+ These traits identify what "kind" of type some type <code class="computeroutput"><span class="identifier">T</span></code> is. These are split into two groups: + primary traits which are all mutually exclusive, and composite traits that + are compositions of one or more primary traits.<br> &#36825;&#20123; traits &#26576;&#20010;&#31867;&#22411; + <code class="computeroutput"><span class="identifier">T</span></code> &#26159;&#21738;&#8220;&#31181;&#8221;&#31867;&#22411;&#12290;&#23427;&#20204;&#21448;&#20998;&#20026;&#20004;&#31867;&#65306;&#22522;&#26412;traits&#20840;&#37117;&#26159;&#20114;&#26021;&#30340;&#65292;&#32780;&#32452;&#21512;traits&#26159;&#19968;&#20010;&#25110;&#22810;&#20010;&#22522;&#26412;traits&#30340;&#21512;&#25104;&#12290;
         </p>
-
-
+<p>
+ For any given type, exactly one primary type trait will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">true_type</a>, + and all the others will inherit from <a class="link" href="../../reference/integral_constant.html" title="integral_constant">false_type</a>, + in other words these traits are mutually exclusive.<br> &#23545;&#20110;&#20219;&#20309;&#32473;&#23450;&#31867;&#22411;&#65292;&#21482;&#33021;&#26377;&#19968;&#20010;&#22522;&#26412; + type trait &#20174; <a class="link" href="../../reference/integral_constant.html" title="integral_constant">true_type</a> + &#32487;&#25215;&#65292;&#25152;&#26377;&#20854;&#23427;&#30340;&#37117;&#20174; <a class="link" href="../../reference/integral_constant.html" title="integral_constant">false_type</a> + &#32487;&#25215;&#65292;&#25442;&#21477;&#35805;&#35828;&#65292;&#36825;&#20123; traits &#26159;&#20114;&#26021;&#30340;&#12290;
+        </p>
+<p>
+ This means that <code class="computeroutput"><a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> + and <code class="computeroutput"><a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> + will only ever be true for built-in types; if you want to check for a user-defined
+          class type that behaves "as if" it is an integral or floating
+ point type, then use the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span> + <span class="keyword">template</span></code> instead.<br> &#36825;&#23601;&#24847;&#21619;&#30528;&#23545;&#20110;&#20869;&#24314;&#31867;&#22411;&#65292;&#22312;&#20219;&#20309;&#26102;&#20505;&#65292;<code class="computeroutput"><a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> + &#21644; <code class="computeroutput"><a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> + &#37117;&#21482;&#26377;&#19968;&#20010;&#20026; true&#65292;&#22914;&#26524;&#20320;&#35201;&#26816;&#26597;&#19968;&#20010;&#34892;&#20026;&#8220;&#31867;&#20284;&#8221;&#25972;&#25968;&#25110;&#28014;&#28857;&#25968;&#31867;&#22411;&#30340;&#29992;&#25143;&#23450;&#20041;&#31867;&#31867;&#22411;&#65292;&#37027;&#20040;&#23601;&#20351;&#29992; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span> <span class="keyword">template</span></code>
+          &#26469;&#20195;&#26367;&#12290;
+        </p>
+<p>
+ <span class="bold"><strong>Synopsis &#27010;&#35201;:</strong></span>
+        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_array.html" title="is_array">is_array</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_array.html" title="is_array">is_array</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_class.html" title="is_class">is_class</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_class.html" title="is_class">is_class</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_complex.html" title="is_complex">is_complex</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_complex.html" title="is_complex">is_complex</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_enum.html" title="is_enum">is_enum</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_enum.html" title="is_enum">is_enum</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_floating_point.html" title="is_floating_point">is_floating_point</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_function.html" title="is_function">is_function</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_function.html" title="is_function">is_function</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_integral.html" title="is_integral">is_integral</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_function_pointer.html" title="is_member_function_pointer">is_member_function_pointer</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_member_object_pointer.html" title="is_member_object_pointer">is_member_object_pointer</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_pointer.html" title="is_pointer">is_pointer</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_reference.html" title="is_reference">is_reference</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_reference.html" title="is_reference">is_reference</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_union.html" title="is_union">is_union</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_union.html" title="is_union">is_union</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> -<span class="keyword">struct</span> <a class="link" href="../../reference/is_void.html" title="is_void">is_void</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_void.html" title="is_void">is_void</a><span class="special">;</span>
 </pre>
-
-
-<p>下面的 traits 由一个或更多个类型分类结合而成。一个类型除了一个主分类之 外,还可能属于多个这种分类。</p>
-
+<p>
+ The following traits are made up of the union of one or more type categorizations. + A type may belong to more than one of these categories, in addition to + one of the primary categories.<br> &#19979;&#38754;&#30340; traits &#30001;&#19968;&#20010;&#25110;&#26356;&#22810;&#20010;&#31867;&#22411;&#20998;&#31867;&#32467;&#21512;&#32780;&#25104;&#12290;&#19968;&#20010;&#31867;&#22411;&#38500;&#20102;&#19968;&#20010;&#20027;&#20998;&#31867;&#20043;&#22806;&#65292;&#36824;&#21487;&#33021;&#23646;&#20110;&#22810;&#20010;&#36825;&#31181;&#20998;&#31867;&#12290;
+        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/is_arithmetic.html" title="is_arithmetic">is_arithmetic</a><span class="special">;</span>

@@ -169,51 +118,21 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/is_scalar.html" title="is_scalar">is_scalar</a><span class="special">;</span>
 </pre>
-
-
 </div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../value_traits.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="properties.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html Tue Jun 2 01:35:23 2009 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/properties.html Wed Jun 2 00:58:52 2010
@@ -1,104 +1,46 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-
- <title>General Type Properties</title><link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
- <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
-
-
-
-  <link rel="prev" href="primary.html" title="Categorizing a Type">
-
-
-
- <link rel="next" href="relate.html" title="Relationships Between Two Types"></head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../../boost.png" height="86" width="277"></td>
-
-
- <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;</title> +<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits"> +<link rel="prev" href="primary.html" title="Categorizing a Type &#23545;&#31867;&#22411;&#20998;&#31867;"> +<link rel="next" href="relate.html" title="Relationships Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h4 class="title">
-<a name="boost_typetraits.category.value_traits.properties"></a><a class="link" href="properties.html" title="General Type Properties">
-        常规类型属性</a>
-</h4>
-
-</div>
-
-</div>
-
-</div>
-
-
-<p>下面的模板描述了一个类型的常规属性。</p>
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_typetraits.category.value_traits.properties"></a><a class="link" href="properties.html" title="General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;"> + General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;</a>
+</h4></div></div></div>
 <p>
-          <span class="bold"><strong>概要:</strong></span>
+ The following templates describe the general properties of a type.<br> + &#19979;&#38754;&#30340;&#27169;&#26495;&#25551;&#36848;&#20102;&#19968;&#20010;&#31867;&#22411;&#30340;&#24120;&#35268;&#23646;&#24615;&#12290;
         </p>
-
-
+<p>
+ <span class="bold"><strong>Synopsis &#27010;&#35201;:</strong></span>
+        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/alignment_of.html" title="alignment_of">alignment_of</a><span class="special">;</span>

-<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span><br><span class="keyword">struct</span> <a class="link" title="has_new_operator" href="../../reference/has_new_operator.html">has_new_operator</a><span class="special">;<br><br></span><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/has_new_operator.html" title="has_new_operator">has_new_operator</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/has_nothrow_assign.html" title="has_nothrow_assign">has_nothrow_assign</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
@@ -167,50 +109,21 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/rank.html" title="rank">rank</a><span class="special">;</span>
 </pre>
-
-
 </div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright (c) 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="primary.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="relate.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html Tue Jun 2 01:35:23 2009 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits/relate.html Wed Jun 2 00:58:52 2010
@@ -1,102 +1,66 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
- <title>Relationships Between Two Types</title><link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type">
-
-  <link rel="prev" href="properties.html" title="General Type Properties">
-
- <link rel="next" href="../transform.html" title="Type Traits that Transform One Type to Another"></head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Relationships Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;</title> +<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits"> +<link rel="prev" href="properties.html" title="General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;"> +<link rel="next" href="../transform.html" title="Type Traits that Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td> +<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h4 class="title">
-<a name="boost_typetraits.category.value_traits.relate"></a><a class="link" href="relate.html" title="Relationships Between Two Types"> 两 个类型之间的关系</a>
-</h4>
-</div>
-</div>
-</div>
-
-<p>这些模板确定在两个类型之间是否有关系:</p>
+<div class="titlepage"><div><div><h4 class="title">
+<a name="boost_typetraits.category.value_traits.relate"></a><a class="link" href="relate.html" title="Relationships Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;"> Relationships + Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;</a>
+</h4></div></div></div>
 <p>
-          <span class="bold"><strong>概要:</strong></span>
+ These templates determine the whether there is a relationship between two + types:<br> &#36825;&#20123;&#27169;&#26495;&#30830;&#23450;&#22312;&#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#26159;&#21542;&#26377;&#20851;&#31995;&#65306;
         </p>
-
+<p>
+ <span class="bold"><strong>Synopsis &#27010;&#35201;:</strong></span>
+        </p>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/is_base_of.html" title="is_base_of">is_base_of</a><span class="special">;</span> -<br><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span><br><span class="keyword">struct</span> <a class="link" title="is_virtual_base_of" href="../../reference/is_virtual_base_of.html">is_virtual_base_of</a><span class="special">;<br><br></span><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Base</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">&gt;</span> +<span class="keyword">struct</span> <a class="link" href="../../reference/is_virtual_base_of.html" title="is_virtual_base_of">is_virtual_base_of</a><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">From</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">To</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/is_convertible.html" title="is_convertible">is_convertible</a><span class="special">;</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">U</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="../../reference/is_same.html" title="is_same">is_same</a><span class="special">;</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright (c) 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="properties.html"><img src="../../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../value_traits.html"><img src="../../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../transform.html"><img src="../../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category/value_traits.html Wed Jun 2 00:58:52 2010
@@ -1,108 +1,72 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-
-
-  <title>Type Traits that Describe the Properties of a Type</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../category.html" title="Type Traits by Category">
-
-  <link rel="prev" href="../category.html" title="Type Traits by Category">
-
- <link rel="next" href="value_traits/primary.html" title="Categorizing a Type">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> +<link rel="prev" href="../category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> +<link rel="next" href="value_traits/primary.html" title="Categorizing a Type &#23545;&#31867;&#22411;&#20998;&#31867;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.category.value_traits"></a><a class="link" href="value_traits.html" title="Type Traits that Describe the Properties of a Type"> &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits</a>
-</h3>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.category.value_traits"></a><a class="link" href="value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits"> Type Traits + that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="value_traits/primary.html"> Categorizing
+        a Type &#23545;&#31867;&#22411;&#20998;&#31867;</a></span></dt>
+<dt><span class="section"><a href="value_traits/properties.html">
+ General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;</a></span></dt>
+<dt><span class="section"><a href="value_traits/relate.html"> Relationships
+ Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;</a></span></dt>
+</dl></div>
+<p>
+ These traits are all <span class="emphasis"><em>value traits</em></span>, which is to say the + traits classes all inherit from <a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a>, + and are used to access some numerical property of a type. Often this is a + simple true or false Boolean value, but in a few cases may be some other + integer value (for example when dealing with type alignments, or array bounds: + see <code class="computeroutput"><a class="link" href="../reference/alignment_of.html" title="alignment_of">alignment_of</a></code>, + <code class="computeroutput"><a class="link" href="../reference/rank.html" title="rank">rank</a></code> + and <code class="computeroutput"><a class="link" href="../reference/extent.html" title="extent">extent</a></code>).<br> + &#36825;&#20123; traits &#20840;&#37096;&#37117;&#26159; /value traits/&#65292;&#20063;&#23601;&#26159;&#35828;&#36825;&#20123; traits &#31867;&#20840;&#37096;&#20174; + <a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a> + &#32487;&#25215;&#65292;&#24182;&#29992;&#26469;&#35775;&#38382;&#19968;&#20010;&#31867;&#22411;&#30340;&#26576;&#20123;&#25968;&#20540;&#23646;&#24615;&#12290; &#36890;&#24120;&#36825;&#26159;&#19968;&#20010;&#31616;&#21333;&#30340; + true &#25110; false &#30340;&#24067;&#23572;&#20540;&#65292;&#20294;&#22312;&#26576;&#20123;&#24773;&#20917;&#19979;&#21487;&#33021;&#20250;&#26377;&#19968;&#20123;&#20854;&#20182;&#30340;&#25972;&#25968;&#20540;&#65288;&#20363;&#22914;&#65292;&#22788;&#29702;&#31867;&#22411;&#25490;&#21015;&#65292;&#25110;&#25968;&#32452;&#33539;&#22260;&#26102;&#65306;&#21442;&#35265; + <code class="computeroutput"><a class="link" href="../reference/alignment_of.html" title="alignment_of">alignment_of</a></code>, + <code class="computeroutput"><a class="link" href="../reference/rank.html" title="rank">rank</a></code> + &#21644; <code class="computeroutput"><a class="link" href="../reference/extent.html" title="extent">extent</a></code>&#65289;&#12290;
+      </p>
 </div>
-</div>
-</div>
-
-<div class="toc">
-<dl>
-
- <dt><span class="section"><a href="value_traits/primary.html">&#23545;&#31867;&#22411;&#20998;&#31867;</a></span></dt>
-
- <dt><span class="section"><a href="value_traits/properties.html">&#24120;&#35268;&#31867;&#22411;&#23646;&#24615;</a></span></dt>
-
- <dt><span class="section"><a href="value_traits/relate.html">&#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;</a></span></dt>
-
-</dl>
-</div>
-
-<p>&#36825;&#20123; traits &#20840;&#37096;&#37117;&#26159; <span class="emphasis"><em>value traits</em></span>&#65292;&#20063;&#23601;&#26159;&#35828;&#36825;&#20123; -traits &#31867;&#20840;&#37096;&#20174; <a title=" integral_constant" href="../reference/integral_constant.html">integral_constant</a> -&#32487;&#25215;&#65292;&#24182;&#29992;&#26469;&#35775;&#38382;&#19968;&#20010;&#31867;&#22411;&#30340;&#26576;&#20123;&#25968;&#20540;&#23646;&#24615;&#12290;&#36890;&#24120;&#36825;&#26159;&#19968;&#20010;&#31616;&#21333;&#30340; true &#25110; false -&#30340;&#24067;&#23572;&#20540;&#65292;&#20294;&#22312;&#26576;&#20123;&#24773;&#20917;&#19979;&#21487;&#33021;&#20250;&#26377;&#19968;&#20123;&#20854;&#20182;&#30340;&#25972;&#25968;&#20540;&#65288;&#20363;&#22914;&#65292;&#22788;&#29702;&#31867;&#22411;&#25490;&#21015;&#65292;&#25110;&#25968;&#32452;&#33539;&#22260;&#26102;&#65306;&#21442;&#35265;&nbsp;<code class="computeroutput"><a class="link" href="../reference/alignment_of.html" title="alignment_of">alignment_of</a></code>, - <code class="computeroutput"><a class="link" href="../reference/rank.html" title="rank">rank</a></code> &#21644; <code class="computeroutput"><a class="link" href="../reference/extent.html" title="extent">extent</a></code>&#65289;&#12290;</p>
-</div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../category.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../category.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="value_traits/primary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/category.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/category.html Wed Jun 2 00:58:52 2010
@@ -1,117 +1,65 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Type Traits by Category</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="prev" href="background.html" title="Background and Tutorial">
-
- <link rel="next" href="category/value_traits.html" title="Type Traits that Describe the Properties of a Type">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Type Traits by Category Type Traits&#20998;&#31867;</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="background.html" title="Background and Tutorial &#32972;&#26223;&#21644;&#25351;&#21335;"> +<link rel="next" href="category/value_traits.html" title="Type Traits that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="background.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.category"></a><a class="link" href="category.html" title="Type Traits by Category"> Type Traits 分类</a>
-</h2>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.category"></a><a class="link" href="category.html" title="Type Traits by Category Type Traits&#20998;&#31867;"> Type Traits by Category Type
+    Traits&#20998;&#31867;</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="category/value_traits.html"> Type Traits
+ that Describe the Properties of a Type &#25551;&#36848;&#31867;&#22411;&#23646;&#24615;&#30340; Type Traits</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="category/value_traits/primary.html"> Categorizing
+        a Type &#23545;&#31867;&#22411;&#20998;&#31867;</a></span></dt>
+<dt><span class="section"><a href="category/value_traits/properties.html">
+ General Type Properties &#24120;&#35268;&#31867;&#22411;&#23646;&#24615;</a></span></dt> +<dt><span class="section"><a href="category/value_traits/relate.html"> Relationships + Between Two Types &#20004;&#20010;&#31867;&#22411;&#20043;&#38388;&#30340;&#20851;&#31995;</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="category/transform.html"> Type Traits that + Transform One Type to Another &#23558;&#19968;&#31181;&#31867;&#22411;&#36716;&#25442;&#25104;&#21478;&#19968;&#31181;&#30340; Type Traits</a></span></dt> +<dt><span class="section"><a href="category/alignment.html"> Synthesizing Types + with Specific Alignments &#29992;&#25351;&#23450;&#30340;&#23545;&#40784;&#26041;&#24335;&#32452;&#21512;&#31867;&#22411;</a></span></dt> +<dt><span class="section"><a href="category/function.html"> Decomposing Function + Types &#35299;&#26512;&#20989;&#25968;&#31867;&#22411;</a></span></dt>
+</dl></div>
 </div>
-</div>
-</div>
-
-<div class="toc">
-<dl>
-
- <dt><span class="section"><a href="category/value_traits.html">描述类型属 性的 Type Traits</a></span></dt>
-
-  <dd>
-    <dl>
-
- <dt><span class="section"><a href="category/value_traits/primary.html">对类型分类</a></span></dt>
-
- <dt><span class="section"><a href="category/value_traits/properties.html">常规类型属性</a></span></dt>
-
- <dt><span class="section"><a href="category/value_traits/relate.html">两个类型之间的关系</a></span></dt>
-
-    </dl>
-  </dd>
-
- <dt><span class="section"><a href="category/transform.html">将一种类型转 换为另一种的 Type Traits</a></span></dt>
-
- <dt><span class="section"><a href="category/alignment.html">用指定的方式 合成类型</a></span></dt>
-
- <dt><span class="section"><a href="category/function.html">解析函数类型 </a></span></dt>
-
-</dl>
-</div>
-
-</div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="background.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="category/value_traits.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/credits.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/credits.html Wed Jun 2 00:58:52 2010
@@ -1,108 +1,90 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-
-
-  <title>Credits</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="prev" href="reference/type_with_alignment.html" title="type_with_alignment">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Credits &#33635;&#35465;</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="prev" href="history.html" title="History &#21382;&#21490;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a> +<a accesskey="p" href="history.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.credits"></a><a class="link" href="credits.html" title="Credits"> &#33635;&#35465;</a>
-</h2>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.credits"></a><a class="link" href="credits.html" title="Credits &#33635;&#35465;"> Credits &#33635;&#35465;</a>
+</h2></div></div></div>
+<p>
+ This documentation was pulled together by John Maddock, using <a href="../../../../../doc/html/quickbook.html" target="_top">Boost.Quickbook</a> + and <a href="../../../../../doc/html/boostbook.html" target="_top">Boost.DocBook</a>.<br> + &#26412;&#25991;&#26723;&#30001; John Maddock &#21327;&#21161;&#23436;&#25104;&#65292;&#20351;&#29992;&#20102; <a href="../../../../../doc/html/quickbook.html" target="_top">Boost.Quickbook</a> + &#21644; <a href="../../../../../doc/html/boostbook.html" target="_top">Boost.DocBook</a>
+      &#24037;&#20855;&#12290;
+    </p>
+<p>
+ The original version of this library was created by Steve Cleary, Beman Dawes, + Howard Hinnant, and John Maddock. John Maddock is the current maintainer of + the library.<br> &#27492;&#24211;&#30340;&#21407;&#22987;&#29256;&#26412;&#30001; Steve Cleary&#65292;Beman Dawes&#65292;Howard + Hinnant &#21644; John Maddock &#21019;&#24314;&#65292;&#24403;&#21069;&#20027;&#35201;&#30001; John Maddock &#32500;&#25252;&#12290;
+    </p>
+<p>
+ This version of type traits library is based on contributions by Adobe Systems + Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, + Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Thorsten Ottosen, Robert + Ramey and Jeremy Siek.<br> &#26412;&#29256; type traits &#24211;&#22522;&#20110; Adobe Systems Inc + David Abrahams&#65292;Steve Cleary&#65292;Beman Dawes&#65292; Aleksey Gurtovoy&#65292;Howard Hinnant&#65292;Jesse + Jones&#65292;Mat Marcus&#65292;Itay Maman&#65292;John Maddock&#65292; Thorsten Ottosen&#65292;Robert
+      Ramey &#21644; Jeremy Siek &#30340;&#25424;&#36192;&#12290;
+    </p>
+<p>
+ Mat Marcus and Jesse Jones invented, and <a href="http://opensource.adobe.com/project4/project.shtml"; target="_top">published + a paper describing</a>, the partial specialization workarounds used in + this library.<br> &#27492;&#24211;&#20013;&#20351;&#29992;&#30340;&#20559;&#29305;&#21270; workarounds &#30001; Mat Marcus + &#21644; Jesse Jones &#20570;&#20986;&#24182; <a href="http://opensource.adobe.com/project4/project.shtml"; target="_top">&#25776;&#25991;&#20171;&#32461;</a>&#12290;
+    </p>
+<p>
+ Aleksey Gurtovoy added MPL integration to the library.<br> Aleksey Gurtovoy
+      &#23558; MPL &#32467;&#21512;&#21040;&#27492;&#24211;&#20013;&#12290;
+    </p>
+<p>
+ The <a class="link" href="reference/is_convertible.html" title="is_convertible">is_convertible</a> + template is based on code originally devised by Andrei Alexandrescu, see "<a href="http://www.cuj.com/experts/1810/alexandr.htm?topic=experts"; target="_top">Generic&lt;Programming&gt;: + Mappings between Types and Values</a>".<br> <a class="link" href="reference/is_convertible.html" title="is_convertible">is_convertible</a> + &#27169;&#26495;&#25152;&#22522;&#20110;&#30340;&#20195;&#30721;&#26368;&#21021;&#30001; Andrei Alexandrescu &#20570;&#20986;&#65292;&#21442;&#35265; "<a href="http://www.cuj.com/experts/1810/alexandr.htm?topic=experts"; target="_top">Generic&lt;Programming&gt;:
+      Mappings between Types and Values</a>"&#12290;
+    </p>
+<p>
+ The latest version of this library and documentation can be found at <a href="http://www.boost.org"; target="_top">www.boost.org</a>. Bugs, suggestions and discussion + should be directed to boost@xxxxxxxxxxxxxxx (see <a href="http://www.boost.org/more/mailing_lists.htm#main"; target="_top">www.boost.org/more/mailing_lists.htm#main</a> + for subscription details).<br> &#27492;&#24211;&#30340;&#26368;&#26032;&#29256;&#26412;&#21644;&#25991;&#26723;&#21487;&#20197;&#22312; <a href="http://www.boost.org"; target="_top">www.boost.org</a> &#25214;&#21040;&#12290;bugs&#65292;&#24314;&#35758;&#21644;&#35752;&#35770;&#35831;&#25552;&#20132;&#21040; + boost@xxxxxxxxxxxxxxx&#65288;&#20851;&#20110;&#35746;&#38405;&#30340;&#32454;&#33410;&#21442;&#35265; <a href="http://www.boost.org/more/mailing_lists.htm#main"; target="_top">www.boost.org/more/mailing_lists.htm#main</a>&#65289;&#12290;
+    </p>
 </div>
-</div>
-</div>
-
-<p>&#26412;&#25991;&#26723;&#30001; John Maddock &#21327;&#21161;&#23436;&#25104;&#65292;&#20351;&#29992;&#20102; <a href="../../../../../tools/quickbook/doc/html/index.html" target="_top">Boost.Quickbook</a> &#21644; <a href="../../../../../doc/html/boostbook.html" target="_top">Boost.DocBook</a> &#24037;&#20855;&#12290;</p>
-
-<p>&#27492;&#24211;&#30340;&#21407;&#22987;&#29256;&#26412;&#30001; Steve Cleary&#65292;Beman Dawes&#65292;Howard Hinnant &#21644; John Maddock &#21019;&#24314;&#65292;&#24403;&#21069;&#20027;&#35201;&#30001; John
-Maddock &#32500;&#25252;&#12290;</p>
-
-<p>&#26412;&#29256; type traits &#24211;&#22522;&#20110; Adobe Systems Inc David Abrahams&#65292;Steve Cleary&#65292;Beman -Dawes&#65292;Aleksey Gurtovoy&#65292;Howard Hinnant&#65292;Jesse Jones&#65292;Mat Marcus&#65292;Itay Maman&#65292;John -Maddock&#65292;Thorsten Ottosen&#65292;Robert Ramey &#21644; Jeremy Siek &#30340;&#25424;&#36192;&#12290;</p>
-
-<p>&#27492;&#24211;&#20013;&#20351;&#29992;&#30340;&#20559;&#29305;&#21270; workarounds &#30001; Mat Marcus &#21644; Jesse Jones &#20570;&#20986;&#24182;<a href="http://opensource.adobe.com/project4/project.shtml"; target="_top">&#25776;&#25991;&#20171;&#32461;</a>&#12290;</p>
-
-<p>Aleksey Gurtovoy &#23558; MPL &#32467;&#21512;&#21040;&#27492;&#24211;&#20013;&#12290;</p>
-
-<p><a title=" is_convertible" href="reference/is_convertible.html">is_convertible</a> -&#27169;&#26495;&#25152;&#22522;&#20110;&#30340;&#20195;&#30721;&#26368;&#21021;&#30001; Andrei Alexandrescu &#20570;&#20986;&#65292;&#21442;&#35265; <a href="http://www.cuj.com/experts/1810/alexandr.htm?topic=experts"; target="_top">Generic&lt;Programming&gt;: Mappings between Types and
-Values</a>"&#12290;</p>
-
-<p>&#27492;&#24211;&#30340;&#26368;&#26032;&#29256;&#26412;&#21644;&#25991;&#26723;&#21487;&#20197;&#22312; <a href="http://www.boost.org/"; target="_top">www.boost.org</a> -&#25214;&#21040;&#12290;bugs&#65292;&#24314;&#35758;&#21644;&#35752;&#35770;&#35831;&#25552;&#20132;&#21040; boost@xxxxxxxxxxxxxxx&#65288;&#20851;&#20110;&#35746;&#38405;&#30340;&#32454;&#33410;&#21442;&#35265; <a href="http://www.boost.org/more/mailing_lists.htm#main"; target="_top">www.boost.org/more/mailing_lists.htm#main</a>&#65289;&#12290;</p>
-</div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
-<a accesskey="p" href="reference/type_with_alignment.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a> +<a accesskey="p" href="history.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples/copy.html Wed Jun 2 00:58:52 2010
@@ -1,66 +1,48 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-
-
-  <title>An Optimized Version of std::copy</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../examples.html" title="Examples">
-
-  <link rel="prev" href="../examples.html" title="Examples">
-
- <link rel="next" href="fill.html" title="An Optimised Version of std::fill">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="prev" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="next" href="fill.html" title="An Optimised Version of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.examples.copy"></a><a class="link" href="copy.html" title="An Optimized Version of std::copy"> std::copy &#30340;&#19968;&#20010;&#20248;&#21270;&#29256;&#26412;</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>&#31034;&#33539;&#20102;&#19968;&#20010; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code> &#30340;&#29256;&#26412;&#65292;&#23427;&#20351;&#29992; <code class="computeroutput"><a title=" has_trivial_assign" href="../reference/has_trivial_assign.html">has_trivial_assign</a></code> -&#27979;&#23450;&#26159;&#21542;&#21487;&#20197;&#29992; <code class="computeroutput"><span class="identifier">memcpy</span></code> -&#26469;&#20248;&#21270;&#25335;&#36125;&#25805;&#20316;&#65288;&#21442;&#35265; <a href="../../../../examples/copy_example.cpp" target="_top">copy_example.cpp</a>&#65289;&#65306;</p> -<pre class="programlisting"><span class="comment">//<br></span><span class="comment">// opt::copy<br></span><span class="comment">// &#21644; std::copy &#35821;&#20041;&#30456;&#21516;<br></span><span class="comment">// &#36866;&#24403;&#26102;&#35843;&#29992; memcpy<br></span><span class="comment">//<br></span>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.examples.copy"></a><a class="link" href="copy.html" title="An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy"> An Optimized Version + of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy</a>
+</h3></div></div></div>
+<p>
+ Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code> + that uses <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + to determine whether to use <code class="computeroutput"><span class="identifier">memcpy</span></code> + to optimise the copy operation (see <a href="../../../../examples/copy_example.cpp" target="_top">copy_example.cpp</a>):<br> + &#31034;&#33539;&#20102;&#19968;&#20010; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">copy</span></code> &#30340;&#29256;&#26412;&#65292;&#23427;&#20351;&#29992; <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + &#27979;&#23450;&#26159;&#21542;&#21487;&#20197;&#29992; <code class="computeroutput"><span class="identifier">memcpy</span></code> + &#26469;&#20248;&#21270;&#25335;&#36125;&#25805;&#20316;&#65288;&#21442;&#35265; <a href="../../../../examples/copy_example.cpp" target="_top">copy_example.cpp</a>&#65289;&#65306;
+      </p>
+<pre class="programlisting"><span class="comment">//
+</span><span class="comment">// opt::copy
+</span><span class="comment">// same semantics as std::copy
+</span><span class="comment">// calls memcpy where appropriate.
+</span><span class="comment">// &#21644; std::copy &#35821;&#20041;&#30456;&#21516;&#65292;&#36866;&#24403;&#26102;&#35843;&#29992; memcpy
+</span><span class="comment">//
+</span>
<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">&gt;</span>
@@ -88,40 +70,32 @@
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="identifier">I2</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I1</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">out</span><span class="special">)</span>
 <span class="special">{</span>
- <span class="comment">//<br></span> <span class="comment">// &#22914;&#26524; T &#20855;&#26377;&#24179;&#20961;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#19988;&#36845;&#20195;&#22120;&#21442;&#25968;&#20026;&#30495;&#27491;&#30340;&#25351;&#38024;&#65292;&#25105;&#20204;&#21487;&#20197;&#29992; memcpy &#26469;&#22797;&#21046;<br></span> <span class="comment">// (&#25105;&#20204;&#29992;&#37325;&#36733;&#20915;&#35758;&#26469;&#26816;&#27979;&#21518;&#19968;&#20010;&#35201;&#27714;</span><span class="comment">):<br></span> <span class="comment">//<br></span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
+   <span class="comment">//
+</span> <span class="comment">// We can copy with memcpy if T has a trivial assignment operator, +</span> <span class="comment">// and if the iterator arguments are actually pointers (this last +</span> <span class="comment">// requirement we detect with overload resolution): +</span> <span class="comment">// &#22914;&#26524; T &#20855;&#26377;&#24179;&#20961;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#19988;&#36845;&#20195;&#22120;&#21442;&#25968;&#20026;&#30495;&#27491;&#30340;&#25351;&#38024;&#65292;&#25105;&#20204;&#21487;&#20197;&#29992; memcpy &#26469;&#22797;&#21046; +</span> <span class="comment">// (&#25105;&#20204;&#29992;&#37325;&#36733;&#20915;&#35758;&#26469;&#26816;&#27979;&#21518;&#19968;&#20010;&#35201;&#27714;):
+</span>   <span class="comment">//
+</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span> <span class="keyword">return</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">copy_imp</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">value_type</span><span class="special">&gt;());</span>
 <span class="special">}</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples/destruct.html Wed Jun 2 00:58:52 2010
@@ -1,65 +1,45 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
- <title>An Example that Omits Destructor Calls For Types with Trivial Destructors</title> - <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../examples.html" title="Examples">
-
- <link rel="prev" href="fill.html" title="An Optimised Version of std::fill">
-
- <link rel="next" href="iter.html" title="An improved Version of std::iter_swap">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>An Example that Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="prev" href="fill.html" title="An Optimised Version of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill"> +<link rel="next" href="iter.html" title="An improved Version of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="fill.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iter.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.examples.destruct"></a><a class="link" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors"> 对于带有 trivial(非特殊)的析构函数的类型 忽略析构函数调用的一个示例</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>示范了一个简单算法,它使用 <code class="computeroutput"><span class="identifier">__has_trivial_destruct</span></code>__has_trivial_destruct -测定是否需要调用析构函数(参见 <a href="../../../../examples/trivial_destructor_example.cpp" target="_top">trivial_destructor_example.cpp</a>):</p> -<pre class="programlisting"><span class="comment">//<br></span><span class="comment">// 算法 destroy_array:<br></span><span class="comment">// 与 std::unitialized_copy 相反,接受一块已初始化的内存并对其中的所有对象 <br></span><span class="comment">// 调用析构函数。<br></span><span class="comment">//<br></span>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.examples.destruct"></a><a class="link" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;"> An Example that + Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;</a>
+</h3></div></div></div>
+<p>
+ Demonstrates a simple algorithm that uses <code class="computeroutput"><span class="identifier">__has_trivial_destruct</span></code> + to determine whether to destructors need to be called (see <a href="../../../../examples/trivial_destructor_example.cpp" target="_top">trivial_destructor_example.cpp</a>):<br> + &#31034;&#33539;&#20102;&#19968;&#20010;&#31616;&#21333;&#31639;&#27861;&#65292;&#23427;&#20351;&#29992; <code class="computeroutput"><span class="identifier">__has_trivial_destruct</span></code> + &#27979;&#23450;&#26159;&#21542;&#38656;&#35201;&#35843;&#29992;&#26512;&#26500;&#20989;&#25968;&#65288;&#21442;&#35265; <a href="../../../../examples/trivial_destructor_example.cpp" target="_top">trivial_destructor_example.cpp</a>&#65289;&#65306;
+      </p>
+<pre class="programlisting"><span class="comment">//
+</span><span class="comment">// algorithm destroy_array:
+</span><span class="comment">// The reverse of std::unitialized_copy, takes a block of +</span><span class="comment">// initialized memory and calls destructors on all objects therein. +</span><span class="comment">// &#19982; std::unitialized_copy &#30456;&#21453;&#65292;&#25509;&#21463;&#19968;&#22359;&#24050;&#21021;&#22987;&#21270;&#30340;&#20869;&#23384;&#24182;&#23545;&#20854;&#20013;&#30340;&#25152;&#26377;&#23545;&#35937;&#35843;&#29992;&#26512;&#26500;&#20989;&#25968;&#12290;
+</span><span class="comment">//
+</span>
<span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
@@ -77,43 +57,29 @@
 <span class="special">{</span>
 <span class="special">}</span>

-<span class="special">}</span> <span class="comment">// namespace detail<br></span>
+<span class="special">}</span> <span class="comment">// namespace detail
+</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">destroy_array</span><span class="special">(</span><span class="identifier">T</span><span class="special">*</span> <span class="identifier">p1</span><span class="special">,</span> <span class="identifier">T</span><span class="special">*</span> <span class="identifier">p2</span><span class="special">)</span>
 <span class="special">{</span>
<span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_destroy_array</span><span class="special">(</span><span class="identifier">p1</span><span class="special">,</span> <span class="identifier">p2</span><span class="special">,</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_destructor.html" title="has_trivial_destructor">has_trivial_destructor</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;());</span>
 <span class="special">}</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="fill.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="iter.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples/fill.html Wed Jun 2 00:58:52 2010
@@ -1,68 +1,47 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>An Optimised Version of std::fill</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../examples.html" title="Examples">
-
- <link rel="prev" href="copy.html" title="An Optimized Version of std::copy">
-
- <link rel="next" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>An Optimised Version of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="prev" href="copy.html" title="An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy"> +<link rel="next" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="copy.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="destruct.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.examples.fill"></a><a class="link" href="fill.html" title="An Optimised Version of std::fill"> std::fill 的一个 优化版本</a>
-</h3>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.examples.fill"></a><a class="link" href="fill.html" title="An Optimised Version of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill"> An Optimised Version + of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill</a>
+</h3></div></div></div>
 <p>
-        </p>
-<p>示范了一个 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></code> 的版本,它使用 <code class="computeroutput"><a title=" has_trivial_assign" href="../reference/has_trivial_assign.html">has_trivial_assign</a></code> -测定是否可以用 <code class="computeroutput"><span class="identifier">memset</span></code> -来优化填充操作(参见 <a href="../../../../examples/fill_example.cpp" target="_top">fill_example.cpp</a>):</p> -<pre class="programlisting"><span class="comment">//<br></span><span class="comment">// fill<br></span><span class="comment">// 与 std::fill 相 同,不过会在适当时使用 memset<br></span><span class="comment">//<br></span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span> + Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></code> + that uses <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + to determine whether to use <code class="computeroutput"><span class="identifier">memset</span></code> + to optimise the fill operation (see <a href="../../../../examples/fill_example.cpp" target="_top">fill_example.cpp</a>):<br> + &#31034;&#33539;&#20102;&#19968;&#20010; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fill</span></code> &#30340;&#29256;&#26412;&#65292;&#23427;&#20351;&#29992; <code class="computeroutput"><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a></code> + &#27979;&#23450;&#26159;&#21542;&#21487;&#20197;&#29992; <code class="computeroutput"><span class="identifier">memset</span></code> + &#26469;&#20248;&#21270;&#22635;&#20805;&#25805;&#20316;&#65288;&#21442;&#35265; <a href="../../../../examples/fill_example.cpp" target="_top">fill_example.cpp</a>&#65289;&#65306;
+      </p>
+<pre class="programlisting"><span class="comment">//
+</span><span class="comment">// fill
+</span><span class="comment">// same as std::fill, but uses memset where appropriate +</span><span class="comment">// &#19982; std::fill &#30456;&#21516;&#65292;&#19981;&#36807;&#20250;&#22312;&#36866;&#24403;&#26102;&#20351;&#29992; memset
+</span><span class="comment">//
+</span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">&gt;</span> <span class="keyword">void</span> <span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <span class="identifier">b</span><span class="special">&gt;&amp;)</span>
@@ -85,40 +64,31 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">I</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">fill</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">last</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">T</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">)</span>
 <span class="special">{</span>
- <span class="comment">//<br></span> <span class="comment">// 如果 T 具 有平凡的赋值操作符且它的大小为1,则我们可以进行优化的 fill</span><span class="comment">:<br></span> <span class="comment">//<br></span> <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> <br> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">)&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span>
+   <span class="comment">//
+</span> <span class="comment">// We can do an optimised fill if T has a trivial assignment
+</span>   <span class="comment">// operator and if it's size is one:
+</span> <span class="comment">// &#22914;&#26524; T &#20855;&#26377;&#24179;&#20961;&#30340;&#36171;&#20540;&#25805;&#20316;&#31526;&#19988;&#23427;&#30340;&#22823;&#23567;&#20026;1&#65292;&#21017;&#25105;&#20204;&#21487;&#20197;&#36827;&#34892;&#20248;&#21270;&#30340; fill:
+</span>   <span class="comment">//
+</span> <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span> + <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/has_trivial_assign.html" title="has_trivial_assign">has_trivial_assign</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">&amp;&amp;</span> <span class="special">(</span><span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">T</span><span class="special">)</span> <span class="special">==</span> <span class="number">1</span><span class="special">)&gt;</span> <span class="identifier">truth_type</span><span class="special">;</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_fill</span><span class="special">(</span><span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">val</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span>
 <span class="special">}</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="copy.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="destruct.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples/iter.html Wed Jun 2 00:58:52 2010
@@ -1,66 +1,54 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>An improved Version of std::iter_swap</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../examples.html" title="Examples">
-
- <link rel="prev" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors">
-
- <link rel="next" href="to_double.html" title="Convert Numeric Types and Enums to double">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>An improved Version of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="prev" href="destruct.html" title="An Example that Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;"> +<link rel="next" href="to_double.html" title="Convert Numeric Types and Enums to double &#23558;&#25968;&#23383;&#31867;&#22411;&#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026;double">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="destruct.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="to_double.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.examples.iter"></a><a class="link" href="iter.html" title="An improved Version of std::iter_swap">&nbsp;std::iter_swap 的一个改进版本</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>示范了一个 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> 的版本,它使用 -type traits 测定它的参数是否是 proxying iterators,如果它们不是,就仅仅对它 的解引用后的参数做一次 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>(和 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code>所 做的一样),反之,如果它们是 proxying -iterators,就特别关照它们的交换,以确保对两个 proxying iterators,甚至不同 类型的 iterators 所做的操作正确(参见 <a href="../../../../examples/iter_swap_example.cpp" target="_top">iter_swap_example.cpp</a>):</p> -<pre class="programlisting"><span class="comment">//<br></span><span class="comment">// iter_swap:<br></span><span class="comment">// 测试迭代器 是否为代理迭代器,并采用相应的优化形式:</span><span class="comment"><br></span><span class="comment">//<br></span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.examples.iter"></a><a class="link" href="iter.html" title="An improved Version of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap"> An improved Version + of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap</a>
+</h3></div></div></div>
+<p>
+ Demonstrates a version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> + that use type traits to determine whether an it's arguments are proxying + iterators or not, if they're not then it just does a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code> + of it's dereferenced arguments (the same as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> + does), however if they are proxying iterators then takes special care over + the swap to ensure that the algorithm works correctly for both proxying iterators, + and even iterators of different types (see <a href="../../../../examples/iter_swap_example.cpp" target="_top">iter_swap_example.cpp</a>):<br> + &#31034;&#33539;&#20102;&#19968;&#20010; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> &#30340;&#29256;&#26412;&#65292;&#23427;&#20351;&#29992; type traits + &#27979;&#23450;&#23427;&#30340;&#21442;&#25968;&#26159;&#21542;&#26159; proxying iterators&#65292; &#22914;&#26524;&#23427;&#20204;&#19981;&#26159;&#65292;&#23601;&#20165;&#20165;&#23545;&#23427;&#30340;&#35299;&#24341;&#29992;&#21518;&#30340;&#21442;&#25968;&#20570;&#19968;&#27425; + <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">swap</span></code>&#65288;&#21644; <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">iter_swap</span></code> + &#25152;&#20570;&#30340;&#19968;&#26679;&#65289;&#65292; &#21453;&#20043;&#65292;&#22914;&#26524;&#23427;&#20204;&#26159; proxying iterators&#65292;&#23601;&#29305;&#21035;&#20851;&#29031;&#23427;&#20204;&#30340;&#20132;&#25442;&#65292;&#20197;&#30830;&#20445;&#23545;&#20004;&#20010; + proxying iterators&#65292; &#29978;&#33267;&#19981;&#21516;&#31867;&#22411;&#30340; iterators &#25152;&#20570;&#30340;&#25805;&#20316;&#27491;&#30830;&#65288;&#21442;&#35265; + <a href="../../../../examples/iter_swap_example.cpp" target="_top">iter_swap_example.cpp</a>&#65289;&#65306;
+      </p>
+<pre class="programlisting"><span class="comment">//
+</span><span class="comment">// iter_swap:
+</span><span class="comment">// tests whether iterator is a proxying iterator or not, and
+</span><span class="comment">// uses optimal form accordingly:
+</span><span class="comment">// &#27979;&#35797;&#36845;&#20195;&#22120;&#26159;&#21542;&#20026;&#20195;&#29702;&#36845;&#20195;&#22120;&#65292;&#24182;&#37319;&#29992;&#30456;&#24212;&#30340;&#20248;&#21270;&#24418;&#24335;&#65306;
+</span><span class="comment">//
+</span><span class="keyword">namespace</span> <span class="identifier">detail</span><span class="special">{</span>

<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span> <span class="keyword">static</span> <span class="keyword">void</span> <span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">I</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I</span> <span class="identifier">two</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">false_type</a><span class="special">&amp;)</span>
@@ -82,7 +70,12 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I1</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">I2</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">void</span> <span class="identifier">iter_swap</span><span class="special">(</span><span class="identifier">I1</span> <span class="identifier">one</span><span class="special">,</span> <span class="identifier">I2</span> <span class="identifier">two</span><span class="special">)</span>
 <span class="special">{</span>
- <span class="comment">//<br></span> <span class="comment">// 检查两个 参数是否均为非代理迭代器,且两个迭代器为相同类型:</span><span class="comment"><br></span> <span class="comment">//<br></span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">r1_t</span><span class="special">;</span>
+   <span class="comment">//
+</span> <span class="comment">// See is both arguments are non-proxying iterators,
+</span>   <span class="comment">// and if both iterator the same type:
+</span> <span class="comment">// &#26816;&#26597;&#20004;&#20010;&#21442;&#25968;&#26159;&#21542;&#22343;&#20026;&#38750;&#20195;&#29702;&#36845;&#20195;&#22120;&#65292;&#19988;&#20004;&#20010;&#36845;&#20195;&#22120;&#20026;&#30456;&#21516;&#31867;&#22411;&#65306;
+</span>   <span class="comment">//
+</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I1</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">r1_t</span><span class="special">;</span> <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I2</span><span class="special">&gt;::</span><span class="identifier">reference</span> <span class="identifier">r2_t</span><span class="special">;</span>

<span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><a class="link" href="../reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="keyword">bool</span><span class="special">,</span>
@@ -93,36 +86,21 @@
<span class="identifier">detail</span><span class="special">::</span><span class="identifier">do_swap</span><span class="special">(</span><span class="identifier">one</span><span class="special">,</span> <span class="identifier">two</span><span class="special">,</span> <span class="identifier">truth_type</span><span class="special">());</span>
 <span class="special">}</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="destruct.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="to_double.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples/to_double.html Wed Jun 2 00:58:52 2010
@@ -1,65 +1,37 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Convert Numeric Types and Enums to double</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../examples.html" title="Examples">
-
- <link rel="prev" href="iter.html" title="An improved Version of std::iter_swap">
-
-  <link rel="next" href="../reference.html" title="Alphabetical Reference">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Convert Numeric Types and Enums to double &#23558;&#25968;&#23383;&#31867;&#22411;&#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026;double</title> +<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits">
+<link rel="up" href="../examples.html" title="Examples &#31034;&#20363;">
+<link rel="prev" href="iter.html" title="An improved Version of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap"> +<link rel="next" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="iter.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_typetraits.examples.to_double"></a><a class="link" href="to_double.html" title="Convert Numeric Types and Enums to double"> 将 数字类型和枚举类型转换为 double</a>
-</h3>
-</div>
-</div>
-</div>
-
-<p>示范将 <a href="../../../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types" target="_top">数字类型</a> 和枚举类型转换为 double:
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_typetraits.examples.to_double"></a><a class="link" href="to_double.html" title="Convert Numeric Types and Enums to double &#23558;&#25968;&#23383;&#31867;&#22411;&#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026;double"> Convert Numeric + Types and Enums to double &#23558;&#25968;&#23383;&#31867;&#22411;&#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026;double</a>
+</h3></div></div></div>
+<p>
+ Demonstrates a conversion of <a href="../../../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types" target="_top">Numeric + Types</a> and enum types to double:<br> &#31034;&#33539;&#23558; <a href="../../../../../../libs/numeric/conversion/doc/html/boost_numericconversion/definitions.html#boost_numericconversion.definitions.numeric_types" target="_top">&#25968;&#23383;&#31867;&#22411;</a> + &#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026; double:
       </p>
-
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">inline</span> <span class="keyword">double</span> <span class="identifier">to_double</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">)</span>
 <span class="special">{</span>
@@ -67,36 +39,21 @@
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">numeric</span><span class="special">::</span><span class="identifier">converter</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span><span class="identifier">promoted</span><span class="special">&gt;::</span><span class="identifier">convert</span><span class="special">(</span><span class="identifier">value</span><span class="special">);</span>
 <span class="special">}</span>
 </pre>
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="iter.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/examples.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/examples.html Wed Jun 2 00:58:52 2010
@@ -1,107 +1,58 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Examples</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="prev" href="mpl.html" title="MPL Interoperability">
-
- <link rel="next" href="examples/copy.html" title="An Optimized Version of std::copy">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Examples &#31034;&#20363;</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="mpl.html" title="MPL Interoperability &#19982;MPL&#30340;&#20114;&#25805;&#20316;&#24615;"> +<link rel="next" href="examples/copy.html" title="An Optimized Version of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="mpl.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.examples"></a><a class="link" href="examples.html" title="Examples"> 示例</a>
-</h2>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.examples"></a><a class="link" href="examples.html" title="Examples &#31034;&#20363;"> Examples &#31034;&#20363;</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="examples/copy.html"> An Optimized Version + of std::copy &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::copy</a></span></dt> +<dt><span class="section"><a href="examples/fill.html"> An Optimised Version + of std::fill &#19968;&#20010;&#20248;&#21270;&#29256;&#26412;&#30340;std::fill</a></span></dt>
+<dt><span class="section"><a href="examples/destruct.html"> An Example that
+ Omits Destructor Calls For Types with Trivial Destructors &#23545;&#20110;&#24102;&#26377; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#30340;&#31867;&#22411;&#24573;&#30053;&#26512;&#26500;&#20989;&#25968;&#35843;&#29992;&#30340;&#19968;&#20010;&#31034;&#20363;</a></span></dt>
+<dt><span class="section"><a href="examples/iter.html"> An improved Version
+ of std::iter_swap &#19968;&#20010;&#25913;&#36827;&#29256;&#26412;&#30340;std::iter_swap</a></span></dt> +<dt><span class="section"><a href="examples/to_double.html"> Convert Numeric + Types and Enums to double &#23558;&#25968;&#23383;&#31867;&#22411;&#21644;&#26522;&#20030;&#31867;&#22411;&#36716;&#25442;&#20026;double</a></span></dt>
+</dl></div>
 </div>
-</div>
-</div>
-
-<div class="toc">
-<dl>
-
- <dt><span class="section"><a href="examples/copy.html">std::copy 的一个优 化版本</a></span></dt>
-
- <dt><span class="section"><a href="examples/fill.html">std::fill 的一个优 化版本</a></span></dt>
-
- <dt><span class="section"><a href="examples/destruct.html">对于带有非特殊 析构函数的类型忽略析构函数调用的一个示例</a></span></dt>
-
- <dt><span class="section"><a href="examples/iter.html">std::iter_swap 的 一个改进版本</a></span></dt>
-
- <dt><span class="section"><a href="examples/to_double.html">将数字类型和 枚举类型转换为 double</a></span></dt>
-
-</dl>
-</div>
-
-</div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="mpl.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/copy.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/intrinsics.html Wed Jun 2 00:58:52 2010
@@ -1,46 +1,47 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Support for Compiler Intrinsics</title>
-
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Support for Compiler Intrinsics &#32534;&#35793;&#22120;&#22266;&#26377;&#30340;&#25903;&#25345;</title> <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-<link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits"> -<link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits"> -<link rel="prev" href="user_defined.html" title="User Defined Specializations">
-<link rel="next" href="mpl.html" title="MPL Interoperability">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="user_defined.html" title="User Defined Specializations &#29992;&#25143;&#23450;&#20041;&#29305;&#21270;"> +<link rel="next" href="mpl.html" title="MPL Interoperability &#19982;MPL&#30340;&#20114;&#25805;&#20316;&#24615;">
 </head>
-
-<body style="color: black; background-color: white;" alink="#0000ff" link="#0000ff" vlink="#840084">
-<table cellpadding="2" width="100%">
-<tbody>
-<tr>
-<td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td> +<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
 <td align="center"><a href="../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-<td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
 <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr>
-</tbody>
-</table>
+</tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="p" href="user_defined.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<div class="spirit-nav">
+<a accesskey="p" href="user_defined.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;"><a name="boost_typetraits.intrinsics"></a><a class="link" href="intrinsics.html" title="Support for Compiler Intrinsics"> 编译器固有的 支持</a>
-</h2>
-</div>
-</div>
-</div>
-<p>有一些 traits 在当前的 C++ 语言中不能实现:为了让这些 traits
-能和用户定义类型一起"正确地工作",需要一些来自编译器的额外的帮助。现在 (2008 年 4 月)Visual C++ 8 和 9, GNU
-GCC 4.3 以及 MWCW 9 提供了必要的内部特性,其它编译器无疑会及时跟进。</p>
-<p>下面的 traits 类对于所有类型都需要编译器的支持才能正常工作(不过,如果没 有这些支持,它们也都会安全地退回原位):</p>
-<div class="itemizedlist">
-<ul type="disc">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.intrinsics"></a><a class="link" href="intrinsics.html" title="Support for Compiler Intrinsics &#32534;&#35793;&#22120;&#22266;&#26377;&#30340;&#25903;&#25345;"> Support for Compiler Intrinsics
+    &#32534;&#35793;&#22120;&#22266;&#26377;&#30340;&#25903;&#25345;</a>
+</h2></div></div></div>
+<p>
+ There are some traits that can not be implemented within the current C++ language:
+      to make these traits "just work" with user defined types, some kind
+ of additional help from the compiler is required. Currently (April 2008) Visual + C++ 8 and 9, GNU GCC 4.3 and MWCW 9 provide the necessary intrinsics, and other + compilers will no doubt follow in due course. <br> &#26377;&#19968;&#20123; traits &#22312;&#24403;&#21069;&#30340; + C++ &#35821;&#35328;&#20013;&#19981;&#33021;&#23454;&#29616;&#65306;&#20026;&#20102;&#35753;&#36825;&#20123; traits &#33021;&#21644;&#29992;&#25143;&#23450;&#20041;&#31867;&#22411;&#19968;&#36215;&#8220;&#27491;&#30830;&#22320;&#24037;&#20316;&#8221;&#65292;&#38656;&#35201;&#19968;&#20123;&#26469;&#33258;&#32534;&#35793;&#22120;&#30340;&#39069;&#22806;&#30340;&#24110;&#21161;&#12290; + &#29616;&#22312;&#65288;2008 &#24180; 4 &#26376;&#65289;Visual C++ 8 &#21644; 9, GNU GCC 4.3 &#20197;&#21450; MWCW 9 &#25552;&#20379;&#20102;&#24517;&#35201;&#30340;&#20869;&#37096;&#29305;&#24615;&#65292;&#20854;&#23427;&#32534;&#35793;&#22120;&#26080;&#30097;&#20250;&#21450;&#26102;&#36319;&#36827;&#12290;
+    </p>
+<p>
+ The Following traits classes always need compiler support to do the right thing + for all types (but all have safe fallback positions if this support is unavailable):<br> + &#19979;&#38754;&#30340; traits &#31867;&#23545;&#20110;&#25152;&#26377;&#31867;&#22411;&#37117;&#38656;&#35201;&#32534;&#35793;&#22120;&#30340;&#25903;&#25345;&#25165;&#33021;&#27491;&#24120;&#24037;&#20316;&#65288;&#19981;&#36807;&#65292;&#22914;&#26524;&#27809;&#26377;&#36825;&#20123;&#25903;&#25345;&#65292;&#23427;&#20204;&#20063;&#37117;&#20250;&#23433;&#20840;&#22320;&#36864;&#22238;&#21407;&#20301;&#65289;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
<li><a class="link" href="reference/is_union.html" title="is_union">is_union</a></li> <li><a class="link" href="reference/is_pod.html" title="is_pod">is_pod</a></li> <li><a class="link" href="reference/has_trivial_constructor.html" title="has_trivial_constructor">has_trivial_constructor</a></li>
@@ -51,269 +52,304 @@
<li><a class="link" href="reference/has_nothrow_copy.html" title="has_nothrow_copy">has_nothrow_copy</a></li> <li><a class="link" href="reference/has_nothrow_assign.html" title="has_nothrow_assign">has_nothrow_assign</a></li> <li><a class="link" href="reference/has_virtual_destructor.html" title="has_virtual_destructor">has_virtual_destructor</a></li>
-</ul>
-</div>
-<p>下面的 traits 类在 C++ 语言中不能可移植地实现,但是,在实践中,这个实现 在我们所知道的编译器上做的事情总是正确的:</p>
-<div class="itemizedlist">
-<ul type="disc">
+</ul></div>
+<p>
+ The following traits classes can't be portably implemented in the C++ language, + although in practice, the implementations do in fact do the right thing on + all the compilers we know about:<br> &#19979;&#38754;&#30340; traits &#31867;&#22312; C++ &#35821;&#35328;&#20013;&#19981;&#33021;&#21487;&#31227;&#26893;&#22320;&#23454;&#29616;&#65292;&#20294;&#26159;&#65292;&#22312;&#23454;&#36341;&#20013;&#65292;&#36825;&#20010;&#23454;&#29616;&#22312;&#25105;&#20204;&#25152;&#30693;&#36947;&#30340;&#32534;&#35793;&#22120;&#19978;&#20570;&#30340;&#20107;&#24773;&#24635;&#26159;&#27491;&#30830;&#30340;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
<li><a class="link" href="reference/is_empty.html" title="is_empty">is_empty</a></li> <li><a class="link" href="reference/is_polymorphic.html" title="is_polymorphic">is_polymorphic</a></li>
-</ul>
-</div>
-<p>下面的 traits 类依赖于上面一个或多个 traits 类:</p>
-<div class="itemizedlist">
-<ul type="disc">
+</ul></div>
+<p>
+ The following traits classes are dependent on one or more of the above:<br> + &#19979;&#38754;&#30340; traits &#31867;&#20381;&#36182;&#20110;&#19978;&#38754;&#19968;&#20010;&#25110;&#22810;&#20010; traits &#31867;&#65306;
+    </p>
+<div class="itemizedlist"><ul type="disc">
<li><a class="link" href="reference/is_class.html" title="is_class">is_class</a></li> <li><a class="link" href="reference/is_stateless.html" title="is_stateless">is_stateless</a></li>
-</ul>
-</div>
-<p>为编译器固有支持准备的钩子定义在 <a href="../../../../../boost/type_traits/intrinsics.hpp" target="_top">boost/type_traits/intrinsics.hpp</a>
-中,为新的编译器增加支持只不过是定义下面一个或多个宏:</p>
+</ul></div>
+<p>
+ The hooks for compiler-intrinsic support are defined in <a href="../../../../../boost/type_traits/intrinsics.hpp" target="_top">boost/type_traits/intrinsics.hpp</a>, + adding support for new compilers is simply a matter of defining one of more + of the following macros:<br> &#20026;&#32534;&#35793;&#22120;&#22266;&#26377;&#25903;&#25345;&#20934;&#22791;&#30340;&#38057;&#23376;&#23450;&#20041;&#22312; + <a href="../../../../../boost/type_traits/intrinsics.hpp" target="_top">boost/type_traits/intrinsics.hpp</a> + &#20013;&#65292;&#20026;&#26032;&#30340;&#32534;&#35793;&#22120;&#22686;&#21152;&#25903;&#25345;&#21482;&#19981;&#36807;&#26159;&#23450;&#20041;&#19979;&#38754;&#19968;&#20010;&#25110;&#22810;&#20010;&#23439;&#65306;
+    </p>
 <div class="table">
-<a name="id2642766"></a>
-<p class="title"><b>表&nbsp;1.4. 为编译器固有支持定义的宏</b></p>
-</div>
-<br class="table-break">
-<table class="table">
+<a name="id4866886"></a><p class="title"><b>Table&#160;1.4.&#160;Macros for Compiler Intrinsics &#20026;&#32534;&#35793;&#22120;&#22266;&#26377;&#25903;&#25345;&#23450;&#20041;&#30340;&#23439;</b></p> +<div class="table-contents"><table class="table" summary="Macros for Compiler Intrinsics &#20026;&#32534;&#35793;&#22120;&#22266;&#26377;&#25903;&#25345;&#23450;&#20041;&#30340;&#23439;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+              <p>
+                BOOST_IS_UNION(T)
+              </p>
+            </th>
+<th>
+              <p>
+ Should evaluate to true if T is a union type<br> &#22914;&#26524; T &#26159;&#19968;&#20010; + union &#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </th>
+</tr></thead>
 <tbody>
 <tr>
 <td>
-<div>
-<p>BOOST_IS_UNION(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_IS_POD(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 是一个 union 类型,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T is a POD type<br> &#22914;&#26524; T &#26159;&#19968;&#20010; + POD &#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_IS_POD(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_IS_EMPTY(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 是一个 POD 类型,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T is an empty struct or union<br> &#22914;&#26524; + T &#26159;&#19968;&#20010;&#31354;&#30340; struct &#25110; union&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_IS_EMPTY(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 是一个空的 struct 或 union,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if the default constructor for T is trivial + (i.e. has no effect)<br> &#22914;&#26524; T &#30340;&#32570;&#30465;&#26500;&#36896;&#20989;&#25968;&#26159; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#65288;&#20063;&#23601;&#26159;&#35828;&#65292;&#36215;&#19981;&#20102;&#20160;&#20040;&#20316;&#29992;&#65289;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040;
+                true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_TRIVIAL_CONSTRUCTOR(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_TRIVIAL_COPY(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 的缺省构造函数是 trivial(非特殊)的(也就是说,起不了什么作用 ),则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T has a trivial copy constructor (and + can therefore be replaced by a call to memcpy)<br> &#22914;&#26524; T &#26377;&#19968;&#20010; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#25335;&#36125;&#26500;&#36896;&#20989;&#25968;&#65288;&#24182;&#22240;&#27492;&#21487;&#20197;&#36890;&#36807;&#35843;&#29992; + memcpy &#26469;&#37325;&#26032;&#35774;&#32622;&#65289;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_TRIVIAL_COPY(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_TRIVIAL_ASSIGN(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 有一个 trivial(非特殊)的拷贝构造函数(并因此可以通过调用 memcpy
-来重新设置),则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T has a trivial assignment operator (and + can therefore be replaced by a call to memcpy)<br> &#22914;&#26524; T &#26377;&#19968;&#20010; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#32570;&#30465;&#22797;&#21046;&#25805;&#20316;&#31526;&#65288;&#24182;&#22240;&#27492;&#21487;&#20197;&#36890;&#36807;&#35843;&#29992; + memcpy &#26469;&#37325;&#26032;&#35774;&#32622;&#65289;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_TRIVIAL_ASSIGN(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_TRIVIAL_DESTRUCTOR(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 有一个 trivial(非特殊)的缺省复制操作符(并因此可以通过调用 memcpy
-来重新设置),则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T has a trivial destructor (i.e. ~T() + has no effect)<br> &#22914;&#26524; T &#26377;&#19968;&#20010; trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26512;&#26500;&#20989;&#25968;&#65288;&#20063;&#23601;&#26159;&#35828;&#65292;~T() + &#36215;&#19981;&#20102;&#20160;&#20040;&#20316;&#29992;&#65289;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_TRIVIAL_DESTRUCTOR(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_NOTHROW_CONSTRUCTOR(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 有一个 trivial(非特殊)的析构函数(也就是说,~T() 起不了什么作用 ),则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span> + <span class="identifier">x</span><span class="special">;</span></code> + can not throw<br> &#22914;&#26524; T x; &#19981;&#20250;&#25243;&#20986;&#24322;&#24120;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040;
+                true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_NOTHROW_CONSTRUCTOR(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_NOTHROW_COPY(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 <code class="computeroutput"><span class="identifier">T</span> <span class="identifier">x</span><span class="special">;</span></code>
-不会抛出异常,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code> can not throw<br> &#22914;&#26524; T(t) + &#19981;&#20250;&#25243;&#20986;&#24322;&#24120;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_NOTHROW_COPY(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_NOTHROW_ASSIGN(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">t</span><span class="special">)</span></code>
-不会抛出异常,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if <code class="computeroutput"><span class="identifier">T</span> + <span class="identifier">t</span><span class="special">,</span> + <span class="identifier">u</span><span class="special">;</span> + <span class="identifier">t</span> <span class="special">=</span> + <span class="identifier">u</span></code> can not throw<br> &#22914;&#26524; + T t, u; t = u &#19981;&#20250;&#25243;&#20986;&#24322;&#24120;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_NOTHROW_ASSIGN(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_HAS_VIRTUAL_DESTRUCTOR(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 <code class="computeroutput"><span class="identifier">T</span> <span class="identifier">t</span><span class="special">, -</span><span class="identifier">u</span><span class="special">;</span> <span class="identifier">t</span> -<span class="special">=</span> <span class="identifier">u</span></code> 不 会抛出异常,则应该得到
-true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true T has a virtual destructor<br> &#22914;&#26524; T + &#26377;&#19968;&#20010;&#34394;&#25311;&#26512;&#26500;&#20989;&#25968;&#65292;&#21017;&#24212;&#35813;&#24471;&#21040; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<div>
-<p>BOOST_HAS_VIRTUAL_DESTRUCTOR(T)</p>
-</div>
-</td>
+              <p>
+                BOOST_IS_ABSTRACT(T)
+              </p>
+            </td>
 <td>
-<div>
-<p>如果 T 有一个虚拟析构函数,则应该得到 true</p>
-</div>
-</td>
+              <p>
+ Should evaluate to true if T is an abstract type<br> &#22914;&#26524; T &#26159;&#19968;&#20010;&#25277;&#35937;&#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026;
+                true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_ABSTRACT(T)
-</p>
-</td>
+              <p>
+                BOOST_IS_BASE_OF(T,U)
+              </p>
+            </td>
 <td>
-<p>如果 T 是一个抽象类型,则应该求值为 true
-</p>
-</td>
+              <p>
+ Should evaluate to true if T is a base class of U<br> &#22914;&#26524; T + &#26159;&#19968;&#20010; U &#30340;&#22522;&#31867;&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_BASE_OF(T,U)
-</p>
-</td>
+              <p>
+                BOOST_IS_CLASS(T)
+              </p>
+            </td>
 <td>
-<p>如果 T 是一个 U 的基类,则应该求值为 true
-</p>
-</td>
+              <p>
+ Should evaluate to true if T is a class type<br> &#22914;&#26524; T &#26159;&#19968;&#20010;&#31867;&#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026;
+                true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_CLASS(T)
-</p>
-</td>
+              <p>
+                BOOST_IS_CONVERTIBLE(T,U)
+              </p>
+            </td>
 <td>
-<p>如果 T 是一个类类型,则应该求值为 true
-</p>
-</td>
+              <p>
+ Should evaluate to true if T is convertible to U<br> &#22914;&#26524; T &#21487;&#36716;&#25442;&#20026; + U&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_CONVERTIBLE(T,U)
-</p>
-</td>
+              <p>
+                BOOST_IS_ENUM(T)
+              </p>
+            </td>
 <td>
-<p>如果 T 可转换为 U,则应该求值为 true
-</p>
-</td>
+              <p>
+ Should evaluate to true is T is an enum<br> &#22914;&#26524; T &#26159;&#19968;&#20010;&#26522;&#20030;&#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026;
+                true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_ENUM(T)
-</p>
-</td>
+              <p>
+                BOOST_IS_POLYMORPHIC(T)
+              </p>
+            </td>
 <td>
-<p>如果 T 是一个枚举类型,则应该求值为 true
-</p>
-</td>
+              <p>
+ Should evaluate to true if T is a polymorphic type<br> &#22914;&#26524; T + &#26159;&#19968;&#20010;&#22810;&#24577;&#31867;&#22411;&#65292;&#21017;&#24212;&#35813;&#27714;&#20540;&#20026; true
+              </p>
+            </td>
 </tr>
 <tr>
 <td>
-<p>
-BOOST_IS_POLYMORPHIC(T)
-</p>
-</td>
+              <p>
+                BOOST_ALIGNMENT_OF(T)
+              </p>
+            </td>
 <td>
-<p>如果 T 是一个多态类型,则应该求值为 true
-</p>
-</td>
-</tr>
-<tr>
-<td>
-<p>
-BOOST_ALIGNMENT_OF(T)
-</p>
-</td>
-<td>
-<p>应该求值为类型 T 的对齐要求
-</p>
-</td>
+              <p>
+ Should evaluate to the alignment requirements of type T.<br> &#24212;&#35813;&#27714;&#20540;&#20026;&#31867;&#22411;
+                T &#30340;&#23545;&#40784;&#35201;&#27714;&#12290;
+              </p>
+            </td>
 </tr>
 </tbody>
-</table>
+</table></div>
 </div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-<tbody>
-<tr>
-<td align="left"></td>
-<td align="right">
-<div class="copyright-footer">Copyright (c) 2000, 2006
-Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey
-Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John
-Maddock, Alexander Nasonov, Thorsten Ottosen, Robert Ramey and Jeremy
-Siek
-<p> Distributed under the Boost Software License, Version
-1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-</p>
+<br class="table-break">
 </div>
-</td>
-</tr>
-</tbody>
-</table>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, + Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat + Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
+      Ramey and Jeremy Siek<p>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying + file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
+      </p>
+</div></td>
+</tr></table>
 <hr>
-<div class="spirit-nav"><a accesskey="p" href="user_defined.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+<div class="spirit-nav">
+<a accesskey="p" href="user_defined.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="mpl.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-</body></html>
+</body>
+</html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/intro.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/intro.html Wed Jun 2 00:58:52 2010
@@ -1,100 +1,73 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Introduction</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
- <link rel="prev" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="next" href="background.html" title="Background and Tutorial">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Introduction &#31616;&#20171;</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="next" href="background.html" title="Background and Tutorial &#32972;&#26223;&#21644;&#25351;&#21335;">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="background.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.intro"></a><a class="link" href="intro.html" title="Introduction">简介</a>
-</h2>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.intro"></a><a class="link" href="intro.html" title="Introduction &#31616;&#20171;"> Introduction &#31616;&#20171;</a>
+</h2></div></div></div>
+<p>
+ The Boost type-traits library contains a set of very specific traits classes, + each of which encapsulate a single trait from the C++ type system; for example, + is a type a pointer or a reference type? Or does a type have a trivial constructor, + or a const-qualifier?<br> Boost type-traits &#24211;&#21253;&#21547;&#19968;&#22871;&#38750;&#24120;&#35814;&#32454;&#30340; + traits classes&#65288;&#29305;&#24449;&#31867;&#65289;&#65292;&#27599;&#19968;&#20010;&#23553;&#35013;&#19968;&#20010; C++ &#31867;&#22411;&#31995;&#32479;&#30340;&#21333;&#19968;&#29305;&#24449;&#12290; + &#20363;&#22914;&#65292;&#26576;&#20010;&#31867;&#22411;&#26159;&#19968;&#20010;&#25351;&#38024;&#36824;&#26159;&#19968;&#20010;&#24341;&#29992;&#31867;&#22411;&#65311;&#25110;&#32773;&#26576;&#20010;&#31867;&#22411;&#26159;&#21542;&#26377;&#19968;&#20010; + trivial&#65288;&#38750;&#29305;&#27530;&#65289;&#30340;&#26500;&#36896;&#20989;&#25968;&#25110;&#32773;&#26377;&#19968;&#20010; const &#20462;&#39280;&#31526;&#65311;
+    </p>
+<p>
+ The type-traits classes share a unified design: each class inherits from a + the type <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + if the type has the specified property and inherits from <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a> + otherwise.<br> &#36825;&#20123; type-traits &#31867;&#20849;&#20139;&#19968;&#20010;&#32479;&#19968;&#30340;&#35774;&#35745;&#65306;&#22914;&#26524;&#36825;&#20010;&#31867;&#22411;&#20855;&#26377;&#29305;&#23450;&#30340;&#23646;&#24615;&#65292;&#21017;&#20174;&#31867;&#22411; + <a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a> + &#32487;&#25215;&#65292;&#21542;&#21017;&#20174; <a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a>
+      &#32487;&#25215;&#12290;
+    </p>
+<p>
+ The type-traits library also contains a set of classes that perform a specific + transformation on a type; for example, they can remove a top-level const or + volatile qualifier from a type. Each class that performs a transformation defines + a single typedef-member <code class="computeroutput"><span class="identifier">type</span></code> + that is the result of the transformation.<br> type-traits &#24211;&#36824;&#21253;&#21547;&#19968;&#22871;&#21487;&#20197;&#23545;&#26576;&#20010;&#31867;&#22411;&#25191;&#34892;&#29305;&#23450;&#36716;&#25442;&#30340;&#31867;&#65292;&#20363;&#22914;&#65292;&#20182;&#20204;&#21487;&#20197;&#20174;&#19968;&#20010;&#31867;&#22411;&#20013;&#31227;&#38500;&#19968;&#20010;&#39030;&#23618;&#30340; + const &#25110; volatile &#20462;&#39280;&#31526;&#12290; &#27599;&#19968;&#20010;&#25191;&#34892;&#36716;&#25442;&#30340;&#31867;&#37117;&#20026;&#36716;&#25442;&#30340;&#32467;&#26524;&#23450;&#20041;&#20102;&#19968;&#20010;&#21333;&#29420;&#30340; + typedef &#25104;&#21592; <code class="computeroutput"><span class="identifier">type</span></code>&#12290;
+    </p>
 </div>
-</div>
-</div>
-
-<p>Boost type-traits 库包含一套非常详细的 traits classes(特征类),每一个 封装一个 C++ -类型系统的单一特征。例如,某个类型是一个指针还是一个引用类型?或者某个类型 是否有一个 trivial(非特殊)的构造函数或者有一个 const 修饰符?</p>
-
-<p>这些 type-traits 类共享一个统一的设计:如果这个类型具有特定的属性,则从 类型 <a title=" integral_constant" href="reference/integral_constant.html">true_type</a> -继承,否则从 <a title=" integral_constant" href="reference/integral_constant.html">false_type</a>
-继承。</p>
-
-<p>type-traits 库还包含一套可以对某个类型执行特定转换的类,例如,他们可以从 一个类型中移除一个顶层的 const 或 volatile -修饰符。每一个执行转换的类都为转换的结果定义了一个单独的 typedef 成员 <code class="computeroutput"><span class="identifier">type</span></code>。 </p>
-</div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="background.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/mpl.html Wed Jun 2 00:58:52 2010
@@ -1,147 +1,72 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>MPL Interoperability</title>
- <link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
- <link rel="up" href="../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
- <link rel="prev" href="intrinsics.html" title="Support for Compiler Intrinsics">
-
-
-
-  <link rel="next" href="examples.html" title="Examples">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>MPL Interoperability &#19982;MPL&#30340;&#20114;&#25805;&#20316;&#24615;</title> +<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="prev" href="intrinsics.html" title="Support for Compiler Intrinsics &#32534;&#35793;&#22120;&#22266;&#26377;&#30340;&#25903;&#25345;">
+<link rel="next" href="examples.html" title="Examples &#31034;&#20363;">
 </head>
-
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../boost.png" height="86" width="277"></td>
-
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="intrinsics.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">
-<a name="boost_typetraits.mpl"></a><a class="link" href="mpl.html" title="MPL Interoperability"> MPL 互操作性</a>
-</h2>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_typetraits.mpl"></a><a class="link" href="mpl.html" title="MPL Interoperability &#19982;MPL&#30340;&#20114;&#25805;&#20316;&#24615;"> MPL Interoperability &#19982;MPL&#30340;&#20114;&#25805;&#20316;&#24615;</a>
+</h2></div></div></div>
+<p>
+ All the value based traits in this library conform to MPL's requirements for + an <a href="../../../../../libs/mpl/doc/refmanual/integral-constant.html" target="_top">Integral + Constant type</a>: that includes a number of rather intrusive workarounds + for broken compilers. <br> &#22312;&#36825;&#20010;&#24211;&#20013;&#65292;&#25152;&#26377;&#22522;&#20110; traits &#30340;&#20540;&#37117;&#31526;&#21512; + MPL &#23545;&#20110;&#19968;&#20010; <a href="../../../../../libs/mpl/doc/refmanual/integral-constant.html" target="_top">&#25972;&#24120;&#31867;&#22411;</a> + &#30340;&#35201;&#27714;&#65306;&#21253;&#21547;&#19968;&#20010;&#20026;&#19981;&#23436;&#25972;&#32534;&#35793;&#22120;&#21512;&#29702;&#22320;&#25554;&#20837; workarounds &#30340;&#25968;&#12290;
+    </p>
+<p>
+ Purely as an implementation detail, this means that <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code></a>, + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code></a>, + and <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> + <span class="identifier">v</span><span class="special">&gt;</span></code> + inherits from <a href="../../../../../libs/mpl/doc/refmanual/integral-c.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">v</span><span class="special">&gt;</span></code></a> + (provided <code class="computeroutput"><span class="identifier">T</span></code> is not <code class="computeroutput"><span class="keyword">bool</span></code>)<br> &#36825;&#32431;&#31929;&#26159;&#19968;&#20010;&#23454;&#29616;&#32454;&#33410;&#65292;&#36825;&#24847;&#21619;&#30528; + <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">true_type</a></code> + &#20174; <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code></a> + &#32487;&#25215;&#65292; <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">false_type</a></code> + &#20174; <a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code></a> + &#32487;&#25215;&#65292; <code class="computeroutput"><a class="link" href="reference/integral_constant.html" title="integral_constant">integral_constant</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> + <span class="identifier">v</span><span class="special">&gt;</span></code> + &#20174; <a href="../../../../../libs/mpl/doc/refmanual/integral-c.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">v</span><span class="special">&gt;</span></code></a>&#65288;&#22914;&#26524; + <code class="computeroutput"><span class="identifier">T</span></code> &#19981;&#26159; <code class="computeroutput"><span class="keyword">bool</span></code>&#65289;&#32487;&#25215;&#12290;
+    </p>
 </div>
-
-</div>
-
-</div>
-
-
-<p>在这个库中,所有基于 traits 的值都符合 MPL 对于一个 <a href="../../../../../libs/mpl/doc/refmanual/integral-constant.html" target="_top">Integral Constant type(整常类型)</a>的要求:包含一个为不完整 编译器合理地插入 workarounds
-的数。</p>
-
-
-<p>这纯粹是一个实现细节,这意味着 <code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">true_type</a></code> 从 -<a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span></code></a> 继承,<code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">false_type</a></code> 从 -<a href="../../../../../libs/mpl/doc/refmanual/bool.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span></code></a> 继承,<code class="computeroutput"><a title=" integral_constant" href="reference/integral_constant.html">integral_constant</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">v</span><span class="special">&gt;</span></code> 从 <a href="../../../../../libs/mpl/doc/refmanual/integral-c.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">integral_c</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">v</span><span class="special">&gt;</span></code></a>(如 果 <code class="computeroutput"><span class="identifier">T</span></code> 不 是 <code class="computeroutput"><span class="keyword">bool</span></code>)继 承。</p>
-
-</div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="intrinsics.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html Thu Sep 4 19:58:01 2008 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_const.html Wed Jun 2 00:58:52 2010
@@ -1,327 +1,150 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>add_const</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
-  <link rel="up" href="../reference.html" title="Alphabetical Reference">
-
-
-
-  <link rel="prev" href="../reference.html" title="Alphabetical Reference">
-
-
-
-  <link rel="next" href="add_cv.html" title="add_cv">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>add_const</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;"> +<link rel="prev" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;">
+<link rel="next" href="add_cv.html" title="add_cv">
 </head>
-
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_cv.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
+<div class="titlepage"><div><div><h3 class="title">
<a name="boost_typetraits.reference.add_const"></a><a class="link" href="add_const.html" title="add_const"> add_const</a>
-</h3>
-
-</div>
-
-</div>
-
-</div>
-
-
+</h3></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_const</span>
 <span class="special">{</span>
<span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-
-
 <p>
-        </p>
-
-<p><span class="bold"><strong>类型:</strong></span>对于所有的 <code class="computeroutput"><span class="identifier">T</span></code> 与 <code class="computeroutput"><span class="identifier">T</span> <span class="keyword">const</span></code> 类型相同。</p>
-
-
-<p><span class="bold"><strong>C++ 标准参考:</strong></span>3.9.3。</p>
-
-
-<p><span class="bold"><strong>编译器兼容性:</strong></span>如果编译器不支 持类模板的偏特化,这个模板也可以编译,但是成员 <code class="computeroutput"><span class="identifier">type</span></code> 总是和 <code class="computeroutput"><span class="identifier">T</span></code> 类型相 同,除非&nbsp;<a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">编 译器 workarounds</a>
-可用。</p>
-
-
-<p><span class="bold"><strong>头文件:</strong></span><code class="computeroutput"><span class="preprocessor">#include</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 或 <code class="computeroutput"><span class="preprocessor">#include</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></p>
-
+ <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">const</span></code> for all <code class="computeroutput"><span class="identifier">T</span></code>. + <br> <span class="bold"><strong>type:</strong></span> &#23545;&#20110;&#25152;&#26377;&#30340; <code class="computeroutput"><span class="identifier">T</span></code> &#19982; <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">const</span></code> &#31867;&#22411;&#30456;&#21516;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
+      </p>
+<p>
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied.<br> <span class="bold"><strong>Compiler + Compatibility:</strong></span> &#22914;&#26524;&#32534;&#35793;&#22120;&#19981;&#25903;&#25345;&#31867;&#27169;&#26495;&#30340;&#20559;&#29305;&#21270;&#65292;&#36825;&#20010;&#27169;&#26495;&#20063;&#21487;&#20197;&#32534;&#35793;&#65292;&#20294;&#26159;&#25104;&#21592; + <code class="computeroutput"><span class="identifier">type</span></code> &#24635;&#26159;&#21644; <code class="computeroutput"><span class="identifier">T</span></code> &#31867;&#22411;&#30456;&#21516;&#65292;&#38500;&#38750; <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
+        workarounds</a> &#21487;&#29992;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
 <div class="table">
-<a name="id2647187"></a>
-<p class="title"><b>表&nbsp;1.5. 示例</b></p>
-
-
-<div class="table-contents">
-<table class="table" summary="Examples">
-
-
-  <colgroup><col><col></colgroup>
-  <thead><tr>
-
-
-    <th>
-
-
-    <p>表达式
-            </p>
-
-
-            </th>
-
-
-    <th>
-
-
-    <p>结果类型
-            </p>
-
-
-            </th>
-
-
-  </tr>
-
-  </thead>
-  <tbody>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
-              <span class="keyword">const</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-
-  </tbody>
-</table>
-
+<a name="id4872211"></a><p class="title"><b>Table&#160;1.5.&#160;Examples &#31034;&#20363;</b></p> +<div class="table-contents"><table class="table" summary="Examples &#31034;&#20363;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Expression &#34920;&#36798;&#24335;
+                </p>
+              </th>
+<th>
+                <p>
+                  Result Type &#32467;&#26524;&#31867;&#22411;
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span>
+                  <span class="keyword">const</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_const</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
 </div>
-
-
-</div>
-
-
 <br class="table-break">
-
-
 </div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_cv.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html Wed Jul 29 07:28:12 2009 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_cv.html Wed Jun 2 00:58:52 2010
@@ -1,231 +1,153 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>add_cv</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-  <link rel="up" href="../reference.html" title="Alphabetical Reference">
-
-  <link rel="prev" href="add_const.html" title="add_const">
-
-  <link rel="next" href="add_pointer.html" title="add_pointer">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>add_cv</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;">
+<link rel="prev" href="add_const.html" title="add_const">
+<link rel="next" href="add_pointer.html" title="add_pointer">
 </head>
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-<table cellpadding="2" width="100%">
-  <tbody>
-    <tr>
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-    </tr>
-  </tbody>
-</table>
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_const.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_pointer.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
+<div class="titlepage"><div><div><h3 class="title">
<a name="boost_typetraits.reference.add_cv"></a><a class="link" href="add_cv.html" title="add_cv"> add_cv</a>
-</h3>
-</div>
-</div>
-</div>
-
+</h3></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">struct</span> <span class="identifier">add_cv</span>
 <span class="special">{</span>
<span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-
 <p>
-        </p>
-<p><span class="bold"><strong>类型:</strong></span>对于所有的 <code class="computeroutput"><span class="identifier">T</span></code> 与 <code class="computeroutput"><span class="identifier">T</span> <span class="keyword">const</span> <span class="keyword">volatile</span></code> 类 型相同。</p>
-
-<p><span class="bold"><strong>C++ 标准参考:</strong></span>3.9.3。</p>
-
-<p><span class="bold"><strong>编译器兼容性:</strong></span>如果编译器不支 持类模板的偏特化,这个模板也可以编译,但是成员 <code class="computeroutput"><span class="identifier">type</span></code> 总是和 <code class="computeroutput"><span class="identifier">T</span></code> 类型相 同,除非<a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">编 译器 workarounds</a>
-可用。</p>
-
-<p><span class="bold"><strong>头文件:</strong></span><code class="computeroutput"><span class="preprocessor">#include</span> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">T</span> + <span class="keyword">const</span> <span class="keyword">volatile</span></code> + for all <code class="computeroutput"><span class="identifier">T</span></code>. <br> <span class="bold"><strong>type:</strong></span> &#23545;&#20110;&#25152;&#26377;&#30340; <code class="computeroutput"><span class="identifier">T</span></code> + &#19982; <code class="computeroutput"><span class="identifier">T</span> <span class="keyword">const</span> + <span class="keyword">volatile</span></code> &#31867;&#22411;&#30456;&#21516;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 3.9.3.
+      </p>
+<p>
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied.<br> <span class="bold"><strong>Compiler + Compatibility:</strong></span> &#22914;&#26524;&#32534;&#35793;&#22120;&#19981;&#25903;&#25345;&#31867;&#27169;&#26495;&#30340;&#20559;&#29305;&#21270;&#65292;&#36825;&#20010;&#27169;&#26495;&#20063;&#21487;&#20197;&#32534;&#35793;&#65292;&#20294;&#26159;&#25104;&#21592; + <code class="computeroutput"><span class="identifier">type</span></code> &#24635;&#26159;&#21644; <code class="computeroutput"><span class="identifier">T</span></code> &#31867;&#22411;&#30456;&#21516;&#65292;&#38500;&#38750; <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
+        workarounds</a> &#21487;&#29992;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
       </p>
-
 <div class="table">
-<a name="id2647768"></a>
-<p class="title"><b>表&nbsp;1.6. 示例</b></p>
-
-<div class="table-contents">
-<table class="table" summary="Examples">
-
-  <colgroup><col><col></colgroup>
-  <thead><tr>
-
-    <th>
-
-    <p>表达式
-            </p>
-
-            </th>
-
-    <th>
-
-    <p>结果类型
-            </p>
-
-            </th>
-
-  </tr>
-  </thead>
-  <tbody>
-
-    <tr>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-            </td>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
-              <span class="keyword">volatile</span></code>
-            </p>
-
-            </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-            </td>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
-            </p>
-
-            </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-            </td>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span> - <span class="keyword">const</span> <span class="keyword">volatile</span></code>
-            </p>
-
-            </td>
-
-    </tr>
-
-    <tr>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-            </td>
-
-      <td>
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
-              <span class="keyword">volatile</span></code>
-            </p>
-
-            </td>
-
-    </tr>
-
-  </tbody>
-</table>
+<a name="id4872884"></a><p class="title"><b>Table&#160;1.6.&#160;Examples &#31034;&#20363;</b></p> +<div class="table-contents"><table class="table" summary="Examples &#31034;&#20363;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Expression &#34920;&#36798;&#24335;
+                </p>
+              </th>
+<th>
+                <p>
+                  Result Type &#32467;&#26524;&#31867;&#22411;
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
+                  <span class="keyword">volatile</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span> + <span class="keyword">const</span> <span class="keyword">volatile</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_cv</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span>
+                  <span class="keyword">volatile</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
 </div>
-
-</div>
-
 <br class="table-break">
-
 </div>
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-  <tbody>
-    <tr>
-
-      <td align="left"></td>
-
-      <td align="right">
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_const.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_pointer.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html Wed Jul 29 07:28:12 2009 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_pointer.html Wed Jun 2 00:58:52 2010
@@ -1,332 +1,152 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>add_pointer</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
-  <link rel="up" href="../reference.html" title="Alphabetical Reference">
-
-
-
-  <link rel="prev" href="add_cv.html" title="add_cv">
-
-
-
-  <link rel="next" href="add_reference.html" title="add_reference">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>add_pointer</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;">
+<link rel="prev" href="add_cv.html" title="add_cv">
+<link rel="next" href="add_reference.html" title="add_reference">
 </head>
-
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_cv.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
+<div class="titlepage"><div><div><h3 class="title">
<a name="boost_typetraits.reference.add_pointer"></a><a class="link" href="add_pointer.html" title="add_pointer"> add_pointer</a>
-</h3>
-
-</div>
-
-</div>
-
-</div>
-
-
+</h3></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_pointer</span>
 <span class="special">{</span>
<span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-
-
 <p>
-        </p>
-
-<p><span class="bold"><strong>类型:</strong></span>与 <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span></code> 类型相同。</p>
-
-
-<p>这个模板的基本原理是:当 <code class="computeroutput"><span class="identifier">t</span></code> 是类型 <code class="computeroutput"><span class="identifier">T</span></code> 的一个对象 时,它生成和 <code class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&amp;</span><span class="identifier">t</span><span class="special">)</span></code> 一样的类 型。</p>
-
-
-<p><span class="bold"><strong>C++ 标准参考:</strong></span>8.3.1。</p>
-
-
-<p><span class="bold"><strong>编译器兼容性:</strong></span>如果编译器不支 持类模板的偏特化,这个模板也可以编译,但是成员 <code class="computeroutput"><span class="identifier">type</span></code> 总是和 <code class="computeroutput"><span class="identifier">T</span></code> 类型相 同,除非<a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">编 译器 workarounds</a>
-可用。</p>
-
-
-<p><span class="bold"><strong>头文件:</strong></span><code class="computeroutput"><span class="preprocessor">#include</span> - <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 或 <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + <span class="bold"><strong>type:</strong></span> The same type as <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span></code>. + <br> <span class="bold"><strong>type:</strong></span> &#19982; <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">*</span></code> &#31867;&#22411;&#30456;&#21516;&#12290;
       </p>
-
-
+<p>
+ The rationale for this template is that it produces the same type as <code class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&amp;</span><span class="identifier">t</span><span class="special">)</span></code>, where + <code class="computeroutput"><span class="identifier">t</span></code> is an object of type <code class="computeroutput"><span class="identifier">T</span></code>.<br> &#36825;&#20010;&#27169;&#26495;&#30340;&#22522;&#26412;&#21407;&#29702;&#26159;&#65306;&#24403; + <code class="computeroutput"><span class="identifier">t</span></code> &#26159;&#31867;&#22411; <code class="computeroutput"><span class="identifier">T</span></code> &#30340;&#19968;&#20010;&#23545;&#35937;&#26102;&#65292;&#23427;&#29983;&#25104;&#21644; <code class="computeroutput"><span class="identifier">TYPEOF</span><span class="special">(&amp;</span><span class="identifier">t</span><span class="special">)</span></code> &#19968;&#26679;&#30340;&#31867;&#22411;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.1.
+      </p>
+<p>
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied.<br> <span class="bold"><strong>Compiler + Compatibility:</strong></span> &#22914;&#26524;&#32534;&#35793;&#22120;&#19981;&#25903;&#25345;&#31867;&#27169;&#26495;&#30340;&#20559;&#29305;&#21270;&#65292;&#36825;&#20010;&#27169;&#26495;&#20063;&#21487;&#20197;&#32534;&#35793;&#65292;&#20294;&#26159;&#25104;&#21592; + <code class="computeroutput"><span class="identifier">type</span></code> &#24635;&#26159;&#21644; <code class="computeroutput"><span class="identifier">T</span></code> &#31867;&#22411;&#30456;&#21516;&#65292;&#38500;&#38750; <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
+        workarounds</a> &#21487;&#29992;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
 <div class="table">
-<a name="id2648416"></a>
-<p class="title"><b>表&nbsp;1.7. 示例</b></p>
-
-
-<div class="table-contents">
-<table class="table" summary="Examples">
-
-
-  <colgroup><col><col></colgroup>
-  <thead><tr>
-
-
-    <th>
-
-
-    <p>表达式
-            </p>
-
-
-            </th>
-
-
-    <th>
-
-
-    <p>结果类型
-            </p>
-
-
-            </th>
-
-
-  </tr>
-
-  </thead>
-  <tbody>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-
-  </tbody>
-</table>
-
+<a name="id4873676"></a><p class="title"><b>Table&#160;1.7.&#160;Examples &#31034;&#20363;</b></p> +<div class="table-contents"><table class="table" summary="Examples &#31034;&#20363;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Expression &#34920;&#36798;&#24335;
+                </p>
+              </th>
+<th>
+                <p>
+                  Result Type &#32467;&#26524;&#31867;&#22411;
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">*</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">**</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
 </div>
-
-
-</div>
-
-
 <br class="table-break">
-
-
 </div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_cv.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 </body>
 </html>
=======================================
--- /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html Wed Jul 29 07:28:12 2009 +++ /trunk/libs/type_traits/doc/html/boost_typetraits/reference/add_reference.html Wed Jun 2 00:58:52 2010
@@ -1,329 +1,149 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>add_reference</title>
- <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-
- <link rel="start" href="../../index.html" title="Chapter&nbsp;1.&nbsp;Boost.TypeTraits">
-
-
-
-  <link rel="up" href="../reference.html" title="Alphabetical Reference">
-
-
-
-  <link rel="prev" href="add_pointer.html" title="add_pointer">
-
-
-
-  <link rel="next" href="add_volatile.html" title="add_volatile">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>add_reference</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
+<link rel="start" href="../../index.html" title="Chapter&#160;1.&#160;Boost.TypeTraits"> +<link rel="up" href="../reference.html" title="Alphabetical Reference &#23383;&#27597;&#39034;&#24207;&#30340;&#21442;&#32771;">
+<link rel="prev" href="add_pointer.html" title="add_pointer">
+<link rel="next" href="add_volatile.html" title="add_volatile">
 </head>
-
-
-<body alink="#0000ff" bgcolor="white" link="#0000ff" text="black" vlink="#840084">
-
-
-<table cellpadding="2" width="100%">
-
-  <tbody>
-
-    <tr>
-
-
- <td valign="top"><img alt="Boost C++ Libraries" src="../../../../../../boost.png" height="86" width="277"></td>
-
-
- <td align="center"><a href="../../../../../../index.html">Home</a></td>
-
-
- <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/people/people.htm";>People</a></td>
-
-
- <td align="center"><a href="http://www.boost.org/more/faq.htm";>FAQ</a></td>
-
-
- <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
+<td align="center"><a href="../../../../../libraries.htm">Libraries</a></td> +<td align="center"><a href="http://www.boost.org/users/people.html";>People</a></td> +<td align="center"><a href="http://www.boost.org/users/faq.html";>FAQ</a></td>
+<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_pointer.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_volatile.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
+<div class="titlepage"><div><div><h3 class="title">
<a name="boost_typetraits.reference.add_reference"></a><a class="link" href="add_reference.html" title="add_reference"> add_reference</a>
-</h3>
-
-</div>
-
-</div>
-
-</div>
-
-
+</h3></div></div></div>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">struct</span> <span class="identifier">add_reference</span>
 <span class="special">{</span>
<span class="keyword">typedef</span> <em class="replaceable"><code>see-below</code></em> <span class="identifier">type</span><span class="special">;</span>
 <span class="special">};</span>
 </pre>
-
-
 <p>
-        </p>
-
-<p><span class="bold"><strong>类型:</strong></span>如果 <code class="computeroutput"><span class="identifier">T</span></code> 不是一个引用 类型,则是 <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>,否则 是 <code class="computeroutput"><span class="identifier">T</span></code>。 </p>
-
-
-<p><span class="bold"><strong>C++ 标准参考:</strong></span>8.3.2。</p>
-
-
-<p><span class="bold"><strong>编译器兼容性:</strong></span>如果编译器不支 持类模板的偏特化,这个模板也可以编译,但是成员 <code class="computeroutput"><span class="identifier">type</span></code> 总是和 <code class="computeroutput"><span class="identifier">T</span></code> 类型相 同,除非<a href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">编 译器 workarounds</a>
-可用。</p>
-
-
-<p><span class="bold"><strong>头文件:</strong></span><code class="computeroutput"><span class="preprocessor">#include</span> - <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> 或 <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + <span class="bold"><strong>type:</strong></span> If <code class="computeroutput"><span class="identifier">T</span></code> + is not a reference type then <code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>, otherwise <code class="computeroutput"><span class="identifier">T</span></code>.<br> + <span class="bold"><strong>type:</strong></span> &#22914;&#26524; T &#19981;&#26159;&#19968;&#20010;&#24341;&#29992;&#31867;&#22411;&#65292;&#21017;&#26159;
+        T&amp;&#65292;&#21542;&#21017;&#26159; T&#12290;
       </p>
-
-
+<p>
+ <span class="bold"><strong>C++ Standard Reference:</strong></span> 8.3.2.
+      </p>
+<p>
+ <span class="bold"><strong>Compiler Compatibility:</strong></span> If the compiler + does not support partial specialization of class-templates then this template + will compile, but the member <code class="computeroutput"><span class="identifier">type</span></code> + will always be the same as type <code class="computeroutput"><span class="identifier">T</span></code> + except where <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler + workarounds</a> have been applied.<br> <span class="bold"><strong>Compiler + Compatibility:</strong></span> &#22914;&#26524;&#32534;&#35793;&#22120;&#19981;&#25903;&#25345;&#31867;&#27169;&#26495;&#30340;&#20559;&#29305;&#21270;&#65292;&#36825;&#20010;&#27169;&#26495;&#20063;&#21487;&#20197;&#32534;&#35793;&#65292;&#20294;&#26159;&#25104;&#21592; + <code class="computeroutput"><span class="identifier">type</span></code> &#24635;&#26159;&#21644; <code class="computeroutput"><span class="identifier">T</span></code> &#31867;&#22411;&#30456;&#21516;&#65292;&#38500;&#38750; <a class="link" href="../category/transform.html#boost_typetraits.category.transform.broken_compiler_workarounds_">compiler
+        workarounds</a> &#21487;&#29992;&#12290;
+      </p>
+<p>
+ <span class="bold"><strong>Header:</strong></span> <code class="computeroutput"> <span class="preprocessor">#include</span> + <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">add_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> + or <code class="computeroutput"> <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
+      </p>
 <div class="table">
-<a name="id2648996"></a>
-<p class="title"><b>表&nbsp;1.8. 示例</b></p>
-
-
-<div class="table-contents">
-<table class="table" summary="Examples">
-
-
-  <colgroup><col><col></colgroup>
-  <thead><tr>
-
-
-    <th>
-
-
-    <p>表达式
-            </p>
-
-
-            </th>
-
-
-    <th>
-
-
-    <p>结果类型
-            </p>
-
-
-            </th>
-
-
-  </tr>
-
-  </thead>
-  <tbody>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
-            </p>
-
-
-            </td>
-
-
-      <td>
-
-
-      <p>
- <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
-            </p>
-
-
-            </td>
-
-
-    </tr>
-
-
-
-  </tbody>
-</table>
-
+<a name="id4874318"></a><p class="title"><b>Table&#160;1.8.&#160;Examples &#31034;&#20363;</b></p> +<div class="table-contents"><table class="table" summary="Examples &#31034;&#20363;">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                <p>
+                  Expression &#34920;&#36798;&#24335;
+                </p>
+              </th>
+<th>
+                <p>
+                  Result Type &#32467;&#26524;&#31867;&#22411;
+                </p>
+              </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">&amp;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span> <span class="keyword">const</span><span class="special">&amp;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
+                </p>
+              </td>
+</tr>
+<tr>
+<td>
+                <p>
+ <code class="computeroutput"><span class="identifier">add_reference</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">*&amp;&gt;::</span><span class="identifier">type</span></code>
+                </p>
+              </td>
+<td>
+                <p>
+ <code class="computeroutput"><span class="keyword">int</span><span class="special">*&amp;</span></code>
+                </p>
+              </td>
+</tr>
+</tbody>
+</table></div>
 </div>
-
-
-</div>
-
-
 <br class="table-break">
-
-
 </div>
-
-
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%">
-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left"></td>
-
-
-      <td align="right">
-
- <div class="copyright-footer">Copyright &copy; 2000, 2006 Adobe Systems Inc, David Abrahams, +<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision"; width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2000, 2006 Adobe Systems Inc, David Abrahams, Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant, Jesse Jones, Mat Marcus, Itay Maman, John Maddock, Alexander Nasonov, Thorsten Ottosen, Robert
-      Ramey and Jeremy Siek
-
-      <p>
+      Ramey and Jeremy Siek<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"; target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">
<a accesskey="p" href="add_pointer.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="add_volatile.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
 </div>
-
-
 </body>
 </html>
=======================================
***Additional files exist in this changeset.***

Other related posts:

  • » [boost-doc-zh] r409 committed - 翻译 type_traits 库的 qbk 文件并生成 html 目录 - boost-doc-zh