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

From: boost-doc-zh@xxxxxxxxxxxxxx
To: boost-doc-zh-notify@xxxxxxxxxxxxx
Date: Wed, 24 Mar 2010 07:55:55 +0000

Revision: 391
Author: alai04
Date: Wed Mar 24 00:54:49 2010
Log: 翻译 optional 库的 qbk 文件并生成 html 目录
http://code.google.com/p/boost-doc-zh/source/detail?r=391

Modified:
 /trunk/libs/optional/doc/acknowledgments.qbk
 /trunk/libs/optional/doc/dependencies.qbk
 /trunk/libs/optional/doc/development.qbk
 /trunk/libs/optional/doc/examples.qbk

/trunk/libs/optional/doc/html/boost_optional/a_note_about_optional_bool_.html

 /trunk/libs/optional/doc/html/boost_optional/acknowledgments.html

/trunk/libs/optional/doc/html/boost_optional/dependencies_and_portability.html

 /trunk/libs/optional/doc/html/boost_optional/detailed_semantics.html
 /trunk/libs/optional/doc/html/boost_optional/development.html
 /trunk/libs/optional/doc/html/boost_optional/examples.html

/trunk/libs/optional/doc/html/boost_optional/exception_safety_guarantees.html

 /trunk/libs/optional/doc/html/boost_optional/implementation_notes.html
 /trunk/libs/optional/doc/html/boost_optional/in_place_factories.html
 /trunk/libs/optional/doc/html/boost_optional/optional_references.html

/trunk/libs/optional/doc/html/boost_optional/rebinding_semantics_for_assignment_of_optional_references.html

 /trunk/libs/optional/doc/html/boost_optional/synopsis.html
 /trunk/libs/optional/doc/html/boost_optional/type_requirements.html
 /trunk/libs/optional/doc/html/index.html
 /trunk/libs/optional/doc/implementation_notes.qbk
 /trunk/libs/optional/doc/optional.qbk
 /trunk/libs/optional/doc/reference.qbk
 /trunk/libs/optional/doc/special_cases.qbk

=======================================
--- /trunk/libs/optional/doc/acknowledgments.qbk        Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/acknowledgments.qbk        Wed Mar 24 00:54:49 2010
@@ -9,7 +9,7 @@
 ]


-[section Acknowledgments]
+[section:acknowledgments Acknowledgments 鸣谢]

 [heading Pre-formal review]

=======================================
--- /trunk/libs/optional/doc/dependencies.qbk   Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/dependencies.qbk   Wed Mar 24 00:54:49 2010
@@ -9,9 +9,10 @@
 ]


-[section Dependencies and Portability]

+[section:dependencies_and_portability Dependencies and Portability 依赖性和可移植性]


 The implementation uses `type_traits/alignment_of.hpp` and
-`type_traits/type_with_alignment.hpp`
+`type_traits/type_with_alignment.hpp`\n

+该实现使用了 `type_traits/alignment_of.hpp` 和`type_traits/type_with_alignment.hpp`


 [endsect]
=======================================
--- /trunk/libs/optional/doc/development.qbk    Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/development.qbk    Wed Mar 24 00:54:49 2010
@@ -8,9 +8,9 @@
     http://www.boost.org/LICENSE_1_0.txt)
 ]

-[section Development]
-
-[section The models]
+[section:development Development 发展]
+
+[section:the_models The models 模型]

In C++, we can ['declare] an object (a variable) of type `T`, and we cangive this

 variable an ['initial value] (through an ['initializer]. (c.f. 8.5)).
@@ -29,7 +29,16 @@

is formally ['undefined behavior] to try to access the value of anuninitializedoptional. An uninitialized optional can be assigned a value, in which caseits initialization state changes to initialized. Furthermore, given theformaltreatment of initialization states in optional objects, it is evenpossible to

-reset an optional to ['uninitialized].
+reset an optional to ['uninitialized].\n

+在C++中，我们可以['声明]类型 `T` 的一个对象(变量)，并且我们可以给这个对象一个['初始值](通过['初始化](参考 8.5))。

+当一个声明中包含非空的初始化(即给出一个初始值)，就称这个对象已被初始化。

+如果一个声明使用了空的初始化(即未给出初始值)，而且也没缺省值可用于初始化，则称该对象是[*未初始化的]。

+它的真实值是存在的，但具有一个['不确定的初始值](参考 8.5.9)。

+`optional<T>` 的目的是规范初始化(或无初始化)的概念，让程序可以检测一个对象是否已初始化，+并规定访问一个未初始化对象的值是未定义的行为。即，如果一个变量被声明为`optional<T>` 而未给定初始值，则该变量就是['正式的]未初始化。+一个正式的未初始化的 optional 对象是没有值的，并且可以在运行期对此状态进行测试。+尝试访问一个未初始化的 optional 被正式规定为['未定义行为]。一个未初始化的optional 可以被赋予一个值，这时它的初始化状态就会变为已初始化。+此外，还给出处理 optional 对象的初始化状态的方法，甚至可以将一个 optional重新置为['未初始化]。


 In C++ there is no formal notion of uninitialized objects, which means that
 objects always have an initial value even if indeterminate.
@@ -45,59 +54,90 @@

Using the __BOOST_VARIANT__ library, this model can be implemented interms of `boost::variant<T,nil_t>`.There is precedent for a discriminated union as a model for an optionalvalue:the __HASKELL__ [*Maybe] built-in type constructor. Thus, a discriminatedunion

-`T+nil_t` serves as a conceptual foundation.
+`T+nil_t` serves as a conceptual foundation.\n

+在C++里没有未初始化对象的正式概念，即是说对象总是带有初始值的，即使是不确定的值。+正如前面所讨论的，这样有一个缺点，因为你需要用额外的信息来告知一个对象是不是已经被有效地初始化了。+一种以前常用的典型方法是使用特殊值：`EOF`, `npos`, -1, 等等... 这相当于增加一个特殊值到给定类型的可取值的集合中。+由 `T` 加上某个 ['nil_t] -- `nil_t` 是某个无状态的POD -- 组成的超集在现代语言中可以被模仿为由 T 和 nil_t 组成的一个[*可识别联合]。+可识别联合通常称为 ['variants]. 一个 variant 具有 ['当前类型]，在我们的例子中就是 `T` 或者 `nil_t`.+使用 __BOOST_VARIANT__ 库，以上模型可以用 `boost::variant<T,nil_t>` 来实现。+用可识别联合来模仿一个 optional 值是有先例的：__HASKELL__ 的 [*Maybe] 内建类型构造器。

+所以，可识别联合 `T+nil_t` 可以作为一个概念上的基础。

A `variant<T,nil_t>` follows naturally from the traditional idiom ofextending

 the range of possible values adding an additional sentinel value with the

special meaning of ['Nothing]. However, this additional ['Nothing] valueis largely

 irrelevant for our purpose since our goal is to formalize the notion of

uninitialized objects and, while a special extended value can be used toconvey

-that meaning, it is not strictly necessary in order to do so.
+that meaning, it is not strictly necessary in order to do so.\n

+`variant<T,nil_t>` 自然而然地可用于扩展可取值的传统惯用法，它增加一个"哨兵"值用于表示['空值]。+不过，这个新增的['空值]与我们意图大不相关，因为我们的目标是规范化未初始化对象的概念，

+虽然一个特殊的扩展值可以用于表达这个意思，但是它并不是严格必要的。

The observation made in the last paragraph about the irrelevant nature ofthe

 additional `nil_t` with respect to [_purpose] of `optional<T>` suggests an

-alternative model: a ['container] that either has a value of `T` ornothing.+alternative model: a ['container] that either has a value of `T` ornothing.\n+最近的研究表明，额外的 `nil_t` 对于 `optional<T>` 的 [_目的] 是无关的，我们建议另一种模型：一个['容器]，它具有 `T` 的值，或者为空。


 As of this writing I don't know of any precedence for a variable-size

fixed-capacity (of 1) stack-based container model for optional values, yetI

 believe this is the consequence of the lack of practical implementations of

-such a container rather than an inherent shortcoming of the containermodel.+such a container rather than an inherent shortcoming of the containermodel.\n+在写这篇文档之时，我还不知道有任何一个大小可变、容量固定(为1)、基于栈的optional 值的容器模型的先例，+但是我相信这只是因为还没有这样一个容器的实际实现，而不是这样一个容器模型的固有缺点。


 In any event, both the discriminated-union or the single-element container
 models serve as a conceptual ground for a class representing optional--i.e.
 possibly uninitialized--objects.

For instance, these models show the ['exact] semantics required for awrapper

-of optional values:
-
-Discriminated-union:
-

-* [*deep-copy] semantics: copies of the variant implies copies of thevalue.

+of optional values:\n

+无论如何，可识别联合或单元素容器模型均可作为表示 optional 类 -- 即可能未初始化的 -- 对象的基础。

+例如，这些模型表现出了一个 optional 值包装器所需的['准确]语义：
+
+Discriminated-union:\n
+可识别联合：
+

+* [*deep-copy] semantics: copies of the variant implies copies of thevalue.\n

+  [*深复制] 语义：variant 的拷贝即为值的拷贝。
 * [*deep-relational] semantics: comparisons between variants matches both
-current types and values

-* If the variant's current type is `T`, it is modeling an ['initialized]optional.

+current types and values\n
+  [*深比较] 语义：比较两个 variants 要同时匹配类型和值。

+* If the variant's current type is `T`, it is modeling an ['initialized]optional.\n

+  如果 variant 的当前类型为 `T`, 它就代表['已初始化的] optional.

* If the variant's current type is not `T`, it is modeling an['uninitialized]

-optional.
+optional.\n
+  如果 variant 的当前类型不是 `T`, 它就代表['未初始化的] optional.

* Testing if the variant's current type is `T` models testing if theoptional

-is initialized
+is initialized\n
+  测试 variant 的当前类型是否为 `T` 即测试 optional 是否已初始化。

* Trying to extract a `T` from a variant when its current type is not `T`,models-the undefined behavior of trying to access the value of an uninitializedoptional

-
-Single-element container:
-

-* [*deep-copy] semantics: copies of the container implies copies of thevalue.+the undefined behavior of trying to access the value of an uninitializedoptional\n+ 试图从一个 variant 取出 `T` 而它的当前类型不是 `T` 时，正好符合了访问一个未初始化 optional 值的未定义行为。

+
+Single-element container:\n
+单元素容器：
+

+* [*deep-copy] semantics: copies of the container implies copies of thevalue.\n

+  [*深复制] 语义：container 的拷贝即为值的拷贝。

* [*deep-relational] semantics: comparisons between containers comparecontainer

-size and if match, contained value
+size and if match, contained value\n

+ [*深比较] 语义：比较两个 containers 要先比较容器的大小，如果匹配再比较容器中的值。* If the container is not empty (contains an object of type `T`), it ismodeling

-an ['initialized] optional.
-* If the container is empty, it is modeling an ['uninitialized] optional.
+an ['initialized] optional.\n

+ 如果 container 非空(包含一个类型为 `T` 的对象)，它就代表['已初始化的]optional.

+* If the container is empty, it is modeling an ['uninitialized] optional.\n
+  如果 container 为空，它就代表['未初始化的] optional.
 * Testing if the container is empty models testing if the optional is
-initialized
+initialized\n
+  测试 container 是否为空即测试 optional 是否已初始化。

* Trying to extract a `T` from an empty container models the undefinedbehavior

-of trying to access the value of an uninitialized optional
+of trying to access the value of an uninitialized optional\n

+ 试图从一个空的 container 取出 `T`，正好符合了访问一个未初始化 optional 值的未定义行为。

+

 [endsect]

-[section The semantics]
+[section:the_semantics The semantics 语义]

Objects of type `optional<T>` are intended to be used in places whereobjects oftype `T` would but which might be uninitialized. Hence, `optional<T>`'spurpose is

@@ -110,40 +150,60 @@
 different mechanism.

Doing it the other way around, that is, making `optional<T>` a ['subtype]of `T`

 is not only conceptually wrong but also impractical: it is not allowed to
-derive from a non-class type, such as a built-in type.
-
-We can draw from the purpose of `optional<T>` the required basic semantics:
+derive from a non-class type, such as a built-in type.\n

+类型 `optional<T>` 的对象的设计意图是，用在那些使用可能未被初始化的类型`T` 的对象的地方。

+因此，`optional<T>` 的意图是对增加可能的未初始化状态进行规范化。

+从这一任务的观点出发，`optional<T>` 可以具有与 `T` 相同的操作语义，再加上与特殊状态相对应的额外语义。+同样，`optional<T>` 可被视为 `T` 的一个 ['超类型]. 当然，我们不能在C++中这样做，所以我们需要用一种不同的机制来得到想要的语义。+使用其它方法实现它，如让 `optional<T>` 作为 `T` 的 ['子类]，不仅是概念上的错误，而且也是不实际的：

+因为不允许从非类类型派生，如从内建类型派生。
+

+We can draw from the purpose of `optional<T>` the required basicsemantics:\n

+我们可以从 `optional<T>` 的目的描画出所需的基本语义：

 * [*Default Construction:] To introduce a formally uninitialized wrapped
-object.
+object.\n
+  [*缺省构造：]引入一个正式的未初始化包装对象。

* [*Direct Value Construction via copy:] To introduce a formallyinitialized

-wrapped object whose value is obtained as a copy of some object.
-* [*Deep Copy Construction:] To obtain a new yet equivalent wrapped object.
+wrapped object whose value is obtained as a copy of some object.\n

+ [*通过复制进行直接的值构造：]引入一个正式的已初始化包装对象，其值来自于某个对象的拷贝。+* [*Deep Copy Construction:] To obtain a new yet equivalent wrappedobject.\n

+  [*深复制构造：]获得一个新的、等价的包装对象。
 * [*Direct Value Assignment (upon initialized):] To assign a value to the
-wrapped object.
+wrapped object.\n
+  [*直接的值赋值(到已初始化的对象)：]将一个值赋值到包装对象。

* [*Direct Value Assignment (upon uninitialized):] To initialize thewrapped

-object with a value obtained as a copy of some object.
+object with a value obtained as a copy of some object.\n

+ [*直接的值赋值(到未初始化的对象)：]从某个对象的拷贝取得值，初始化包装对象。* [*Assignment (upon initialized):] To assign to the wrapped object thevalue

-of another wrapped object.
+of another wrapped object.\n
+  [*赋值(到已初始化的对象)：]将另一个包装对象的值赋值到包装对象。
 * [*Assignment (upon uninitialized):] To initialize the wrapped object with
-value of another wrapped object.
+value of another wrapped object.\n
+  [*赋值(到未初始化的对象)：]以另一个包装对象的值初始化包装对象。
 * [*Deep Relational Operations (when supported by the type T):] To compare

-wrapped object values taking into account the presence of uninitializedstates.

-* [*Value access:] To unwrap the wrapped object.

+wrapped object values taking into account the presence of uninitializedstates.\n+ [*深比较操作(仅当被类型T支持时)：]比较两个包装对象的值，包括未初始化状态的情形。

+* [*Value access:] To unwrap the wrapped object.\n
+  [*值访问：]对包装对象去包装。
 * [*Initialization state query:] To determine if the object is formally
-initialized or not.
+initialized or not.\n
+  [*初始化状态查询：]判断该对象是否已正式初始化。
 * [*Swap:] To exchange wrapped objects. (with whatever exception safety
-guarantees are provided by `T`'s swap).
+guarantees are provided by `T`'s swap).\n
+  [*交换：]交换包装的对象。(无论 `T` 的交换操作提供何种异常安全性保证)。

* [*De-initialization:] To release the wrapped object (if any) and leavethe

-wrapper in the uninitialized state.
+wrapper in the uninitialized state.\n
+  [*去初始化：]释放包装的对象(如果有)，并使包装器保留未初始化状态。

 Additional operations are useful, such as converting constructors and
 converting assignments, in-place construction and assignment, and safe
-value access via a pointer to the wrapped object or null.
+value access via a pointer to the wrapped object or null.\n

+其它操作也是有用的，如转换构造函数和转换赋值，就地构造和赋值，以及通过包装对象的一个指针或空指针进行安全的值访问。


 [endsect]

-[section The Interface]
+[section:the_interface The Interface 接口]

 Since the purpose of optional is to allow us to use objects with a formal
 uninitialized additional state, the interface could try to follow the
@@ -152,31 +212,42 @@

be noted: Even if all the operations supported by an instance of type `T`are

 defined for the entire range of values for such a type, an `optional<T>`
 extends such a set of values with a new value for which most
-(otherwise valid) operations are not defined in terms of `T`.
+(otherwise valid) operations are not defined in terms of `T`.\n

+由于 optional 的目的是允许我们使用增加了正式的未初始化状态的对象，所以它的接口应该尽可能跟随底层的类型 `T`.+为了选择适当的原本的 `T` 接口，应该留意以下几点：即使被类型 `T` 的实例所支持的所有操作是为该类的整个值域所定义的，+但是 `optional<T>` 将该值域扩充了一个新值，所以很多(对其它值有效的)操作对该值没有定义。

Furthermore, since `optional<T>` itself is merely a `T` wrapper (modelinga `T`supertype), any attempt to define such operations upon uninitializedoptionals

-will be totally artificial w.r.t. `T`.
+will be totally artificial w.r.t. `T`.\n

+此外，由于 `optional<T>` 本身只不过是一个 `T` 的包装(类似于 `T` 的一个超类)，任何针对未初始化的 optional 的操作定义都应完全与 `T` 相关。

This library chooses an interface which follows from `T`'s interface onlyforthose operations which are well defined (w.r.t the type `T`) even if anyof the

 operands are uninitialized. These operations include: construction,
-copy-construction, assignment, swap and relational operations.
+copy-construction, assignment, swap and relational operations.\n

+本库所选择的接口是，沿用 `T` 的接口，只要那些操作是有良好定义的(与类型 `T`有关)，即使某些操作数未初始化。

+这样的操作包括有：构造，复制构造，赋值，交换和比较操作。

For the value access operations, which are undefined (w.r.t the type `T`)whenthe operand is uninitialized, a different interface is chosen (which willbe

-explained next).
+explained next).\n

+对于值访问操作，如果操作数是未初始化的，则是未定义的(与类型 `T` 有关)，所以选用了不同的接口(稍后将会解释)。


 Also, the presence of the possibly uninitialized state requires additional

-operations not provided by `T` itself which are supported by a specialinterface.+operations not provided by `T` itself which are supported by a specialinterface.\n+还有，未初始化状态的可能出现需要有更多的操作，这些操作是 `T` 本身所不具备的，它们将以特定的接口提供。


 [heading Lexically-hinted Value Access in the presence of possibly
-untitialized optional objects: The operators * and ->]
+untitialized optional objects: The operators * and ->\n
+对可能未初始化的 optional 对象的带提示的值访问：操作符 * 和 ->]

A relevant feature of a pointer is that it can have a [*null pointervalue].This is a ['special] value which is used to indicate that the pointer isnot

 referring to any object at all. In other words, null pointer values convey
-the notion of inexistent objects.
+the notion of inexistent objects.\n

+指针的一个特点是它可以具有 [*空指针值]。这是一个['特殊]值，用于表示该指针没有指向任何对象。

+换句话说，空指针值表达的意思是不存在的对象。

 This meaning of the null pointer value allowed pointers to became a ['de
 facto] standard for handling optional objects because all you have to do
@@ -184,7 +255,10 @@
 value of the appropriate type. Pointers have been used for decades--from

the days of C APIs to modern C++ libraries--to ['refer] to optional (thatis,

 possibly inexistent) objects; particularly as optional arguments to a
-function, but also quite often as optional data members.
+function, but also quite often as optional data members.\n

+空指针值的这个意义使得指针成为了处理 optional 对象的['事实]标准，因为当你要引向一个实际上不存在的值时，+你要做的只是使用适当类型的空指针值。指针已经被使用了几十年 -- 从 C APIs 一直到现代的 C++ 库 -- 用来['表示] optional

+(即可能不存在的)对象；尤其是用作函数的可选参数，但也常被用作可选数据成员。

 The possible presence of a null pointer value makes the operations that
 access the pointee's value possibly undefined, therefore, expressions which
@@ -192,12 +266,17 @@

implicitly convey the notion of optionality, and this information is tiedtothe ['syntax] of the expressions. That is, the presence of operators `*`and `->`tell by themselves --without any additional context-- that the expressionwill

-be undefined unless the implied pointee actually exist.
+be undefined unless the implied pointee actually exist.\n

+空指针值的可能出现使得访问被指物值的操作可能是无定义的，所以，使用提领和访问操作符的表达式，+如 `( *p = 2 )` 和 `( p->foo() )`, 暗含了可选性的概念，此类信息被表达式的['语法]所依赖。+即，操作符 `*` 和 `->` 本身 -- 无需任何额外的上下文 -- 就说明了该表达式可以是无定义的，除非被指物确实存在。

Such a ['de facto] idiom for referring to optional objects can beformalized

 in the form of a concept: the __OPTIONAL_POINTEE__ concept.
 This concept captures the syntactic usage of operators `*`, `->` and
-conversion to `bool` to convey the notion of optionality.
+conversion to `bool` to convey the notion of optionality.\n

+这个表示 optional 对象的['事实上]的惯用法可以用一个概念来规范化：__OPTIONAL_POINTEE__ 概念。

+该概念包含了操作符 `*`, `->` 以及转换到 `bool` 的语法，以表达可选性的概念。

However, pointers are good to [_refer] to optional objects, but notparticularlygood to handle the optional objects in all other respects, such asinitializing

@@ -206,7 +285,10 @@

are not enough. The problem is that copies of pointers do not imply copiesof

 pointees. For example, as was discussed in the motivation, pointers alone

cannot be used to return optional objects from a function because theobject

-must move outside from the function and into the caller's context.
+must move outside from the function and into the caller's context.\n

+虽然指针适合于[_表示] optional 对象，但是并不特别适合处理 optional 对象的其它方面，如初始化或移动/复制。+问题主要在于指针语义的浅复制：如果你需要高效地移动或复制对象，那么仅有指针是不够的。问题是指针的拷贝并不代表被指物的拷贝。+例如，象在"动机"一节中所讨论的，仅用指针并不能从一个函数返回 optional 对象，因为该对象必须从函数中移至外部，进入调用者的上下文。


 A solution to the shallow-copy problem that is often used is to resort to

dynamic allocation and use a smart pointer to automatically handle thedetails

@@ -219,18 +301,26 @@
 not have this semantics, so are inappropriate for the initialization and

transport of optional values, yet are quite convenient for handling theaccess

 to the possible undefined value because of the idiomatic aid present in the
-__OPTIONAL_POINTEE__ concept incarnated by pointers.
+__OPTIONAL_POINTEE__ concept incarnated by pointers.\n

+解决浅复制问题的一个常用方法是，采用动态分配并使用智能指针来自动处理其细节。+例如，如果一个函数可选性地返回一个对象 `X`, 则可以使用 `shared_ptr<X>` 作为返回值。+不过，这要求对 `X` 进行动态分配。如果 `X` 是内建的或是小的 POD, 该技术在资源方面很不划算。+Optional 对象本质上是值对象，所以，如果可以象我们处理普通的值对象那样，使用自动存储和深复制语义来维护 optional 值，才是最方便的。+指针不具有这种语义，所以不适于初始化和转移 optional 值，但还是非常适合于访问有可能无定义的值，

+因为该用法已存在于以指针为代表的 __OPTIONAL_POINTEE__ 概念中。


-[heading Optional<T> as a model of OptionalPointee]

+[heading Optional<T> as a model of OptionalPointee Optional<T>作为OptionalPointee的模型]


 For value access operations `optional<>` uses operators `*` and `->` to
 lexically warn about the possibly uninitialized state appealing to the
-familiar pointer semantics w.r.t. to null pointers.
+familiar pointer semantics w.r.t. to null pointers.\n

+对于值访问操作，`optional<>` 使用操作符 `*` 和 `->` 来提醒有可能出现的未初始化状态，这类似于指针语义中的空指针用法。


 [warning
 However, it is particularly important to note that `optional<>` objects
-are not pointers. [_`optional<>` is not, and does not model, a pointer].
+are not pointers. [_`optional<>` is not, and does not model, a pointer].\n

+但是，要重点留意的是，`optional<>` 对象不是指针。[_`optional<>` 不是也不符合指针的概念]。

 ]

 For instance, `optional<>` does not have shallow-copy so does not alias:
@@ -244,7 +334,13 @@
 As a result, you might be able to replace `optional<T>` by `T*` on some
 situations but not always. Specifically, on generic code written for both,
 you cannot use relational operators directly, and must use the template

-functions __FUNCTION_EQUAL_POINTEES__ and __FUNCTION_LESS_POINTEES__instead.+functions __FUNCTION_EQUAL_POINTEES__ and __FUNCTION_LESS_POINTEES__instead.\n+例如，`optional<>` 没有浅复制，所以也没有别名：两个不同的 optional 永远不会引向['同一个]值，+除非 `T` 本身是一个引用(但可以有['相等的]值)。必须注意 `optional<T>` 和指针间的区别，特别是因为它们的比较操作符的语义是不同的：+因为 `optional<T>` 是一个值包装器，比较操作符是"深"的：它们比较 optional 的值；而指针的比较操作符则是"浅"的：+它们不比较被指物的值。所以，你也许可以在某些情形下用 `T*` 替换`optional<T>`，但并不是总可以这样做。+特别是，在为两者所写的泛型代码中，你不能直接使用比较操作符，而必须使用模板函数 __FUNCTION_EQUAL_POINTEES__ 和

+__FUNCTION_LESS_POINTEES__ 来代替。

 [endsect]

=======================================
--- /trunk/libs/optional/doc/examples.qbk       Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/examples.qbk       Wed Mar 24 00:54:49 2010
@@ -9,28 +9,29 @@
 ]


-[section Examples]
-
-[section Optional return values]
+[section:examples Examples 例子]
+
+[section:optional_return_values Optional return values  Optional返回值]

     optional<char> get_async_input()
     {
         if ( !queue.empty() )
             return optional<char>(queue.top());
-        else return optional<char>(); // uninitialized
+        else return optional<char>(); // uninitialized 未初始化
     }

     void receive_async_message()
     {
         optional<char> rcv ;
-        // The safe boolean conversion from 'rcv' is used here.
+        // The safe boolean conversion from 'rcv' is used here.
+        // 此处使用了从 'rcv' 到布尔值的安全转换。
         while ( (rcv = get_async_input()) && !timeout() )
             output(*rcv);
     }

 [endsect]

-[section Optional local variables]

+[section:optional_local_variables Optional local variables Optional局部变量]


     optional<string> name ;
     if ( database.open() )
@@ -49,7 +50,7 @@

 [endsect]

-[section Optional data members]
+[section:optional_data_members Optional data members  Optional数据成员]

     class figure
     {
@@ -58,12 +59,13 @@
         figure()
         {

// data member 'm_clipping_rect' is uninitialized at thispoint.

+            // 此处数据成员 'm_clipping_rect' 未初始化。
         }

         void clip_in_rect ( rect const& rect )
         {
             ....
-            m_clipping_rect.reset ( rect ) ; // initialized here.

+ m_clipping_rect.reset ( rect ) ; // initialized here. 此处初始化。

         }

         void draw ( canvas& cvs )
@@ -74,7 +76,7 @@
             cvs.drawXXX(..);
         }

-        // this can return NULL.
+        // this can return NULL.  可以返回 NULL.

rect const* get_clipping_rect() { returnget_pointer(m_clipping_rect); }


         private :
@@ -85,7 +87,8 @@

 [endsect]

-[section Bypassing expensive unnecessary default construction]

+[section:bypassing_expensive_unnecessary_default_construction Bypassingexpensive unnecessary default construction

+避免不必要的昂贵的缺省构造]

     class ExpensiveCtor { ... } ;
     class Fred
=======================================

---/trunk/libs/optional/doc/html/boost_optional/a_note_about_optional_bool_.htmlTue Nov 25 06:14:27 2008+++/trunk/libs/optional/doc/html/boost_optional/a_note_about_optional_bool_.htmlWed Mar 24 00:54:49 2010

@@ -1,109 +1,98 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-

- <title>A note about optional<bool></title><link rel="stylesheet"href="../boostbook.css" type="text/css">

-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="in_place_factories.html" title="In-PlaceFactories">

- <link rel="next" href="exception_safety_guarantees.html"title="Exception Safety Guarantees"></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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../more/index.htm">More</a></td>

-
-    </tr>
-  </tbody>
-</table>
-
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">

+<title>A note about optional<bool>关于optional<bool>的说明</title>

+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="in_place_factories.html" title="In-Place Factories就地创建">+<link rel="next" href="exception_safety_guarantees.html" title="ExceptionSafety Guarantees 异常安全性保证">

+</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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="in_place_factories.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="exception_safety_guarantees.html"><imgsrc="../../../../../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_optional.a_note_about_optional_bool_"></a><a class="link"href="a_note_about_optional_bool_.html" title="A note aboutoptional<bool>">关于

-    optional&lt;bool&gt; 的说明</a>
-</h2>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.a_note_about_optional_bool_"></a><a class="link"href="a_note_about_optional_bool_.html" title="A note aboutoptional<bool>关于optional<bool>的说明"> A note about+ optional<bool>关于optional<bool>的说明</a>

+</h2></div></div></div>
 <p>

- <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code> 在使用时需要特别小心和留意。

-首先，它的功能类似于三态布尔类型(false,maybe,true) -- 如 <ahref="../../../../../doc/html/tribool.html">boost::tribool</a> ---只有一点区别，即在三态布尔类型中，maybe 状态<spanstyle="text-decoration: underline;">代表了一个有效的值，而不是未初始化的 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code>-的相应状态。如果真的要用 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code> 替代 <code class="computeroutput"><spanclass="identifier">tribool</code>，你要非常小心谨慎。

-其次，<code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>- 提供了到 <code class="computeroutput"><spanclass="keyword">bool</code> 的隐式转换。该转换表示了所含值是否为已初始化状态。使用 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code> 可能会由于这个到 <code class="computeroutput"><spanclass="keyword">bool</code>

- 的隐式转换而导致微妙的错误：<br>
-</p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code> should+ be used with special caution and consideration. <codeclass="computeroutput">optional<spanclass="special"><bool<spanclass="special">></code>+在使用时需要特别小心和留意。

+    </p>
+<p>

+ First, it is functionally similar to a tristate boolean(false,maybe,true)+ —such as <a href="../../../../../doc/html/tribool.html"target="_top">boost::tribool</a>—+ except that in a tristate boolean, the maybe state <spanclass="underline">represents+ a valid value, unlike the corresponding state of anuninitialized+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code>. It+ should be carefully considered if an <codeclass="computeroutput">optional<spanclass="special"><bool<spanclass="special">></code>+ instead of a <code class="computeroutput"><spanclass="identifier">tribool</code> is really+ needed. 首先，它的功能类似于三态布尔类型(false,maybe,true)+ — 如 <a href="../../../../../doc/html/tribool.html"target="_top">boost::tribool</a>+ — 只有一点区别，即在三态布尔类型中，maybe状态<spanclass="underline">代表了一个有效的值，而不是未初始化的+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code>的相应状态。+ 如果真的要用 <codeclass="computeroutput">optional<spanclass="special"><bool<spanclass="special">></code>+ 替代 <code class="computeroutput"><spanclass="identifier">tribool</code>，你要非常小心谨慎。

+    </p>
+<p>

+ Second, <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>+ provides an implicit conversion to <codeclass="computeroutput">bool</code>.+ This conversion refers to the initialization state and not to thecontained+ value. Using <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code> can+ lead to subtle errors due to the implicit <codeclass="computeroutput">bool</code>+ conversion: 其次，<codeclass="computeroutput">optional<spanclass="special"><></code> 提供了到<code class="computeroutput">bool</code>+的隐式转换。该转换表示了所含值是否为已初始化状态。+ 使用 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="keyword">bool></code>可能会由于这个到+ <code class="computeroutput"><spanclass="keyword">bool</code>的隐式转换而导致微妙的错误：

+    </p>

<pre class="programlisting">void <spanclass="identifier">foo ( <spanclass="keyword">bool v <spanclass="special">) ;void bar<spanclass="special">()

 <span class="special">{</span>

optional<spanclass="special"><bool<spanclass="special">> v <spanclass="special">= try<spanclass="special">();

- // 下面将 'v' 的值传递给 foo(): foo(<spanclass="identifier">v);- // 但是实际上，被传递的是初始化状态 // 正确的写法应该是：foo(*v). }+ // The following intended to pass the valueof 'v' to foo():+ // 下面将 'v'的值传递给 foo():+ foo<spanclass="special">(v<spanclass="special">);+ // But instead, the initialization state ispassed+ // due to a typo: it should have beenfoo(*v).+ //但是实际上，被传递的是初始化状态。正确的写法应该是：foo(*v).

+</span><span class="special">}</span>
 </pre>
-

-隐式转换只是转为 <code class="computeroutput"><spanclass="keyword">bool</code>, 不会对其进行整型类型的提升，所以它还是安全的(例如，如果 <codeclass="computeroutput">foo<spanclass="special">()</code> 接受的是一个 <codeclass="computeroutput">int</code>, 它将不能编译)。

+<p>

+ The only implicit conversion is to <codeclass="computeroutput">bool</code>,+ and it is safe in the sense that typical integral promotions don'tapply (i.e.+ if <code class="computeroutput"><spanclass="identifier">foo()</code>+ takes an <code class="computeroutput"><spanclass="keyword">int</code> instead, it won't+ compile). 隐式转换只是转为 <codeclass="computeroutput">bool</code>,+不会对其进行整型类型的提升，所以它还是安全的(例如，如果+ <code class="computeroutput"><spanclass="identifier">foo()</code>+ 接受的是一个 <codeclass="computeroutput">int</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">

-      <p>

+<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 © 2003-2007 Fernando Luis Cacciola CarballalDistributed under the Boost Software License, Version 1.0. (Seeaccompanyingfile LICENSE_1_0.txt or copy at <ahref="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">

 </div>
-
-</body></html>
+</body>
+</html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/acknowledgments.html ThuSep 4 19:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/acknowledgments.html WedMar 24 00:54:49 2010

@@ -1,197 +1,125 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Acknowledgments</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="dependencies_and_portability.html"title="Dependencies and Portability">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Acknowledgments &#40483;&#35874;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="dependencies_and_portability.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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_optional.acknowledgments"></a><a class="link"href="acknowledgments.html" title="Acknowledgments">鸣谢</a>

-</h2>
-</div>
-</div>
-</div>
-
-<a name="boost_optional.acknowledgments.pre_formal_review"></a>
-<h4>
-<a name="id2665170"></a>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.acknowledgments"></a><a class="link"href="acknowledgments.html" title="Acknowledgments 鸣谢">Acknowledgments 鸣谢</a>

+</h2></div></div></div>
+<a name="boost_optional.acknowledgments.pre_formal_review"></a><h4>
+<a name="id4895857"></a>

<a class="link"href="acknowledgments.html#boost_optional.acknowledgments.pre_formal_review">Pre-formal

       review</a>
     </h4>
-
-<div class="itemizedlist">
-<ul type="disc">
-
-  <li>
+<div class="itemizedlist"><ul type="disc">
+<li>

Peter Dimov suggested the name 'optional', and was the first topoint out

         the need for aligned storage.
       </li>
-
-  <li>
+<li>

Douglas Gregor developed 'type_with_alignment', and later EricFriedman coded'aligned_storage', which are the core of the optional classimplementation.

       </li>
-
-  <li>
+<li>

Andrei Alexandrescu and Brian Parker also worked with alignedstorage techniques

         and their work influenced the current implementation.
       </li>
-
-  <li>
+<li>

Gennadiy Rozental made extensive and important comments whichshaped the

         design.
       </li>
-
-  <li>
+<li>

Vesa Karvonen and Douglas Gregor made quite useful comparisonsbetween optional,

         variant and any; and made other relevant comments.
       </li>
-
-  <li>
+<li>

Douglas Gregor and Peter Dimov commented on comparisons andevaluation in

         boolean contexts.
       </li>
-
-  <li>
+<li>

Eric Friedman helped understand the issues involved with alignedstorage,

         move/copy operations and exception safety.
       </li>
-
-  <li>
+<li>

Many others have participated with useful comments: AlekseyGurotov, Kevlin

         Henney, David Abrahams, and others I can't recall.
       </li>
-
-</ul>
-</div>
-
-<a name="boost_optional.acknowledgments.post_formal_review"></a>
-<h4>
-<a name="id2665241"></a>
+</ul></div>
+<a name="boost_optional.acknowledgments.post_formal_review"></a><h4>
+<a name="id4895927"></a>

<a class="link"href="acknowledgments.html#boost_optional.acknowledgments.post_formal_review">Post-formal

       review</a>
     </h4>
-
-<div class="itemizedlist">
-<ul type="disc">
-
-  <li>
+<div class="itemizedlist"><ul type="disc">
+<li>

William Kempf carefully considered the originally proposedinterface andsuggested the new interface which is currently used. He alsostarted andfueled the discussion about the analogy optional<>/smartpointer and

         about relational operators.
       </li>
-
-  <li>
+<li>

Peter Dimov, Joel de Guzman, David Abrahams, Tanton Gibbs and IanHansonfocused on the relational semantics of optional (originallyundefined); concludingwith the fact that the pointer-like interface doesn't make it apointer so

         it shall have deep relational operators.
       </li>
-
-  <li>
+<li>

Augustus Saunders also explored the different relational semanticsbetweenoptional<> and a pointer and developed the OptionalPointeeconcept

         as an aid against potential conflicts on generic code.
       </li>
-
-  <li>
+<li>

Joel de Guzman noticed that optional<> can be seen as an APIon top

         of variant&lt;T,nil_t&gt;.
       </li>
-
-  <li>
+<li>

Dave Gomboc explained the meaning and usage of the Haskell analogto optional<>:the Maybe type constructor (analogy originally pointed out byDavid Sankel).

       </li>
-
-  <li>
+<li>

Other comments were posted by Vincent Finn, Anthony Williams, EdBrey, Rob

         Stewart, and others.
       </li>
-
-  <li>
+<li>

Joel de Guzman made the case for the support of references andhelped with

         the proper semantics.
       </li>
-
-  <li>
+<li>

Mat Marcus shown the virtues of a value-oriented interface,influencing the

         current design, and contributed the idea of "none".
       </li>
-
-</ul>
+</ul></div>
 </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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

---/trunk/libs/optional/doc/html/boost_optional/dependencies_and_portability.htmlThu Sep 4 19:32:19 2008+++/trunk/libs/optional/doc/html/boost_optional/dependencies_and_portability.htmlWed Mar 24 00:54:49 2010

@@ -1,92 +1,48 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Dependencies and Portability</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="implementation_notes.html" title="ImplementationNotes">

-
-  <link rel="next" href="acknowledgments.html" title="Acknowledgments">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">

+<title>Dependencies and Portability依赖性和可移植性</title>

+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="implementation_notes.html" title="ImplementationNotes 实现说明">+<link rel="next" href="acknowledgments.html" title="Acknowledgments鸣谢">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="implementation_notes.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="acknowledgments.html"><imgsrc="../../../../../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_optional.dependencies_and_portability"></a><a class="link"href="dependencies_and_portability.html" title="Dependencies andPortability">依赖性和可移植性</a>

-</h2>
-</div>
-</div>
-</div>
-

-该实现使用了 <code class="computeroutput"><spanclass="identifier">type_traits/<spanclass="identifier">alignment_of.<spanclass="identifier">hpp</code> 和- <code class="computeroutput"><spanclass="identifier">type_traits/<spanclass="identifier">type_with_alignment<spanclass="special">.hpp</code>

+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.dependencies_and_portability"></a><a class="link"href="dependencies_and_portability.html" title="Dependencies andPortability依赖性和可移植性">Dependencies+ and Portability依赖性和可移植性</a>

+</h2></div></div></div>
+<p>

+ The implementation uses <code class="computeroutput"><spanclass="identifier">type_traits/<spanclass="identifier">alignment_of.<spanclass="identifier">hpp</code> and+ <code class="computeroutput"><spanclass="identifier">type_traits/<spanclass="identifier">type_with_alignment<spanclass="special">.hpp</code> 该实现使用了 <codeclass="computeroutput">type_traits<spanclass="special">/alignment_of<spanclass="special">.hpp</code> 和<code class="computeroutput"><spanclass="identifier">type_traits/<spanclass="identifier">type_with_alignment<spanclass="special">.hpp</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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/detailed_semantics.htmlTue Nov 25 06:14:27 2008+++ /trunk/libs/optional/doc/html/boost_optional/detailed_semantics.htmlWed Mar 24 00:54:49 2010

@@ -1,2780 +1,1869 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>Detailed Semantics</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

-
-
-

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

-
-
-
-  <link rel="prev" href="synopsis.html" title="Synopsis">
-
-
-
-  <link rel="next" href="examples.html" title="Examples">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Detailed Semantics &#35814;&#32454;&#35821;&#20041;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

+<link rel="prev" href="synopsis.html" title="Synopsis &#25688;&#35201;">
+<link rel="next" href="examples.html" title="Examples &#20363;&#23376;">
 </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>

-
-
-      <td align="center"><a href="../../../../../index.html">Home</a></td>
-
-

- <td align="center"><ahref="../../../../libraries.htm">Libraries</a></td>

-
-

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

-
-

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

-
-

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="synopsis.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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"><imgsrc="../../../../../doc/html/images/next.png" alt="Next"></a>

+<div class="spirit-nav">

+<a accesskey="p" href="synopsis.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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"><imgsrc="../../../../../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;"><aname="boost_optional.detailed_semantics"></a><a class="link"href="detailed_semantics.html" title="Detailed Semantics">详细语义</a>

-</h2>
-
-
-</div>
-
-
-</div>
-
-
-</div>
-
-

-因为 <code class="computeroutput"><spanclass="identifier">T</code>-可能是引用类型，所以，那些语义与 <code class="computeroutput"><spanclass="identifier">T</code>

-的类型是否为引用相关的项，将使用以下约定： </p>
-
-
-<div class="itemizedlist">
-<ul type="disc">
-
-

- <li>如果该项为： <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T</code>(not aref)<code class="computeroutput"><spanclass="special">></code>,

-则对应的描述仅适作于T不是引用类型时的情况。 </li>
-
-

- <li>如果该项为：<code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>,

-则对应的描述仅适用于T是引用类型时的情况。 </li>
-
-

- <li>如果该项为：<code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>,

-则对应的描述适用于两种情况。 </li>
-
-
-</ul>
-
-
-</div>
-
-
-<div class="note">
-<table summary="Note" border="0">
-
-
-  <tbody>
-
-
-    <tr>
-
-

- <td rowspan="2" align="center" valign="top" width="25"><imgalt="[Note]" src="../../../../../doc/html/images/note.png"></td>

-
-
-      <th align="left">说明</th>
-
-
-    </tr>
-
-
-    <tr>
-
-
-      <td align="left" valign="top">
-

- 以下章节中包含多个 <code class="computeroutput"><spanclass="identifier">assert()</code>，仅用于示范后续条件的例子代码。它-并不意味着类型 <code class="computeroutput"><spanclass="identifier">T</code>

-必须支持每个单独的表达式，但是如果它支持某个表达式，则满足相应的条件。</p>
-
-
-      </td>
-
-
-    </tr>
-
-
-
-  </tbody>
-</table>
-
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.detailed_semantics"></a><a class="link"href="detailed_semantics.html" title="Detailed Semantics详细语义"> Detailed Semantics

+    &#35814;&#32454;&#35821;&#20041;</a>
+</h2></div></div></div>
+<p>

+ Because <code class="computeroutput"><spanclass="identifier">T</code> might be of reference+ type, in the sequel, those entries whose semantic depends on <codeclass="computeroutput">T</code> being ofreference type or not will be+ distinguished using the following convention: 因为<code class="computeroutput">T</code>+可能是引用类型，所以，那些语义与<code class="computeroutput">T</code>+的类型是否为引用相关的项，将使用以下约定：

+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+ If the entry reads: <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T</code>(not+ a ref)<code class="computeroutput"><spanclass="special">></code>, the description+ corresponds only to the case where <codeclass="computeroutput">T</code>+ is not of reference type. 如果该项为：<codeclass="computeroutput">optional<spanclass="special"><T</code><spanclass="emphasis">(非引用)<codeclass="computeroutput">></code>,则对应的描述仅适作于<code class="computeroutput">T</code>不是引用类型时的情况。

+      </li>
+<li>

+ If the entry reads: <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>,+ the description corresponds only to the case where <codeclass="computeroutput">T</code>+ is of reference type. 如果该项为：<codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">&></code>,+则对应的描述仅适用于<code class="computeroutput">T</code>+是引用类型时的情况。

+      </li>
+<li>

+ If the entry reads: <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>,+ the description is the same for both cases. 如果该项为：<codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>,+则对应的描述适用于两种情况。

+      </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>

+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]"src="../../../../../doc/html/images/note.png"></td>

+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>

+ The following section contains various <codeclass="computeroutput">assert<spanclass="special">()</code> which are used only to show thepostconditions+ as sample code. It is not implied that the type <codeclass="computeroutput">T</code>+ must support each particular expression but that if the expressionis supported,+ the implied condition holds. 以下章节中包含多个<code class="computeroutput">assert<spanclass="special">()</code>，仅用于示范后续条件的例子代码。+ 它并不意味着类型<code class="computeroutput">T</code>+必须支持每个单独的表达式，但是如果它支持某个表达式，则满足相应的条件。

+      </p></td></tr>
+</table></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>

+<aname="boost_optional.detailed_semantics.optional_class_member_functions__optional__________________"></a><h4>

+<a name="id4865163"></a>

+ <a class="link"href="detailed_semantics.html#boost_optional.detailed_semantics.optional_class_member_functions__optional__________________">optional+ class member functionsoptional类的成员函数</a>

+    </h4>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Default-Constructs an<code class="computeroutput"><spanclass="identifier">optional</code>. <spanclass="bold">作用：缺省构造一个+ <code class="computeroutput"><spanclass="identifier">optional</code>.

+      </li>
+<li>

+Postconditions:<codeclass="computeroutput">*<spanclass="keyword">this</code> is <spanclass="underline">uninitialized. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code> 为 <spanclass="underline">未初始化的。

+      </li>
+<li>

+Throws: Nothing. <spanclass="bold">抛出：无。

+      </li>
+<li>

+ Notes: T's default constructor isnot+ called. <spanclass="bold">说明：T的缺省构造函数<spanclass="underline">未被调用。

+      </li>
+<li>

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_none_t"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Constructs an <codeclass="computeroutput">optional</code>+ uninitialized. <spanclass="bold">作用：构造一个未初始化的+ <code class="computeroutput"><spanclass="identifier">optional</code>.

+      </li>
+<li>

+Postconditions:<codeclass="computeroutput">*<spanclass="keyword">this</code> is <spanclass="underline">uninitialized. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code> 为 <spanclass="underline">未初始化的。

+      </li>
+<li>

+Throws: Nothing. <spanclass="bold">抛出：无。

+      </li>
+<li>

+Notes:<codeclass="computeroutput">T</code>'s

+        default constructor <span class="underline">is not</span> called.

+ The expression <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">none</code> denotes an instance of <codeclass="computeroutput">boost<spanclass="special">::none_t</code> thatcan be used as the parameter. <spanclass="bold">说明：<codeclass="computeroutput">T</code>+ 的缺省构造函数<spanclass="underline">未被调用。表达式+ <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">none</code> 表示一个<code class="computeroutput">boost<spanclass="special">::none_t</code>+实例，可用作本构造函数的参数。

+      </li>
+<li>

+Example: <spanclass="bold">例子：<preclass="programlisting">#include <spanclass="special"><boost<spanclass="special">/none<spanclass="special">.hpp<spanclass="special">>+optional<spanclass="special"><T<spanclass="special">> n<spanclass="special">(none<spanclass="special">) ;+assert (!n <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_value"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T </code>(not aref)<code class="computeroutput"><spanclass="special">>::optional<spanclass="special">( T <spanclass="keyword">const& <spanclass="identifier">v )</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Directly-Constructs an<code class="computeroutput"><spanclass="identifier">optional</code>. <spanclass="bold">作用：直接构造一个+ <code class="computeroutput"><spanclass="identifier">optional</code>.

+      </li>
+<li>

+Postconditions:<codeclass="computeroutput">*<spanclass="keyword">this</code> is <spanclass="underline">initialized+ and its value is acopy of<code class="computeroutput"><spanclass="identifier">v</code>. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code> 为 <spanclass="underline">已初始化的，它的值为+ <code class="computeroutput"><spanclass="identifier">v</code> 的<spanclass="emphasis">拷贝。

+      </li>
+<li>

+      </li>
+<li>

+      </li>
+<li>

+Exception Safety: Exceptionscan only be+ thrown during <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T( <spanclass="identifier">T+ const<spanclass="special">&+ );</code> in that case, thisconstructor+ has no effect. <spanclass="bold">异常安全性：仅会在+ <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T( <spanclass="identifier">T+ const<spanclass="special">&+ );</code>中抛出异常，这时构造函数无效。

+      </li>
+<li>

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+      </li>
+<li>

+Postconditions:<codeclass="computeroutput">*<spanclass="keyword">this</code> is <spanclass="underline">initialized+ and its value is an instance of an internal type wrapping thereference+ <code class="computeroutput"><spanclass="identifier">ref</code>. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code> 为+ <spanclass="underline">已初始化的，它的值为某个内部类型的实例，包装了引用+ <code class="computeroutput"><spanclass="identifier">ref</code>.

+      </li>
+<li>

+Throws: Nothing. <spanclass="bold">抛出：无。

+      </li>
+<li>

+Example: <spanclass="bold">例子：<preclass="programlisting">T <spanclass="identifier">v;+T& <spanclass="identifier">vref = <spanclass="identifier">v ;+optional<spanclass="special"><T<spanclass="special">&> opt<spanclass="special">(vref<spanclass="special">);+assert (*opt <spanclass="special">== v <spanclass="special">) ;+++ v <spanclass="special">; // mutate referee+assert <spanclass="special">(*opt <spanclass="special">== v<spanclass="special">);

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_bool_value"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T</code> (not aref)<code class="computeroutput"><spanclass="special">>::optional<spanclass="special">( bool <spanclass="identifier">condition,+ T <spanclass="keyword">const& <spanclass="identifier">v ) <spanclass="special">;</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+          <span class="identifier">v</span> <span class="special">)</span>
+          <span class="special">;</span></code>
+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc"><li>

+ If condition is true, same as: 如果 condition为 true, 则相当于：

+      </li></ul></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T</code> (not aref)<code class="computeroutput"><spanclass="special">>::optional<spanclass="special">( T <spanclass="keyword">const& <spanclass="identifier">v )</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc"><li>

+ otherwise, same as: 否则相当于：

+      </li></ul></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_optional"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T </code>(not aref)<code class="computeroutput"><spanclass="special">>::optional<spanclass="special">( optional+ const<spanclass="special">&+ rhs <spanclass="special">);</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Copy-Constructs an<code class="computeroutput"><spanclass="identifier">optional</code>. <spanclass="bold">作用：复制构造一个+ <code class="computeroutput"><spanclass="identifier">optional</code>.

+      </li>
+<li>

+Postconditions: If rhs isinitialized,+ <code class="computeroutput">*<spanclass="keyword">this</code>+ is initialized and its value is a <spanclass="emphasis">copy of the value+ of <code class="computeroutput"><spanclass="identifier">rhs</code>; else <codeclass="computeroutput">*<spanclass="keyword">this</code> is uninitialized. <spanclass="bold">后续条件：如果<code class="computeroutput">rhs</code>+ 是已初始化的，则<code class="computeroutput">*<spanclass="keyword">this</code>+为已初始化的，且值为<code class="computeroutput">rhs</code>+ 的值的<spanclass="emphasis">拷贝；否则<code class="computeroutput">*<spanclass="keyword">this</code>为未初始化的。

+      </li>
+<li>

+      </li>
+<li>

+Notes: If rhs is initialized,<code class="computeroutput">T<spanclass="special">::T<spanclass="special">(T <spanclass="keyword">const& <spanclass="special">)</code> is+ called. <spanclass="bold">说明：如果<code class="computeroutput">rhs</code>是已初始化的，则调用<code class="computeroutput">T<spanclass="special">::T<spanclass="special">(T <spanclass="keyword">const& <spanclass="special">)</code> .

+      </li>
+<li>

+      </li>
+<li>

+optional<spanclass="special"><T<spanclass="special">> uinit2 <spanclass="special">( uninit <spanclass="special">) ;+assert (uninit2 ==uninit );

+optional<spanclass="special"><T<spanclass="special">> init<spanclass="special">( T<spanclass="special">(2<spanclass="special">) );+assert (*init <spanclass="special">== T<spanclass="special">(2<spanclass="special">) ) <spanclass="special">;

+optional<spanclass="special"><T<spanclass="special">> init2 <spanclass="special">( init <spanclass="special">) ;+assert (init2 == <spanclass="identifier">init ) <spanclass="special">;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+      </li>
+<li>

+Postconditions: If <codeclass="computeroutput">rhs</code>+ is initialized, <code class="computeroutput"><spanclass="special">*this</code>+ is initialized and its value is another reference to the sameobject referenced+ by <code class="computeroutput"><spanclass="special">*rhs</code>;+ else <code class="computeroutput"><spanclass="special">*this</code>+ is uninitialized. <spanclass="bold">后续条件：如果+ <code class="computeroutput"><spanclass="identifier">rhs</code>是已初始化的，则+ <code class="computeroutput">*<spanclass="keyword">this</code>+为已初始化的，且值为<code class="computeroutput">*<spanclass="identifier">rhs</code>所引用的同一个对象的另一个引用；否则+ <code class="computeroutput">*<spanclass="keyword">this</code>

+        &#20026;&#26410;&#21021;&#22987;&#21270;&#30340;&#12290;
+      </li>
+<li>

+Throws: Nothing. <spanclass="bold">抛出：无。

+      </li>
+<li>

+Notes: If <codeclass="computeroutput">rhs</code>+ is initialized, both <code class="computeroutput"><spanclass="special">*this</code>+ and <code class="computeroutput"><spanclass="special">*rhs</code>+ will reefer to the same object (they alias). <spanclass="bold">说明：如果+ <code class="computeroutput"><spanclass="identifier">rhs</code>是已初始化的，则+ <code class="computeroutput">*<spanclass="keyword">this</code>+ 与 <code class="computeroutput"><spanclass="special">*rhs</code>+均引向同一个对象(它们互为别名)。

+      </li>
+<li>

+optional<spanclass="special"><T<spanclass="special">&> uinit2( uninit <spanclass="special">) ;+assert (uninit2 ==uninit );

+T v <spanclass="special">= 2 <spanclass="special">; T<spanclass="special">& ref <spanclass="special">= v <spanclass="special">;+optional<spanclass="special"><T<spanclass="special">> init<spanclass="special">(ref<spanclass="special">);+assert (*init <spanclass="special">== v <spanclass="special">) ;

+optional<spanclass="special"><T<spanclass="special">> init2 <spanclass="special">( init <spanclass="special">) ;+assert (*init2 <spanclass="special">== v <spanclass="special">) ;

+v = <spanclass="number">3 ;

+assert (*init <spanclass="special">== 3 <spanclass="special">) ;+assert (*init2 <spanclass="special">== 3 <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_other_optional"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="keyword">template<<spanclass="identifier">U> <spanclass="keyword">explicit <spanclass="identifier">optional<<spanclass="identifier">T</code>+ (not a ref)<codeclass="computeroutput">>::<spanclass="identifier">optional( <spanclass="identifier">optional<<spanclass="identifier">U> <spanclass="keyword">const& <spanclass="identifier">rhs );</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+      </li>
+<li>

+Postconditions: If <codeclass="computeroutput">rhs</code>+ is initialized, <code class="computeroutput"><spanclass="special">*this</code>+ is initialized and its value is a <spanclass="emphasis">copy of the value+ of rhs converted to type <code class="computeroutput"><spanclass="identifier">T</code>;+ else <code class="computeroutput"><spanclass="special">*this</code>+ is uninitialized. <spanclass="bold">后续条件：如果+ <code class="computeroutput"><spanclass="identifier">rhs</code>是已初始化的，则+ <code class="computeroutput">*<spanclass="keyword">this</code>+为已初始化的，且值为<code class="computeroutput">rhs</code>+转换为类型T的值的拷贝；否则<code class="computeroutput">*<spanclass="keyword">this</code>为未初始化的。

+      </li>
+<li>

+      </li>
+<li>

+Notes: <codeclass="computeroutput">T<spanclass="special">::T<spanclass="special">(+ U <spanclass="keyword">const& <spanclass="special">)</code> is+ called if <code class="computeroutput"><spanclass="identifier">rhs</code> is initialized,+ which requires a valid conversion from <codeclass="computeroutput">U</code>+ to <code class="computeroutput"><spanclass="identifier">T</code>. <spanclass="bold">说明：如果+ <code class="computeroutput"><spanclass="identifier">rhs</code>已初始化，则调用+ <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T( <spanclass="identifier">U+ const<spanclass="special">&+ )</code>,要求有从 <code class="computeroutput"><spanclass="identifier">U</code>+ 到 <code class="computeroutput"><spanclass="identifier">T</code>的有效转换。

+      </li>
+<li>

+Exception Safety: Exceptionscan only be+ thrown during <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T( <spanclass="identifier">U+ const<spanclass="special">&+ );</code> in that case, thisconstructor+ has no effect. <spanclass="bold">异常安全性：仅会在+ <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T( <spanclass="identifier">U+ const<spanclass="special">&+ );</code>中抛出异常，这时构造函数无效。

+      </li>
+<li>

+optional<spanclass="special"><int<spanclass="special">> y<spanclass="special">(x<spanclass="special">) ;+assert( <spanclass="special">*y <spanclass="special">== 123 <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_constructor_factory"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="keyword">template<<spanclass="identifier">InPlaceFactory>+ explicit <spanclass="identifier">optional<<spanclass="identifier">T</code>+ (not a ref)<codeclass="computeroutput">>::<spanclass="identifier">optional( <spanclass="identifier">InPlaceFactory <spanclass="keyword">const& <spanclass="identifier">f );</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="keyword">template<<spanclass="identifier">TypedInPlaceFactory<spanclass="special">>+ explicit <spanclass="identifier">optional<<spanclass="identifier">T</code>+ (not a ref)<codeclass="computeroutput">>::<spanclass="identifier">optional( <spanclass="identifier">TypedInPlaceFactory <spanclass="keyword">const& <spanclass="identifier">f );</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Constructs an <codeclass="computeroutput">optional</code>+ with a value of <code class="computeroutput"><spanclass="identifier">T</code> obtained+ from the factory. <spanclass="bold">作用：构造一个+ <code class="computeroutput"><spanclass="identifier">optional</code>，<codeclass="computeroutput">T</code>的值从工厂获得。

+      </li>
+<li>

+Postconditions: <codeclass="computeroutput">*<spanclass="keyword">this</code> is <spanclass="underline">initialized+ and its value is directlygiven from the factory <code class="computeroutput"><spanclass="identifier">f</code> (i.e., the value <spanclass="underline">is+ not copied). <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code><spanclass="underline">已初始化且其值<spanclass="emphasis">直接由工厂+ <code class="computeroutput"><spanclass="identifier">f</code>取得(即该值<spanclass="underline">不是复制的)。

+      </li>
+<li>

+Throws: Whatever the <codeclass="computeroutput">T</code>+ constructor called by the factory throws. <spanclass="bold">抛出：由工厂所调用的+ <code class="computeroutput"><spanclass="identifier">T</code>构造函数所抛出的任何异常。

+      </li>
+<li>

+Notes: See <a class="link"href="in_place_factories.html" title="In-Place Factories就地创建">In-Place+ Factories</a> <spanclass="bold">说明：请见+ <a class="link" href="in_place_factories.html" title="In-PlaceFactories就地创建">就地创建</a>

+</li>
+<li>

+Exception Safety: Exceptionscan only be+ thrown during the call to the <code class="computeroutput"><spanclass="identifier">T</code>+ constructor used by the factory; in that case, this constructorhas no effect. <spanclass="bold">异常安全性：仅会在工厂调用+ <code class="computeroutput"><spanclass="identifier">T</code>的构造函数时抛出异常，这时构造函数无效。

+      </li>
+<li>

+Example: <spanclass="bold">例子：<preclass="programlisting">class <spanclass="identifier">C { <spanclass="identifier">C ( <spanclass="keyword">char, <spanclass="keyword">double, <spanclass="identifier">std::<spanclass="identifier">string ) <spanclass="special">; } <spanclass="special">;

+C v<spanclass="special">('A'<spanclass="special">,123.4<spanclass="special">,"hello"<spanclass="special">);

+optional<spanclass="special"><C<spanclass="special">> x<spanclass="special">( in_place <spanclass="special">('A'<spanclass="special">, 123.4<spanclass="special">, "hello"<spanclass="special">) ); <spanclass="comment">// InPlaceFactory used+optional<spanclass="special"><C<spanclass="special">> y<spanclass="special">( in_place<spanclass="special"><C<spanclass="special">>('A'<spanclass="special">, 123.4<spanclass="special">, "hello"<spanclass="special">) ); <spanclass="comment">// TypedInPlaceFactory used

+</span>

+assert (*x <spanclass="special">== v <spanclass="special">) ;+assert (*y <spanclass="special">== v <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_operator_equal_value"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional&+ optional<spanclass="special"><T</code> <spanclass="emphasis">(not a ref)<codeclass="computeroutput">>::<spanclass="keyword">operator= <spanclass="special">( T+ const<spanclass="special">&+ rhs <spanclass="special">)

+          <span class="special">;</span></code>
+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Assigns the value <codeclass="computeroutput">rhs</code> to an<code class="computeroutput"><spanclass="identifier">optional</code>. <spanclass="bold">作用：将值<code class="computeroutput">rhs</code>+ 赋给一个 <codeclass="computeroutput">optional</code>.

+      </li>
+<li>

+Postconditions: <codeclass="computeroutput">*<spanclass="keyword">this</code> is initialized and its value is a <spanclass="emphasis">copy+ of <code class="computeroutput"><spanclass="identifier">rhs</code>. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code>为已初始化的，其值为+ <code class="computeroutput"><spanclass="identifier">rhs</code> 的<spanclass="emphasis">拷贝。

+      </li>
+<li>

+Throws: Whatever <codeclass="computeroutput">T<spanclass="special">::operator<spanclass="special">=( T <spanclass="keyword">const& <spanclass="special">)</code> or+ <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T(<spanclass="identifier">T+ const<spanclass="special">&)</code>+ throws. <spanclass="bold">抛出：由 <codeclass="computeroutput">T<spanclass="special">::operator<spanclass="special">=( T <spanclass="keyword">const& <spanclass="special">)</code> 或+ <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T(<spanclass="identifier">T+ const<spanclass="special">&)</code>

+        &#25243;&#20986;&#30340;&#20219;&#20309;&#24322;&#24120;&#12290;
+      </li>
+<li>

+Notes: If <codeclass="computeroutput">*<spanclass="keyword">this</code> was initialized, <codeclass="computeroutput">T</code>'s+ assignment operator is used, otherwise, its copy-constructor isused. <spanclass="bold">说明：如果<code class="computeroutput">*<spanclass="keyword">this</code>是已初始化的，则使用<code class="computeroutput">T</code>的赋值操作符，否则使用它的复制构造函数。

+      </li>
+<li>

+Exception Safety: In the eventof an exception,+ the initialization state of <code class="computeroutput"><spanclass="special">*this</code> isunchanged and its value unspecified+ as far as <code class="computeroutput"><spanclass="identifier">optional</code> is concerned+ (it is up to <code class="computeroutput"><spanclass="identifier">T</code>'s <code class="computeroutput"><spanclass="keyword">operator=()</code>).+ If <code class="computeroutput"><spanclass="special">*this</code>+ is initially uninitialized and <code class="computeroutput"><spanclass="identifier">T</code>'s+ copy constructor fails,<code class="computeroutput">*<spanclass="keyword">this</code> is left properly uninitialized. <spanclass="bold">异常安全性：如果发生异常，<codeclass="computeroutput">*<spanclass="keyword">this</code>的初始化状态不会改变，它的值是不确定的直至+ <code class="computeroutput"><spanclass="identifier">optional</code> 被关联(由<code class="computeroutput">T</code>的 <code class="computeroutput"><spanclass="keyword">operator=()</code>进行)。 如 <code class="computeroutput"><spanclass="special">*this</code>原来是未初始化的，且<code class="computeroutput">T</code>的<spanclass="emphasis">复制构造函数+ 失败了，则 <codeclass="computeroutput">*<spanclass="keyword">this</code>

+        &#20173;&#20026;&#26410;&#21021;&#22987;&#21270;&#30340;&#12290;
+      </li>
+<li>

+T y<spanclass="special">;+def = <spanclass="identifier">y ;+assert (*def <spanclass="special">== y <spanclass="special">) ;+opt = <spanclass="identifier">y ;+assert (*opt <spanclass="special">== y <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&>&+ optional<spanclass="special"><T<spanclass="special">&>::<spanclass="keyword">operator= <spanclass="special">( T<spanclass="special">&+ const<spanclass="special">&+ rhs <spanclass="special">)

+          <span class="special">;</span></code>
+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: (Re)binds thee wrappedreference. <spanclass="bold">作用：(重)绑定被包装的引用。

+      </li>
+<li>

+Postconditions: <codeclass="computeroutput">*<spanclass="keyword">this</code> is initialized and it references the+ same object referenced by <code class="computeroutput"><spanclass="identifier">rhs</code>. <spanclass="bold">后续条件：<codeclass="computeroutput">*<spanclass="keyword">this</code>已初始化且引向由 <codeclass="computeroutput">rhs</code>所引向的对象。

+      </li>
+<li>

+Notes: If <codeclass="computeroutput">*<spanclass="keyword">this</code> was initialized, is is <spanclass="emphasis">rebound+ to the new object. See <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">here</a>+ for details on this behavior. <spanclass="bold">说明：如果+ <code class="computeroutput">*<spanclass="keyword">this</code>+ 已初始化，则<spanclass="emphasis">重绑定到新的对象。有关细节请见+ <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">这里</a>。

+      </li>
+<li>

+Example: <spanclass="bold">例子：<preclass="programlisting">int <spanclass="identifier">a = <spanclass="number">1 ;+int b <spanclass="special">= 2 <spanclass="special">;+T& <spanclass="identifier">ra = <spanclass="identifier">a ;+T& <spanclass="identifier">rb = <spanclass="identifier">b ;+optional<spanclass="special"><int<spanclass="special">&> def <spanclass="special">;+optional<spanclass="special"><int<spanclass="special">&> opt<spanclass="special">(ra<spanclass="special">) ;

+def = <spanclass="identifier">rb ; <spanclass="comment">// binds 'def' to 'b' through 'rb'+assert <spanclass="special">( *<spanclass="identifier">def == <spanclass="identifier">b ) <spanclass="special">;+*def <spanclass="special">= a <spanclass="special">; // changes the value of 'b'to a copy of the value of 'a'+assert <spanclass="special">( b <spanclass="special">== a <spanclass="special">) ;+int c <spanclass="special">= 3<spanclass="special">;+int& <spanclass="identifier">rc = <spanclass="identifier">c ;+opt = <spanclass="identifier">rc ; <spanclass="comment">// REBINDS to 'c' through 'rc'+c =4 ;+assert (*opt <spanclass="special">== 4 <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_operator_equal_optional"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional&+ optional<spanclass="special"><T</code> <spanclass="emphasis">(not a ref)<codeclass="computeroutput">>::<spanclass="keyword">operator= <spanclass="special">( optional+ const<spanclass="special">&+ rhs <spanclass="special">)

+          <span class="special">;</span></code>
+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: Assigns another <codeclass="computeroutput">optional</code>+ to an <code class="computeroutput"><spanclass="identifier">optional</code>. <spanclass="bold">作用：将另一个<code class="computeroutput">optional</code>+ 赋值给一个 <codeclass="computeroutput">optional</code>.

+      </li>
+<li>

+Postconditions: If <codeclass="computeroutput">rhs</code>+ is initialized, <code class="computeroutput"><spanclass="special">*this</code>+ is initialized and its value is a <spanclass="emphasis">copy of the value+ of <code class="computeroutput"><spanclass="identifier">rhs</code>; else <codeclass="computeroutput">*<spanclass="keyword">this</code> is uninitialized. <spanclass="bold">后续条件：如果<code class="computeroutput">rhs</code>+ 已初始化，则 <codeclass="computeroutput">*<spanclass="keyword">this</code>+为已初始化且其值为<code class="computeroutput">rhs</code>+ 值的<spanclass="emphasis">拷贝；否则<code class="computeroutput">*<spanclass="keyword">this</code>为未初始化。

+      </li>
+<li>

+Throws: Whatever <codeclass="computeroutput">T<spanclass="special">::operator<spanclass="special">( T <spanclass="keyword">const&)</code> or<code class="computeroutput">T<spanclass="special">::T<spanclass="special">(+ T <spanclass="keyword">const& <spanclass="special">)</code> throws. <spanclass="bold">抛出：由 <codeclass="computeroutput">T<spanclass="special">::operator<spanclass="special">( T <spanclass="keyword">const&)</code>或 <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T(+ T <spanclass="keyword">const& <spanclass="special">)</code>抛出的任何异常。

+      </li>
+<li>

+Notes: If both <codeclass="computeroutput">*<spanclass="keyword">this</code> and <code class="computeroutput"><spanclass="identifier">rhs</code>+ are initially initialized, <code class="computeroutput"><spanclass="identifier">T</code>'s+ assignment operator isused. If <code class="computeroutput">*<spanclass="keyword">this</code> is initially initialized but <codeclass="computeroutput">rhs</code> isuninitialized, <code class="computeroutput"><spanclass="identifier">T</code>'s+ [destructor] is called. If <code class="computeroutput"><spanclass="special">*this</code> isinitially uninitialized but <code class="computeroutput"><spanclass="identifier">rhs</code> is initialized, <codeclass="computeroutput">T</code>'s+ copy constructor iscalled. <spanclass="bold">说明：如果+ <code class="computeroutput">*<spanclass="keyword">this</code>+ 和 <code class="computeroutput"><spanclass="identifier">rhs</code>均已初始化，则使用+ <code class="computeroutput"><spanclass="identifier">T</code> 的 <spanclass="emphasis">赋值操作符。+ 如果 <code class="computeroutput"><spanclass="special">*this</code>+ 已初始化而 <codeclass="computeroutput">rhs</code>未初始化，则调用+ <code class="computeroutput"><spanclass="identifier">T</code> 的 <spanclass="emphasis">析构函数。+ 如果 <code class="computeroutput"><spanclass="special">*this</code>+ 未初始化而 <codeclass="computeroutput">rhs</code>已初始化，则调用+ <code class="computeroutput"><spanclass="identifier">T</code> 的 <spanclass="emphasis">复制构造函数。

+      </li>
+<li>

+Exception Safety: In the eventof an exception,+ the initialization state of <code class="computeroutput"><spanclass="special">*this</code> isunchanged and its value unspecified+ as far as optional is concerned (it is up to <codeclass="computeroutput">T</code>'s+ <code class="computeroutput"><spanclass="keyword">operator=()</code>).+ If <code class="computeroutput"><spanclass="special">*this</code>+ is initially uninitialized and <code class="computeroutput"><spanclass="identifier">T</code>'s+ copy constructor fails,<code class="computeroutput">*<spanclass="keyword">this</code> is left properly uninitialized. <spanclass="bold">异常安全性：发生异常时，<codeclass="computeroutput">*<spanclass="keyword">this</code>的初始化状态不改变，其值是不确定的直至+ <code class="computeroutput"><spanclass="identifier">optional</code> 被关联(由T+ 的 <code class="computeroutput"><spanclass="keyword">operator=()</code>+ 进行)。 如果 <codeclass="computeroutput">*<spanclass="keyword">this</code>+原来是未初始化的而且<code class="computeroutput">T</code>+ 的 <spanclass="emphasis">复制构造函数失败，则 <code class="computeroutput"><spanclass="special">*this</code>保持为未初始化]

+      </li>
+<li>

+opt = <spanclass="identifier">def ;+assert (!def <spanclass="special">) ;+// previous value (copy of 'v') destroyed fromwithin 'opt'.+<spanclass="comment">// 'opt'的原值('v'的拷贝)被销毁

+</span></pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+        </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&>+ & <spanclass="identifier">optional<<spanclass="identifier">T&>::<spanclass="keyword">operator= <spanclass="special">( optional<spanclass="special"><T<spanclass="special">&> const<spanclass="special">& rhs <spanclass="special">) ;</code>

+        </p>
+<p>
+      </p>
+</blockquote></div>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Effect: (Re)binds thee wrappedreference. <spanclass="bold">作用：(重)绑定被包装的引用。

+      </li>
+<li>

+Postconditions: If <codeclass="computeroutput">*<spanclass="identifier">rhs</code> is initialized, <codeclass="computeroutput">*<spanclass="keyword">this</code> is initialized and it references the+ same object referenced by <code class="computeroutput"><spanclass="special">*rhs</code>;otherwise, <code class="computeroutput">*<spanclass="keyword">this</code> is uninitialized (and references noobject). <spanclass="bold">后续条件：如果<code class="computeroutput">*<spanclass="identifier">rhs</code>已初始化，则 <codeclass="computeroutput">*<spanclass="keyword">this</code>为已初始化的且引向且引向由+ <code class="computeroutput">*<spanclass="identifier">rhs</code>+所引向的对象；否则<code class="computeroutput">*<spanclass="keyword">this</code>为未初始化(不引向任何对象)。

+      </li>
+<li>

+Notes: If <codeclass="computeroutput">*<spanclass="keyword">this</code> was initialized and so is *rhs, this+ is is rebound to the newobject. See <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">here</a>+ for details on this behavior. <spanclass="bold">说明：如果+ <code class="computeroutput">*<spanclass="keyword">this</code>+ 已初始化且 <codeclass="computeroutput">*<spanclass="identifier">rhs</code>+ 也是，则<spanclass="emphasis">重绑定到新的对象。有关细节请见+ <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">这里</a>。

+      </li>
+<li>

+Example: <spanclass="bold">例子：<preclass="programlisting">int <spanclass="identifier">a = <spanclass="number">1 ;+int b <spanclass="special">= 2 <spanclass="special">;+T& <spanclass="identifier">ra = <spanclass="identifier">a ;+T& <spanclass="identifier">rb = <spanclass="identifier">b ;+optional<spanclass="special"><int<spanclass="special">&> def <spanclass="special">;+optional<spanclass="special"><int<spanclass="special">&> ora<spanclass="special">(ra<spanclass="special">) ;+optional<spanclass="special"><int<spanclass="special">&> orb<spanclass="special">(rb<spanclass="special">) ;

+def = <spanclass="identifier">orb ; <spanclass="comment">// binds 'def' to 'b' through 'rb' wrapped within 'orb'+assert <spanclass="special">( *<spanclass="identifier">def == <spanclass="identifier">b ) <spanclass="special">;+*def <spanclass="special">= ora <spanclass="special">; // changes the value of 'b'to a copy of the value of 'a'+assert <spanclass="special">( b <spanclass="special">== a <spanclass="special">) ;+int c <spanclass="special">= 3<spanclass="special">;+int& <spanclass="identifier">rc = <spanclass="identifier">c ;+optional<spanclass="special"><int<spanclass="special">&> orc<spanclass="special">(rc<spanclass="special">) ;+ora = <spanclass="identifier">orc ; <spanclass="comment">// REBINDS ora to 'c' through 'rc'+c =4 ;+assert (*ora <spanclass="special">== 4 <spanclass="special">) ;

+</pre>
+</li>
+</ul></div>
+<p>

+ <img src="../images/space.png"alt="space">

+    </p>
+<a name="reference_optional_operator_equal_other_optional"></a><p>
+    </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
***The diff for this file has been truncated for email.***
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/development.html Tue Nov25 06:14:27 2008+++ /trunk/libs/optional/doc/html/boost_optional/development.html Wed Mar24 00:54:49 2010

@@ -1,339 +1,532 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-

- <title>Development</title><link rel="stylesheet" href="../boostbook.css"type="text/css">

-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="../index.html"title="Chapter 1. Boost.Optional">

-
-  <link rel="next" href="synopsis.html" title="Synopsis"></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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../more/index.htm">More</a></td>

-
-    </tr>
-  </tbody>
-</table>
-
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Development &#21457;&#23637;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="next" href="synopsis.html" title="Synopsis &#25688;&#35201;">
+</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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="synopsis.html"><imgsrc="../../../../../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_optional.development"></a><a class="link"href="development.html" title="Development">发展</a>

-</h2>
-</div>
-</div>
-</div>
-
-<div class="toc">
-<dl>
-

- <dt><ahref="development.html#boost_optional.development.the_models">模型</a></dt>

- <dt><ahref="development.html#boost_optional.development.the_semantics">语义</a></dt>

- <dt><ahref="development.html#boost_optional.development.the_interface">接口</a></dt>

-
-</dl>
-</div>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.development"></a><a class="link"href="development.html" title="Development 发展"> Development发展</a>

+</h2></div></div></div>
+<div class="toc"><dl>

+<dt><ahref="development.html#boost_optional.development.the_models"> The models模型</a></dt>+<dt><ahref="development.html#boost_optional.development.the_semantics"> Thesemantics

+      &#35821;&#20041;</a></span></dt>

+<dt><ahref="development.html#boost_optional.development.the_interface"> TheInterface

+      &#25509;&#21475;</a></span></dt>
+</dl></div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<a name="boost_optional.development.the_models"></a><a class="link"href="development.html#boost_optional.development.the_models" title="Themodels">模型</a>

-</h3>
+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.development.the_models"></a><a class="link"href="development.html#boost_optional.development.the_models" title="Themodels 模型"> The models 模型</a>

+</h3></div></div></div>
+<p>

+ In C++, we can declare anobject (a variable) of type+ <code class="computeroutput"><spanclass="identifier">T</code>, and we can give this variable+ an initial value (throughan initializer.+ (c.f. 8.5)). When a declaration includes a non-empty initializer(an initial+ value is given), it is said that the object has been initialized.If the+ declaration uses an empty initializer (no initial value is given),and neither+ default nor value initialization applies, it is said that theobject is+ uninitialized. Itsactual value exist but+ has an indeterminate initialvalue (c.f. 8.5.9). <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> intends+ to formalize the notion of initialization (or lack of it) allowinga program+ to test whether an object has been initialized and stating thataccess to+ the value of an uninitialized object is undefined behavior. Thatis, when+ a variable is declared as <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ and no initial value is given, the variable is <spanclass="emphasis">formally+ uninitialized. A formally uninitialized optional object hasconceptually+ no value at all and this situation can be tested at runtime. It isformally+ undefined behavior to tryto access the value of an+ uninitialized optional. An uninitialized optional can be assigneda value,+ in which case its initialization state changes to initialized.Furthermore,+ given the formal treatment of initialization states in optionalobjects,+ it is even possible to reset an optional to <spanclass="emphasis">uninitialized. + 在C++中，我们可以<spanclass="emphasis">声明类型 <codeclass="computeroutput">T</code>+的一个对象(变量)，并且我们可以给这个对象一个<spanclass="emphasis">初始值(通过<spanclass="emphasis">初始化(参考+ 8.5))。当一个声明中包含非空的初始化(即给出一个初始值)，就称这个对象已被初始化。+如果一个声明使用了空的初始化(即未给出初始值)，而且也没缺省值可用于初始化，则称该对象是<spanclass="bold">未初始化的。它的真实值是存在的，但具有一个<spanclass="emphasis">不确定的初始值(参考+ 8.5.9)。 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>的目的是规范初始化(或无初始化)的概念，让程序可以检测一个对象是否已初始化，+并规定访问一个未初始化对象的值是未定义的行为。即，如果一个变量被声明为+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>而未给定初始值，则该变量就是<spanclass="emphasis">正式的未初始化。+一个正式的未初始化的optional对象是没有值的，并且可以在运行期对此状态进行测试。+尝试访问一个未初始化的optional 被正式规定为<spanclass="emphasis">未定义行为。一个未初始化的+ optional可以被赋予一个值，这时它的初始化状态就会变为已初始化。+ 此外，还给出处理optional对象的初始化状态的方法，甚至可以将一个+ optional 重新置为<spanclass="emphasis">未初始化。

+      </p>
+<p>

+ In C++ there is no formal notion of uninitialized objects, whichmeans that+ objects always have an initial value even if indeterminate. Asdiscussed+ on the previous section, this has a drawback because you needadditional+ information to tell if an object has been effectively initialized.One of+ the typical ways in which this has been historically dealt with isvia a+ special value: <code class="computeroutput"><spanclass="identifier">EOF</code>, <code class="computeroutput"><spanclass="identifier">npos</code>, -1, etc... This is equivalent to+ adding the special value to the set of possible values of a giventype. This+ super set of <code class="computeroutput"><spanclass="identifier">T</code> plus some+ nil_t—were <codeclass="computeroutput">nil_t</code>+ is some stateless POD-can be modeled in modern languages as adiscriminated+ union of T and nil_t. Discriminated unions areoften called variants.+ A variant has a currenttype, which in our case is either+ <code class="computeroutput"><spanclass="identifier">T</code> or <code class="computeroutput"><spanclass="identifier">nil_t</code>.+ Using the <a href="../../../../variant/index.html"target="_top">Boost.Variant</a>+ library, this model can be implemented in terms of <codeclass="computeroutput">boost<spanclass="special">::variant<spanclass="special"><T<spanclass="special">,nil_t<spanclass="special">></code>.+ There is precedent for a discriminated union as a model for anoptional value:+ the <a href="http://www.haskell.org/"; target="_top">Haskell</a>Maybe+ built-in type constructor. Thus, a discriminated union <codeclass="computeroutput">T<spanclass="special">+nil_t</code>+ serves as a conceptual foundation. 在C++里没有未初始化对象的正式概念，即是说对象总是带有初始值的，即使是不确定的值。+正如前面所讨论的，这样有一个缺点，因为你需要用额外的信息来告知一个对象是不是已经被有效地初始化了。+一种以前常用的典型方法是使用特殊值：<codeclass="computeroutput">EOF</code>,+ <code class="computeroutput"><spanclass="identifier">npos</code>, -1, 等等...这相当于增加一个特殊值到给定类型的可取值的集合中。+ 由 <code class="computeroutput"><spanclass="identifier">T</code> 加上某个 <spanclass="emphasis">nil_t+ — <code class="computeroutput"><spanclass="identifier">nil_t</code>是某个无状态的POD+ --组成的超集在现代语言中可以被模仿为由T 和 nil_t 组成的一个<spanclass="bold">可识别联合。可识别联合通常称为variants.+ 一个 variant 具有 <spanclass="emphasis">当前类型，在我们的例子中就是+ <code class="computeroutput"><spanclass="identifier">T</code> 或者 <codeclass="computeroutput">nil_t</code>.+ 使用 <a href="../../../../variant/index.html"target="_top">Boost.Variant</a>库，以上模型可以用+ <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">variant<<spanclass="identifier">T,<spanclass="identifier">nil_t></code>来实现。用可识别联合来模仿一个+ optional值是有先例的：<ahref="http://www.haskell.org/"; target="_top">Haskell</a>+ 的 Maybe内建类型构造器。所以，可识别联合+ <code class="computeroutput"><spanclass="identifier">T+<spanclass="identifier">nil_t</code>可以作为一个概念上的基础。

+      </p>
+<p>

+ A <code class="computeroutput"><spanclass="identifier">variant<<spanclass="identifier">T,<spanclass="identifier">nil_t></code>follows naturally from the traditional+ idiom of extending the range of possible values adding anadditional sentinel+ value with the special meaning of <spanclass="emphasis">Nothing. However,+ this additional Nothingvalue is largely irrelevant+ for our purpose since our goal is to formalize the notion ofuninitialized+ objects and, while a special extended value can be used to conveythat meaning,+ it is not strictly necessary in order to do so. <codeclass="computeroutput">variant<spanclass="special"><T<spanclass="special">,nil_t<spanclass="special">></code>+自然而然地可用于扩展可取值的传统惯用法，它增加一个"哨兵"值用于表示<spanclass="emphasis">空值。+不过，这个新增的<spanclass="emphasis">空值与我们意图大不相关，因为我们的目标是规范化未初始化对象的概念，+虽然一个特殊的扩展值可以用于表达这个意思，但是它并不是严格必要的。

+      </p>
+<p>

+ The observation made in the last paragraph about the irrelevantnature of+ the additional <code class="computeroutput"><spanclass="identifier">nil_t</code> with+ respect to purpose of <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code> suggests+ an alternative model: a <spanclass="emphasis">container that either has a+ value of <code class="computeroutput"><spanclass="identifier">T</code> or nothing. +最近的研究表明，额外的<code class="computeroutput">nil_t</code>+ 对于 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> 的+ 目的是无关的，我们建议另一种模型：一个<spanclass="emphasis">容器，它具有+ <code class="computeroutput"><spanclass="identifier">T</code>的值，或者为空。

+      </p>
+<p>

+ As of this writing I don't know of any precedence for avariable-size fixed-capacity+ (of 1) stack-based container model for optional values, yet Ibelieve this+ is the consequence of the lack of practical implementations ofsuch a container+ rather than an inherent shortcoming of the container model. 在写这篇文档之时，我还不知道有任何一个大小可变、容量固定(为1)、基于栈的+ optional值的容器模型的先例，但是我相信这只是因为还没有这样一个容器的实际实现，而不是这样一个容器模型的固有缺点。

+      </p>
+<p>

+ In any event, both the discriminated-union or the single-elementcontainer+ models serve as a conceptual ground for a class representingoptional—i.e.+ possibly uninitialized—objects. For instance, these modelsshow the exact+ semantics required for a wrapper of optional values: 无论如何，可识别联合或单元素容器模型均可作为表示+ optional 类 —即可能未初始化的 —对象的基础。例如，这些模型表现出了一个+ optional值包装器所需的<spanclass="emphasis">准确语义：

+      </p>
+<p>

+ Discriminated-union: 可识别联合：

+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+deep-copy semantics: copies ofthe variant+ implies copies of the value. <spanclass="bold">深复制+ 语义：variant的拷贝即为值的拷贝。

+        </li>
+<li>

+deep-relational semantics:comparisons+ between variants matches both current types and values <spanclass="bold">深比较语义：比较两个 variants要同时匹配类型和值。

+        </li>
+<li>

+ If the variant's current type is <codeclass="computeroutput">T</code>,+ it is modeling an <spanclass="emphasis">initialized optional. 如果+ variant 的当前类型为 <codeclass="computeroutput">T</code>,+ 它就代表<spanclass="emphasis">已初始化的optional.

+        </li>
+<li>

+ If the variant's current type is not <codeclass="computeroutput">T</code>,+ it is modeling an <spanclass="emphasis">uninitialized optional. 如果+ variant 的当前类型不是<code class="computeroutput">T</code>,+ 它就代表<spanclass="emphasis">未初始化的optional.

+        </li>
+<li>

+ Testing if the variant's current type is <codeclass="computeroutput">T</code>+ models testing if the optional is initialized 测试 variant的当前类型是否为+ <code class="computeroutput"><spanclass="identifier">T</code> 即测试 optional是否已初始化。

+        </li>
+<li>

+ Trying to extract a <code class="computeroutput"><spanclass="identifier">T</code> from+ a variant when its current type is not <codeclass="computeroutput">T</code>,+ models the undefined behavior of trying to access the value ofan uninitialized+ optional 试图从一个 variant取出 <code class="computeroutput"><spanclass="identifier">T</code>+而它的当前类型不是<code class="computeroutput">T</code>+时，正好符合了访问一个未初始化optional 值的未定义行为。

+        </li>
+</ul></div>
+<p>

+ Single-element container: 单元素容器：

+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+deep-copy semantics: copies ofthe container+ implies copies of the value. <spanclass="bold">深复制+ 语义：container的拷贝即为值的拷贝。

+        </li>
+<li>

+deep-relational semantics:comparisons+ between containers compare container size and if match,contained value <spanclass="bold">深比较语义：比较两个 containers+要先比较容器的大小，如果匹配再比较容器中的值。

+        </li>
+<li>

+ If the container is not empty (contains an object of type <codeclass="computeroutput">T</code>), it ismodeling an initialized+ optional. 如果 container非空(包含一个类型为<code class="computeroutput">T</code>的对象)，它就代表<spanclass="emphasis">已初始化的

+          optional.
+        </li>
+<li>

+ If the container is empty, it is modeling an <spanclass="emphasis">uninitialized+ optional. 如果 container为空，它就代表<spanclass="emphasis">未初始化的

+          optional.
+        </li>
+<li>

+ Testing if the container is empty models testing if the optionalis initialized + 测试 container是否为空即测试 optional是否已初始化。

+        </li>
+<li>

+ Trying to extract a <code class="computeroutput"><spanclass="identifier">T</code> from+ an empty container models the undefined behavior of trying toaccess the+ value of an uninitialized optional 试图从一个空的 container+ 取出 <code class="computeroutput"><spanclass="identifier">T</code>，正好符合了访问一个未初始化+ optional值的未定义行为。

+        </li>
+</ul></div>
 </div>
-</div>
-</div>
-

-在C++中，我们可以声明类型T的一个对象(变量)，并且我们可以给这个对象一个初始值(通过初始化 (参考-8.5))。当一个声明中包含非空的初始化(即给出一个初始值)，就称这个对象已被初始化。如果一个声明使用了空的初始化(即未给出初始值)，而且也没缺省值可用于初始化，则称该对象是未初始化的。它的真实值是存在的，但具有一个不确定的初始值(参考

-8.5.9)。<code>optional&lt;T&gt;</code>

-的目的是规范初始化(或无初始化)的概念，让程序可以检测一个对象是否已初始化，并规定访问一个未初始化对象的值是未定义的行为。即，如果一个变量被声明为<code class="computeroutput">optional<spanclass="special"><T<spanclass="special">></code> 而未给定初始值，则该变量就是<spanstyle="font-style: italic;">正式的未初始化。一个正式的未初始化的optional-对象是没有值的，并且可以在运行期对此状态进行测试。尝试访问一个未初始化的optional 被正式规定为未定义行为。一个未初始化的 optional 可以被赋予一个值，这时它的初始化状态就会变为已初始化。此外，还给出处理 optional-对象的初始化状态的方法，甚至可以将一个 optional 重新置为<spanstyle="font-style: italic;">未初始化。 

-</p>

-在C++里没有未初始化对象的正式概念，即是说对象总是带有初始值的，即使是不确定的值。正如前面所讨论的，这样有一个缺点，因为你需要用额外的信息来告知一个对象是不是已经被有效地初始化了。一种以前常用的典型方法是使用特殊值：<codeclass="computeroutput">EOF</code>, <codeclass="computeroutput">npos</code>, -1,-等等... 这相当于增加一个特殊值到给定类型的可取值的集合中。由 <codeclass="computeroutput">T</code> 加上某个nil_t -- <code class="computeroutput"><spanclass="identifier">nil_t</code> 是某个无状态的POD ---组成的超集在现代语言中可以被模仿为由 <code>T</code> 和 <code>nil_t</code>组成的一个可识别联合。可识别联合通常称为 variants. 一个 variant 具有-当前类型，在我们的例子中就是<code>T</code> 或者-<code>nil_t</code>.使用 <ahref="../../../../variant/index.html">Boost.Variant</a> 库，以上模型可以用-<code>boost::variant<T,nil_t></code> 来实现。用可识别联合来模仿一个optional-值是有先例的：<a href="http://www.haskell.org/";>Haskell</a> 的Maybe-内建类型构造器。所以，可识别联合 <code>T+nil_t</code> 可以作为一个概念上的基础。 

-</p>

-<code>variant<T,nil_t></code> 自然而然地可用于扩展可取值的传统惯用法，它增加一个"哨兵"值用于表示空值。不过，这个新增的空值与我们意图大不相关，因为我们的目标是规范化未初始化对象的概念，虽然一个特殊的扩展值可以用于表达这个意思，但是它并不是严格必要的。

-最近的研究表明，额外的 <code>nil_t</code> 对于 <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code> 的 目的-是无关的，我们建议另一种模型：一个容器，它具有 <code class="computeroutput"><spanclass="identifier">T</code> 的值，或者为空。 

-在写这篇文档之时，我还不知道有任何一个大小可变、容量固定(为1)、基于栈的optional-值的容器模型的先例，但是我相信这只是因为还没有这样一个容器的实际实现，而不是这样一个容器模型的固有缺点。

-无论如何，可识别联合或单元素容器模型均可作为表示 optional 类 -- 即可能未初始化的 -- 对象的基础。 

-例如，这些模型表现出了一个

-optional 值包装器所需的准确语义：

-
-<p>可识别联合：</p>
-
-<blockquote>
-  <li><b>深复制</b> 语义：variant 的拷贝即为值的拷贝。
-  </li>
-  <li><b>深比较</b> 语义：比较两个 variants 要同时匹配类型和值。
-  </li>

- <li>如果 variant 的当前类型为 T, 它就代表已初始化的

-optional.
-  </li>

- <li>如果 variant 的当前类型不是 T, 它就代表未初始化的

-optional.
-  </li>
-  <li>测试 variant 的当前类型是否为 T 即测试 optional 是否已初始化。
-  </li>

- <li>试图从一个 variant 取出 T 而它的当前类型不是 T 时，正好符合了访问一个未初始化 optional 值的未定义行为。

-  </li>
-</blockquote>
-
-<p>单元素容器：</p>
-
-<blockquote>
-  <li><b>深复制</b> 语义：container 的拷贝即为值的拷贝。
-  </li>

- <li>深比较 语义：比较两个 containers 要先比较容器的大小，如果匹配再比较容器中的值。

-  </li>

- <li>如果 container 非空(包含一个类型为 T 的对象)，它就代表<spanstyle="font-style: italic;">已初始化的 optional.

-  </li>

- <li>如果 container 为空，它就代表未初始化的 optional.

-  </li>
-  <li>测试&nbsp;container&nbsp;是否为空即测试 optional 是否已初始化。
-  </li>

- <li>试图从一个空的 container 取出 T，正好符合了访问一个未初始化 optional值的未定义行为。 

-  </li>
-</blockquote>
-</div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">
-<a name="boost_optional.development.the_semantics"></a>语义
-</h3>
-</div>
-</div>
-</div>
-

-类型 <code>optional<T></code> 的对象的设计意图是，用在那些使用可能未被初始化的类型 <code class="computeroutput"><spanclass="identifier">T</code>

-的对象的地方。因此，<code>optional&lt;T&gt;</code>

-的意图是对增加可能的未初始化状态进行规范化。从这一任务的观点出发，<code>optional<T></code> 可以具有与 <codeclass="computeroutput">T</code>-相同的操作语义，再加上与特殊状态相对应的额外语义。同样，<code>optional<T></code> 可被视为 <codeclass="computeroutput">T</code> 的一个-超类型supertype. 当然，我们不能在C++中这样做，所以我们需要用一种不同的机制来得到想要的语义。使用其它方法实现它，如让-<code>optional<T></code> 作为 <code class="computeroutput"><spanclass="identifier">T</code> 的-子类，不仅是概念上的错误，而且也是不实际的：因为不允许从非类类型派生，如从内建类型派生。

-我们可以从 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> 的目的描画出所需的基本语义：

-<div class="itemizedlist">
-<ul type="disc">
-
-  <li>
-    <b>缺省构造：</b>引入一个正式的未初始化包装对象。
+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.development.the_semantics"></a><a class="link"href="development.html#boost_optional.development.the_semantics" title="Thesemantics 语义"> The semantics

+      &#35821;&#20041;</a>
+</h3></div></div></div>
+<p>

+ Objects of type <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ are intended to be used in places where objects of type <codeclass="computeroutput">T</code>+ would but which might be uninitialized. Hence, <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>'s+ purpose is to formalize the additional possibly uninitializedstate. From+ the perspective of this role, <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ can have the same operational semantics of <codeclass="computeroutput">T</code>+ plus the additional semantics corresponding to this special state.As such,+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> could+ be thought of as a <spanclass="emphasis">supertype of <codeclass="computeroutput">T</code>.+ Of course, we can't do that in C++, so we need to compose thedesired semantics+ using a different mechanism. Doing it the other way around, thatis, making+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> a+ subtype of <codeclass="computeroutput">T</code>+ is not only conceptually wrong but also impractical: it is notallowed to+ derive from a non-class type, such as a built-in type. 类型 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>的对象的设计意图是，用在那些使用可能未被初始化的类型+ <code class="computeroutput"><spanclass="identifier">T</code>的对象的地方。因此，<code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>的意图是对增加可能的未初始化状态进行规范化。+从这一任务的观点出发，<codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ 可以具有与 <codeclass="computeroutput">T</code>相同的操作语义，再加上与特殊状态相对应的额外语义。+ 同样，<code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>可被视为+ <code class="computeroutput"><spanclass="identifier">T</code> 的一个 <spanclass="emphasis">超类型.+当然，我们不能在C++中这样做，所以我们需要用一种不同的机制来得到想要的语义。+使用其它方法实现它，如让<code class="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ 作为 <code class="computeroutput"><spanclass="identifier">T</code> 的 <spanclass="emphasis">子类，不仅是概念上的错误，而且也是不实际的：+因为不允许从非类类型派生，如从内建类型派生。

+      </p>
+<p>

+ We can draw from the purpose of <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ the required basic semantics: 我们可以从 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+的目的描画出所需的基本语义：

+      </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+Default Construction: Tointroduce a formally+ uninitialized wrapped object. <spanclass="bold">缺省构造：引入一个正式的未初始化包装对象。

         </li>
-
-  <li>

- 通过复制进行直接的值构造：引入一个正式的已初始化包装对象，其值来自于某个对象的拷贝。

+<li>

+Direct Value Construction viacopy: To+ introduce a formally initialized wrapped object whose value isobtained+ as a copy of some object. <spanclass="bold">通过复制进行直接的值构造：引入一个正式的已初始化包装对象，其值来自于某个对象的拷贝。

         </li>
-
-  <li>
-    <b>深复制构造：</b>获得一个新的、等价的包装对象。
+<li>

+Deep Copy Construction: Toobtain a new+ yet equivalent wrapped object. <spanclass="bold">深复制构造：获得一个新的、等价的包装对象。

         </li>
-
-  <li>
-    <b>直接的值赋值(到已初始化的对象)：</b>将一个值赋值到包装对象。
+<li>

+Direct Value Assignment (uponinitialized):+ To assign a value to the wrapped object. <spanclass="bold">直接的值赋值(到已初始化的对象)：将一个值赋值到包装对象。

         </li>
-
-  <li>

- 直接的值赋值(到未初始化的对象)：从某个对象的拷贝取得值，初始化包装对象。

+<li>

+Direct Value Assignment (uponuninitialized):+ To initialize the wrapped object with a value obtained as a copyof some+ object. <spanclass="bold">直接的值赋值(到未初始化的对象)：从某个对象的拷贝取得值，初始化包装对象。

         </li>
-
-  <li>
-    <b>赋值(到已初始化的对象)：</b>将另一个包装对象的值赋值到包装对象。
+<li>

+Assignment (upon initialized):To assign+ to the wrapped object the value of another wrappedobject. <spanclass="bold">赋值(到已初始化的对象)：将另一个包装对象的值赋值到包装对象。

         </li>
-
-  <li>
-    <b>赋值(到未初始化的对象)：</b>以另一个包装对象的值初始化包装对象。
+<li>

+Assignment (uponuninitialized): To initialize+ the wrapped object with value of another wrappedobject. <spanclass="bold">赋值(到未初始化的对象)：以另一个包装对象的值初始化包装对象。

         </li>
-
-  <li>

- 深比较操作(仅当被类型T支持时)：比较两个包装对象的值，包括未初始化状态的情形。

+<li>

+Deep Relational Operations (when supported bythe+ type T): To compare wrapped object values takinginto account+ the presence of uninitialized states. <spanclass="bold">深比较操作(仅当被类型T支持时)：比较两个包装对象的值，包括未初始化状态的情形。

         </li>
-
-  <li>
-    <b>值访问：</b>对包装对象去包装。
+<li>

+Value access: To unwrap thewrapped object. <spanclass="bold">值访问：对包装对象去包装。

         </li>
-
-  <li>
-    <b>初始化状态查询：</b>判断该对象是否已正式初始化。
+<li>

+Initialization state query: Todetermine+ if the object is formally initialized or not. <spanclass="bold">初始化状态查询：判断该对象是否已正式初始化。

         </li>
-
-  <li>

- 交换：交换包装的对象。(无论 T 的交换操作提供何种异常安全性保证)。

+<li>

+Swap: To exchange wrappedobjects. (with+ whatever exception safety guarantees are provided by <codeclass="computeroutput">T</code>'s+ swap). <spanclass="bold">交换：交换包装的对象。(无论+ <code class="computeroutput"><spanclass="identifier">T</code>的交换操作提供何种异常安全性保证)。

         </li>
-
-  <li>
-    <b>去初始化：</b>释放包装的对象(如果有)，并使包装器保留未初始化状态。
+<li>

+De-initialization: To releasethe wrapped+ object (if any) and leave the wrapper in the uninitializedstate. <spanclass="bold">去初始化：释放包装的对象(如果有)，并使包装器保留未初始化状态。

         </li>
-
-</ul>
-</div>
-

-其它操作也是有用的，如转换构造函数和转换赋值，就地构造和赋值，以及通过包装对象的一个指针或空指针进行安全的值访问。 

+</ul></div>
+<p>

+ Additional operations are useful, such as converting constructorsand converting+ assignments, in-place construction and assignment, and safe valueaccess+ via a pointer to the wrapped object or null. 其它操作也是有用的，如转换构造函数和转换赋值，就地构造和赋值，以及通过包装对象的一个指针或空指针进行安全的值访问。

       </p>
-
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<a name="boost_optional.development.the_interface"></a><a class="link"href="development.html#boost_optional.development.the_interface" title="TheInterface">接口</a>

-</h3>
-</div>
-</div>
-</div>
-

-由于 optional 的目的是允许我们使用增加了正式的未初始化状态的对象，所以它的接口应该尽可能跟随底层的类型 <code class="computeroutput"><spanclass="identifier">T</code>. 为了选择适当的原本的 T-接口，应该留意以下几点：即使被类型 <code class="computeroutput"><spanclass="identifier">T</code> 的实例所支持的所有操作是为该类的整个值域所定义的，但是 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>

-将该值域扩充了一个新值，所以多数操作对此没有定义。</p>

-此外，由于 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> 本身只不过是一个 <code class="computeroutput"><spanclass="identifier">T</code> 的包装(类似于 T-的一个超类)，任何针对未初始化的 optional 的操作定义都应完全与 <codeclass="computeroutput">T</code> 相关。-本库所选择的接口是，沿用 <code class="computeroutput"><spanclass="identifier">T</code>-的接口，只要那些操作是有良好定义的(与类型 <codeclass="computeroutput">T</code>-有关)，即使某些操作数未初始化。这样的操作包括有：构造，复制构造，赋值，交换和比较操作。-对于值访问操作，如果操作数是未初始化的，则是未定义的(与类型 <codeclass="computeroutput">T</code>

-有关)，所以选用了不同的接口(稍后将会解释)。</p>

-还有，未初始化状态的可能出现需要有更多的操作，这些操作是 <codeclass="computeroutput">T</code>

-本身所不具备的，它们将以特定的接口提供。</p>

-<aname="boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_"></a>

-<h5>

-<a name="id2636515"></a> <a class="link"href="development.html#boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt_">对可能未初始化的 optional 对象的带提示的值访问：操作符 * 和 -></a>

+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.development.the_interface"></a><a class="link"href="development.html#boost_optional.development.the_interface" title="TheInterface 接口"> The Interface

+      &#25509;&#21475;</a>
+</h3></div></div></div>
+<p>

+ Since the purpose of optional is to allow us to use objects with aformal+ uninitialized additional state, the interface could try to followthe interface+ of the underlying <code class="computeroutput"><spanclass="identifier">T</code> type+ as much as possible. In order to choose the proper degree ofadoption of+ the native <code class="computeroutput"><spanclass="identifier">T</code> interface, the+ following must be noted: Even if all the operations supported byan instance+ of type <code class="computeroutput"><spanclass="identifier">T</code> are defined for+ the entire range of values for such a type, an <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ extends such a set of values with a new value for which most(otherwise valid)+ operations are not defined in terms of <codeclass="computeroutput">T</code>. + 由于 optional的目的是允许我们使用增加了正式的未初始化状态的对象，所以它的接口应该尽可能跟随底层的类型+ <code class="computeroutput"><spanclass="identifier">T</code>.为了选择适当的原本的+ <code class="computeroutput"><spanclass="identifier">T</code>接口，应该留意以下几点：即使被类型+ <code class="computeroutput"><spanclass="identifier">T</code>的实例所支持的所有操作是为该类的整个值域所定义的，+ 但是 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>将该值域扩充了一个新值，所以很多(对其它值有效的)操作对该值没有定义。

+      </p>
+<p>

+ Furthermore, since <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ itself is merely a <code class="computeroutput"><spanclass="identifier">T</code> wrapper+ (modeling a <code class="computeroutput"><spanclass="identifier">T</code> supertype),+ any attempt to define such operations upon uninitialized optionalswill be+ totally artificial w.r.t. <code class="computeroutput"><spanclass="identifier">T</code>. + 此外，由于 <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ 本身只不过是一个<code class="computeroutput">T</code>+ 的包装(类似于 <codeclass="computeroutput">T</code>的一个超类)，任何针对未初始化的+ optional的操作定义都应完全与<code class="computeroutput">T</code>

+        &#30456;&#20851;&#12290;
+      </p>
+<p>

+ This library chooses an interface which follows from <codeclass="computeroutput">T</code>'s+ interface only for those operations which are well defined (w.r.tthe type+ <code class="computeroutput"><spanclass="identifier">T</code>) even if any of the operands+ are uninitialized. These operations include: construction,copy-construction,+ assignment, swap and relational operations. 本库所选择的接口是，沿用+ <code class="computeroutput"><spanclass="identifier">T</code>的接口，只要那些操作是有良好定义的(与类型+ <code class="computeroutput"><spanclass="identifier">T</code>有关)，即使某些操作数未初始化。+这样的操作包括有：构造，复制构造，赋值，交换和比较操作。

+      </p>
+<p>

+ For the value access operations, which are undefined (w.r.t thetype <code class="computeroutput">T</code>)when the operand is uninitialized, a+ different interface is chosen (which will be explained next). 对于值访问操作，如果操作数是未初始化的，则是未定义的(与类型+ <code class="computeroutput"><spanclass="identifier">T</code>有关)，所以选用了不同的接口(稍后将会解释)。

+      </p>
+<p>

+ Also, the presence of the possibly uninitialized state requiresadditional+ operations not provided by <code class="computeroutput"><spanclass="identifier">T</code>+ itself which are supported by a special interface. 还有，未初始化状态的可能出现需要有更多的操作，这些操作是+ <code class="computeroutput"><spanclass="identifier">T</code>本身所不具备的，它们将以特定的接口提供。

+      </p>

+<aname="boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt__sbr_____________________________optional____________________________________________________gt_"></a><h5>

+<a name="id4860008"></a>

+ <a class="link"href="development.html#boost_optional.development.the_interface.lexically_hinted_value_access_in_the_presence_of_possibly_untitialized_optional_objects__the_operators___and___gt__sbr_____________________________optional____________________________________________________gt_">Lexically-hinted+ Value Access in the presence of possibly untitialized optionalobjects: The+ operators * and -> 对可能未初始化的 optional对象的带提示的值访问：操作符

+        * &#21644; -&gt;</a>
       </h5>
-

-指针的一个特点是它可以具有 空指针值。这是一个特殊值，用于表示该指针没有指向任何对象。换句话说，空指针值表达的意思是不存在的对象。

-
-<p>空指针值的这个意义使得指针成为了处理 optional

-对象的事实标准，因为当你要引向一个实际上不存在的值时，你要做的只是使用适当类型的空指针值。指针已经被使用了几十年 -- 从 C APIs 一直到现代的 C++ 库--- 用来表示 optional (即可能不存在的)对象；尤其是用作函数的可选参数，但也常被用作可选数据成员。

-空指针值的可能出现使得访问被指物值的操作可能是无定义的，所以，使用提领和访问操作符的表达式，如 <code>( *p = 2 )</code> 和-<code>( p->foo())</code>, 暗含了可选性的概念，此类信息被表达式的语法所依赖。即，操作符 <code class="computeroutput"><spanclass="special">*</code> 和 <code class="computeroutput"><spanclass="special">-></code> 本身 ---无需任何额外的上下文 --就说明了该表达式可以是无定义的，除非被指物确实存在。

-这个表示 optional 对象的事实上的惯用法可以用一个概念来规范化：<ahref="../../../../utility/OptionalPointee.html">OptionalPointee</a> 概念。该概念包含了操作符 <code class="computeroutput"><spanclass="special">*</code>, <code class="computeroutput"><spanclass="special">-></code> 以及转换到 <codeclass="computeroutput">bool</code> 的语法，以表达可选性的概念。

-
-<p>虽然指针适合于表示 optional 对象，但是并不特别适合处理 optional

-对象的其它方面，如初始化或移动/复制。问题主要在于指针语义的浅复制：如果你需要高效地移动或复制对象，那么仅有指针是不够的。问题是指针的拷贝并不代表被指物的拷贝。例如，象在"动机"一节中所讨论的，仅用指针并不能从一个函数返回

-optional
-对象，因为该对象必须从函数中移至外部，进入调用者的上下文。</p>

-解决浅复制问题的一个常用方法是，采用动态分配并使用智能指针来自动处理其细节。例如，如果一个函数可选性地返回一个对象-X, 则可以使用 <code class="computeroutput"><spanclass="identifier">shared_ptr<<spanclass="identifier">X></code>- 作为返回值。不过，这要求对 <code class="computeroutput"><spanclass="identifier">X</code> 进行动态分配。如果 <codeclass="computeroutput">X</code> 是内建的或是小的 POD,-该技术在资源方面很不划算。Optional 对象本质上是值对象，所以，如果可以象我们处理普通的值对象那样，使用自动存储和深复制语义来维护 optional-值，才是最方便的。指针不具有这种语义，所以不适于初始化和转移 optional值，但还是非常适合于访问有可能无定义的值，因为该用法已存在于以指针为代表的<a href="../../../../utility/OptionalPointee.html"target="_top">OptionalPointee</a> 概念中。-<aname="boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee"></a>

-<h5>
-<a name="id2636825"></a>

- <a class="link"href="development.html#boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee">Optional<T>作为 OptionalPointee 的模型</a>

+<p>

+ A relevant feature of a pointer is that it can have a <spanclass="bold">null+ pointer value. This is a <spanclass="emphasis">special value which+ is used to indicate that the pointer is not referring to anyobject at all.+ In other words, null pointer values convey the notion ofinexistent objects. +指针的一个特点是它可以具有<spanclass="bold">空指针值。这是一个<spanclass="emphasis">特殊值，用于表示该指针没有指向任何对象。+换句话说，空指针值表达的意思是不存在的对象。

+      </p>
+<p>

+ This meaning of the null pointer value allowed pointers to becamea de+ facto standard for handling optional objects becauseall you have+ to do to refer to a value which you don't really have is to use anull pointer+ value of the appropriate type. Pointers have been used fordecades—from+ the days of C APIs to modern C++ libraries—to <spanclass="emphasis">refer+ to optional (that is, possibly inexistent) objects; particularlyas optional+ arguments to a function, but also quite often as optional datamembers. +空指针值的这个意义使得指针成为了处理optional 对象的<spanclass="emphasis">事实标准，因为当你要引向一个实际上不存在的值时，+你要做的只是使用适当类型的空指针值。指针已经被使用了几十年+ — 从 C APIs一直到现代的 C++ 库 —用来表示+ optional(即可能不存在的)对象；尤其是用作函数的可选参数，但也常被用作可选数据成员。

+      </p>
+<p>

+ The possible presence of a null pointer value makes the operationsthat access+ the pointee's value possibly undefined, therefore, expressionswhich use+ dereference and access operators, such as: <codeclass="computeroutput">(+ *p= 2 <spanclass="special">)</code>+ and <code class="computeroutput">(p-><spanclass="identifier">foo() <spanclass="special">)</code>, implicitly+ convey the notion of optionality, and this information is tied tothe syntax+ of the expressions. That is, the presence of operators <codeclass="computeroutput">*</code>+ and <code class="computeroutput"><spanclass="special">-></code> tell by themselves+ —without any additional context— that the expressionwill be undefined+ unless the implied pointee actually exist. 空指针值的可能出现使得访问被指物值的操作可能是无定义的，所以，使用提领和访问操作符的表达式，+ 如 <code class="computeroutput"><spanclass="special">( *<spanclass="identifier">p = <spanclass="number">2+ )</code> 和 <codeclass="computeroutput">(+ p<spanclass="special">->foo<spanclass="special">() )</code>,暗含了可选性的概念，此类信息被表达式的<spanclass="emphasis">语法所依赖。+ 即，操作符 <codeclass="computeroutput">*</code> 和 <codeclass="computeroutput">-></code>本身 —无需任何额外的上下文+ —就说明了该表达式可以是无定义的，除非被指物确实存在。

+      </p>
+<p>

+ Such a de facto idiom forreferring to optional objects+ can be formalized in the form of a concept: the <ahref="../../../../utility/OptionalPointee.html"target="_top">OptionalPointee</a>+ concept. This concept captures the syntactic usage of operators<code class="computeroutput">*</code>, <codeclass="computeroutput">-></code>+ and conversion to <code class="computeroutput"><spanclass="keyword">bool</code> to convey+ the notion of optionality. 这个表示optional 对象的<spanclass="emphasis">事实上的惯用法可以用一个概念来规范化：<ahref="../../../../utility/OptionalPointee.html"target="_top">OptionalPointee</a> 概念。+该概念包含了操作符<code class="computeroutput">*</code>,+ <code class="computeroutput"><spanclass="special">-></code>以及转换到 <code class="computeroutput"><spanclass="keyword">bool</code>的语法，以表达可选性的概念。

+      </p>
+<p>
+        However, pointers are good to <span class="underline">refer</span>

+ to optional objects, but not particularly good to handle theoptional objects+ in all other respects, such as initializing or moving/copyingthem. The problem+ resides in the shallow-copy of pointer semantics: if you need toeffectively+ move or copy the object, pointers alone are not enough. Theproblem is that+ copies of pointers do not imply copies of pointees. For example,as was discussed+ in the motivation, pointers alone cannot be used to returnoptional objects+ from a function because the object must move outside from thefunction and+ into the caller's context. 虽然指针适合于<spanclass="underline">表示+ optional对象，但是并不特别适合处理optional对象的其它方面，如初始化或移动/复制。+问题主要在于指针语义的浅复制：如果你需要高效地移动或复制对象，那么仅有指针是不够的。问题是指针的拷贝并不代表被指物的拷贝。+例如，象在"动机"一节中所讨论的，仅用指针并不能从一个函数返回+ optional对象，因为该对象必须从函数中移至外部，进入调用者的上下文。

+      </p>
+<p>

+ A solution to the shallow-copy problem that is often used is toresort to+ dynamic allocation and use a smart pointer to automatically handlethe details+ of this. For example, if a function is to optionally return anobject <code class="computeroutput"><spanclass="identifier">X</code>, it can use <codeclass="computeroutput">shared_ptr<spanclass="special"><X<spanclass="special">></code>+ as the return value. However, this requires dynamic allocation of<code class="computeroutput">X</code>. If<code class="computeroutput">X</code>+ is a built-in or small POD, this technique is very poor in termsof required+ resources. Optional objects are essentially values so it is veryconvenient+ to be able to use automatic storage and deep-copy semantics tomanipulate+ optional values just as we do with ordinary values. Pointers donot have+ this semantics, so are inappropriate for the initialization andtransport+ of optional values, yet are quite convenient for handling theaccess to the+ possible undefined value because of the idiomatic aid present inthe <a href="../../../../utility/OptionalPointee.html"target="_top">OptionalPointee</a> concept+ incarnated by pointers. 解决浅复制问题的一个常用方法是，采用动态分配并使用智能指针来自动处理其细节。+例如，如果一个函数可选性地返回一个对象<code class="computeroutput">X</code>,+ 则可以使用 <codeclass="computeroutput">shared_ptr<spanclass="special"><X<spanclass="special">></code>+ 作为返回值。不过，这要求对 <codeclass="computeroutput">X</code>+进行动态分配。如果<code class="computeroutput">X</code>+ 是内建的或是小的POD,该技术在资源方面很不划算。Optional+对象本质上是值对象，所以，如果可以象我们处理普通的值对象那样，使用自动存储和深复制语义来维护+ optional值，才是最方便的。指针不具有这种语义，所以不适于初始化和转移+ optional值，但还是非常适合于访问有可能无定义的值，+因为该用法已存在于以指针为代表的<a href="../../../../utility/OptionalPointee.html"target="_top">OptionalPointee</a>

+        &#27010;&#24565;&#20013;&#12290;
+      </p>

+<aname="boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee__optional_lt_t_gt_______optionalpointee_________"></a><h5>

+<a name="id4860604"></a>

+ <a class="link"href="development.html#boost_optional.development.the_interface.optional_lt_t_gt__as_a_model_of_optionalpointee__optional_lt_t_gt_______optionalpointee_________">Optional<T>+ as a model of OptionalPointeeOptional<T>作为OptionalPointee的模型</a>

       </h5>
-

-对于值访问操作，<code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code> 使用操作符 <codeclass="computeroutput">*</code> 和 <codeclass="computeroutput">-></code>

-来提醒有可能出现的未初始化状态，这类似于指针语义中的空指针用法。<br>
-</p>
-<div class="warning">
-<table summary="Warning" border="0">
-
-  <tbody>
-    <tr>
-

- <td rowspan="2" align="center" valign="top" width="25"><imgalt="[Warning]" src="../../../../../doc/html/images/warning.png"></td>

-
-      <th align="left">警告</th>
-
-    </tr>
-
-    <tr>
-      <td align="left" valign="top">

- 但是，要重点留意的是，<code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code> 对象不是指针。<spanclass="underline"><code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code> 不是也不符合指针的概念。

-        </p>
-      </td>
-    </tr>
-
-  </tbody>
-</table>
+<p>

+ For value access operations <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code> uses operators <codeclass="computeroutput">*</code>+ and <code class="computeroutput"><spanclass="special">-></code> to lexically warn+ about the possibly uninitialized state appealing to the familiarpointer+ semantics w.r.t. to null pointers. 对于值访问操作，<codeclass="computeroutput">optional<spanclass="special"><></code>+ 使用操作符 <codeclass="computeroutput">*</code> 和 <codeclass="computeroutput">-></code>来提醒有可能出现的未初始化状态，这类似于指针语义中的空指针用法。

+      </p>
+<div class="warning"><table border="0" summary="Warning">
+<tr>

+<td rowspan="2" align="center" valign="top" width="25"><imgalt="[Warning]" src="../../../../../doc/html/images/warning.png"></td>

+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top"><p>

+ However, it is particularly important to note that <codeclass="computeroutput">optional<spanclass="special"><></code> objects are not pointers. <spanclass="underline"><code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code> is not, and does not model, apointer. +但是，要重点留意的是，<codeclass="computeroutput">optional<spanclass="special"><></code>对象不是指针。<spanclass="underline"><code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>不是也不符合指针的概念。

+        </p></td></tr>
+</table></div>
+<p>

+ For instance, <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>+ does not have shallow-copy so does not alias: two differentoptionals never+ refer to the same valueunless <code class="computeroutput">T</code>+ itself is a reference (but may have <spanclass="emphasis">equivalent values).+ The difference between an <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>+ and a pointer must be kept in mind, particularly because thesemantics of+ relational operators are different: since <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ is a value-wrapper, relational operators are deep: they compareoptional+ values; but relational operators for pointers are shallow: they donot compare+ pointee values. As a result, you might be able to replace <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code>+ by <code class="computeroutput"><spanclass="identifier">T*</code>+ on some situations but not always. Specifically, on generic codewritten+ for both, you cannot use relational operators directly, and mustuse the+ template functions <ahref="../../../../utility/OptionalPointee.html#equal" target="_top"><codeclass="computeroutput">equal_pointees<spanclass="special">()</code></a>+ and <a href="../../../../utility/OptionalPointee.html#less"target="_top"><code class="computeroutput"><spanclass="identifier">less_pointees<spanclass="special">()</code></a>+ instead. 例如，<codeclass="computeroutput">optional<spanclass="special"><></code>没有浅复制，所以也没有别名：两个不同的+ optional 永远不会引向<spanclass="emphasis">同一个值，除非 <code class="computeroutput"><spanclass="identifier">T</code>本身是一个引用(但可以有<spanclass="emphasis">相等的值)。必须注意+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>和指针间的区别，特别是因为它们的比较操作符的语义是不同的：+ 因为 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>是一个值包装器，比较操作符是"深"的：它们比较+ optional的值；而指针的比较操作符则是"浅"的：+它们不比较被指物的值。所以，你也许可以在某些情形下用+ <code class="computeroutput"><spanclass="identifier">T*</code>+ 替换 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T<spanclass="special">></code>，但并不是总可以这样做。+特别是，在为两者所写的泛型代码中，你不能直接使用比较操作符，而必须使用模板函数+ <a href="../../../../utility/OptionalPointee.html#equal"target="_top"><code class="computeroutput"><spanclass="identifier">equal_pointees<spanclass="special">()</code></a> 和 <ahref="../../../../utility/OptionalPointee.html#less" target="_top"><codeclass="computeroutput">less_pointees<spanclass="special">()</code></a>

+        &#26469;&#20195;&#26367;&#12290;
+      </p>
 </div>
-

-例如，<code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>- 没有浅复制，所以也没有别名：两个不同的 optional 永远不会引向同一个值，除非 <code class="computeroutput">T</code> 本身是一个引用(但可以有相等的值)。必须注意 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> 和指针间的区别，特别是因为它们的比较操作符的语义是不同的：因为 <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">></code> 是一个值包装器，比较操作符是"深"的：它们比较 optional-的值；而指针的比较操作符则是"浅"的：它们不比较被指物的值。所以，你也许可以在某些情形下用 <code class="computeroutput"><spanclass="identifier">T*</code>-替换 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>，但并不是总可以这样做。特别是，在为两者所写的泛型代码中，你不能直接使用比较操作符，而必须使用模板函数 <ahref="../../../../utility/OptionalPointee.html#equal" target="_top"><codeclass="computeroutput">equal_pointees<spanclass="special">()</code></a> 和 <ahref="../../../../utility/OptionalPointee.html#less" target="_top"><codeclass="computeroutput">less_pointees<spanclass="special">()</code></a> 来代替。 

-</p>
 </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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
-</body></html>
+</body>
+</html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/examples.html Thu Sep 419:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/examples.html Wed Mar 2400:54:49 2010

@@ -1,119 +1,68 @@
-<!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="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="detailed_semantics.html" title="DetailedSemantics">

- <link rel="next" href="optional_references.html" title="Optionalreferences">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Examples &#20363;&#23376;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="detailed_semantics.html" title="Detailed Semantics详细语义">+<link rel="next" href="optional_references.html" title="Optionalreferences Optional引用">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="detailed_semantics.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="optional_references.html"><imgsrc="../../../../../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_optional.examples"></a><a class="link" href="examples.html"title="Examples">例子</a>

-</h2>
-</div>
-</div>
-</div>
-
-<div class="toc">
-<dl>
-

- <dt><ahref="examples.html#boost_optional.examples.optional_return_values">Optional

-      返回值</a></span></dt>
-

- <dt><ahref="examples.html#boost_optional.examples.optional_local_variables">Optional

-      局部变量</a></span></dt>
-

- <dt><ahref="examples.html#boost_optional.examples.optional_data_members">Optional

-      数据成员</a></span></dt>
-

- <dt><ahref="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">避免不必要的昂贵的缺省构造</a></dt>

-
-</dl>
-</div>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.examples"></a><a class="link" href="examples.html"title="Examples 例子"> Examples 例子</a>

+</h2></div></div></div>
+<div class="toc"><dl>

+<dt><ahref="examples.html#boost_optional.examples.optional_return_values">Optional

+      return values Optional&#36820;&#22238;&#20540;</a></span></dt>

+<dt><ahref="examples.html#boost_optional.examples.optional_local_variables">Optional+ local variablesOptional局部变量</a></dt>+<dt><ahref="examples.html#boost_optional.examples.optional_data_members"> Optional

+      data members Optional&#25968;&#25454;&#25104;&#21592;</a></span></dt>

+<dt><ahref="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">+ Bypassing expensive unnecessary default construction避免不必要的昂贵的缺省构造</a></dt>

+</dl></div>
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<a name="boost_optional.examples.optional_return_values"></a><aclass="link"href="examples.html#boost_optional.examples.optional_return_values"title="Optional return values">Optional

-      返回值</a>
-</h3>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.examples.optional_return_values"></a><aclass="link"href="examples.html#boost_optional.examples.optional_return_values"title="Optional return values Optional返回值"> Optional

+      return values Optional&#36820;&#22238;&#20540;</a>
+</h3></div></div></div>

<pre class="programlisting">optional<spanclass="special"><char<spanclass="special">> <spanclass="identifier">get_async_input()

 <span class="special">{</span>

if ( <spanclass="special">!queue<spanclass="special">.empty<spanclass="special">() )return <spanclass="identifier">optional<<spanclass="keyword">char>(<spanclass="identifier">queue.<spanclass="identifier">top());- else returnoptional<spanclass="special"><char<spanclass="special">>(); // 未初始化 }+ else returnoptional<spanclass="special"><char<spanclass="special">>(); // uninitialized未初始化

+</span><span class="special">}</span>

void <spanclass="identifier">receive_async_message<spanclass="special">()

 <span class="special">{</span>

optional<spanclass="special"><char<spanclass="special">> rcv <spanclass="special">;- // 此处使用了从 'rcv' 到布尔值的安全转换。 while <spanclass="special">( (<spanclass="identifier">rcv = <spanclass="identifier">get_async_input())&& !<spanclass="identifier">timeout() <spanclass="special">)+ // The safe boolean conversion from 'rcv' isused here.+ //此处使用了从 'rcv'到布尔值的安全转换。+ while <spanclass="special">( (<spanclass="identifier">rcv = <spanclass="identifier">get_async_input())&& !<spanclass="identifier">timeout() <spanclass="special">)output<spanclass="special">(*rcv<spanclass="special">);

 <span class="special">}</span>
 </pre>
-
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<a name="boost_optional.examples.optional_local_variables"></a><aclass="link"href="examples.html#boost_optional.examples.optional_local_variables"title="Optional local variables">Optional

-      局部变量</a>
-</h3>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.examples.optional_local_variables"></a><aclass="link"href="examples.html#boost_optional.examples.optional_local_variables"title="Optional local variables Optional局部变量">Optional

+      local variables Optional&#23616;&#37096;&#21464;&#37327;</a>
+</h3></div></div></div>

<pre class="programlisting">optional<spanclass="special"><string<spanclass="special">> name <spanclass="special">;if ( <spanclass="identifier">database.<spanclass="identifier">open() <spanclass="special">)

 <span class="special">{</span>
@@ -129,33 +78,27 @@

print<spanclass="special">(*name<spanclass="special">);else <spanclass="identifier">print(<spanclass="string">"employer's name not found!"<spanclass="special">);

 </pre>
-
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<a name="boost_optional.examples.optional_data_members"></a><aclass="link"href="examples.html#boost_optional.examples.optional_data_members"title="Optional data members">Optional

-      数据成员</a>
-</h3>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h3 class="title">

+<a name="boost_optional.examples.optional_data_members"></a><aclass="link"href="examples.html#boost_optional.examples.optional_data_members"title="Optional data members Optional数据成员">Optional

+      data members Optional&#25968;&#25454;&#25104;&#21592;</a>
+</h3></div></div></div>

<pre class="programlisting">class <spanclass="identifier">figure

 <span class="special">{</span>
     <span class="keyword">public</span><span class="special">:</span>

     <span class="identifier">figure</span><span class="special">()</span>
     <span class="special">{</span>

- // 此处数据成员 'm_clipping_rect' 未初始化。 }+ // data member 'm_clipping_rect' isuninitialized at this point.+ //此处数据成员 'm_clipping_rect'未初始化。

+</span>    <span class="special">}</span>

void <spanclass="identifier">clip_in_rect ( <spanclass="identifier">rect const<spanclass="special">& rect <spanclass="special">)

     <span class="special">{</span>
         <span class="special">....</span>

- m_clipping_rect<spanclass="special">.reset <spanclass="special">( rect <spanclass="special">) ; <spanclass="comment">// 此处初始化。 }+ m_clipping_rect<spanclass="special">.reset <spanclass="special">( rect <spanclass="special">) ; <spanclass="comment">// initialized here.此处初始化。

+</span>    <span class="special">}</span>

void draw( canvas<spanclass="special">& cvs <spanclass="special">)

     <span class="special">{</span>
@@ -165,7 +108,8 @@

cvs<spanclass="special">.drawXXX<spanclass="special">(..);

     <span class="special">}</span>

- // 可以返回 NULL. <spanclass="identifier">rect const<spanclass="special">* <spanclass="identifier">get_clipping_rect(){ return <spanclass="identifier">get_pointer(<spanclass="identifier">m_clipping_rect);}+ // this can return NULL.可以返回 NULL.+ rect <spanclass="keyword">const* <spanclass="identifier">get_clipping_rect(){ return <spanclass="identifier">get_pointer(<spanclass="identifier">m_clipping_rect);}


     <span class="keyword">private</span> <span class="special">:</span>

@@ -173,20 +117,12 @@

 <span class="special">};</span>
 </pre>
-
 </div>
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h3 class="title">

-<aname="boost_optional.examples.bypassing_expensive_unnecessary_default_construction"></a><aclass="link"href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction"title="Bypassing expensive unnecessary default construction">避免不必要的昂贵的缺省构造</a>

-</h3>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h3 class="title">

+<aname="boost_optional.examples.bypassing_expensive_unnecessary_default_construction"></a><aclass="link"href="examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction"title="Bypassing expensive unnecessary default construction避免不必要的昂贵的缺省构造">+ Bypassing expensive unnecessary default construction避免不必要的昂贵的缺省构造</a>

+</h3></div></div></div>

<pre class="programlisting">class <spanclass="identifier">ExpensiveCtor {... } <spanclass="special">;

 <span class="keyword">class</span> <span class="identifier">Fred</span>
 <span class="special">{</span>
@@ -195,35 +131,19 @@

std<spanclass="special">::vector<spanclass="special">< optional<spanclass="special"><<spanclass="identifier">ExpensiveCtor>> <spanclass="identifier">mLargeVector ;

 <span class="special">}</span> <span class="special">;</span>
 </pre>
-
 </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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

---/trunk/libs/optional/doc/html/boost_optional/exception_safety_guarantees.htmlThu Sep 4 19:32:19 2008+++/trunk/libs/optional/doc/html/boost_optional/exception_safety_guarantees.htmlWed Mar 24 00:54:49 2010

@@ -1,119 +1,93 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Exception Safety Guarantees</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="a_note_about_optional_bool_.html" title="A noteabout optional<bool>">

-
-  <link rel="next" href="type_requirements.html" title="Type requirements">
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">

+<title>Exception Safety Guarantees异常安全性保证</title>

+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="a_note_about_optional_bool_.html" title="A noteabout optional<bool>关于optional<bool>的说明">+<link rel="next" href="type_requirements.html" title="Type requirements类型要求">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="a_note_about_optional_bool_.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="type_requirements.html"><imgsrc="../../../../../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_optional.exception_safety_guarantees"></a><a class="link"href="exception_safety_guarantees.html" title="Exception SafetyGuarantees">异常安全性保证</a>

-</h2>
-</div>
-</div>
-</div>
-

-由于当前的实现(请见 <ahref="../index.html#optional_implementation_notes">实现说明</a>)，所有赋值方法：

+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.exception_safety_guarantees"></a><a class="link"href="exception_safety_guarantees.html" title="Exception Safety Guarantees异常安全性保证"> Exception+ Safety Guarantees异常安全性保证</a>

+</h2></div></div></div>
+<p>

+ Because of the current implementation (see <a class="link"href="implementation_notes.html" title="Implementation Notes实现说明">Implementation+ Notes</a>), all of the assignment methods: 由于当前的实现(请见+ <a class="link" href="implementation_notes.html"title="Implementation Notes实现说明">实现说明</a>)，所有赋值方法：

     </p>
-
-<div class="itemizedlist">
-<ul type="disc">
-

- <li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="keyword">operator= <spanclass="special">( optional<spanclass="special"><T<spanclass="special">>

+<div class="itemizedlist"><ul type="disc">

         <span class="special">)</span></code></li>
-

- <li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="keyword">operator= <spanclass="special">( T <spanclass="keyword">const& <spanclass="special">)</code></li>

- <li><code class="computeroutput"><spanclass="keyword">template<<spanclass="keyword">class U<spanclass="special">> optional<spanclass="special"><T<spanclass="special">>::operator<spanclass="special">= ( <spanclass="identifier">optional<<spanclass="identifier">U>+<li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="keyword">operator= <spanclass="special">( T <spanclass="keyword">const& <spanclass="special">)</code></li>+<li><code class="computeroutput"><spanclass="keyword">template<<spanclass="keyword">class U<spanclass="special">> optional<spanclass="special"><T<spanclass="special">>::operator<spanclass="special">= ( <spanclass="identifier">optional<<spanclass="identifier">U>const<spanclass="special">&

         <span class="special">)</span></code></li>
-

         <span class="special">)</span></code></li>
-

         <span class="special">)</span> </code></li>
-

- <li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>:::<spanclass="identifier">reset ( <spanclass="identifier">T const<spanclass="special">&)</code></li>

-
-</ul>
-</div>
-

-不提供任何超过 <code>T::operator=( T const& )</code> 所提供的<spanstyle="text-decoration: underline;">异常安全性保证。<code></code>

-只能保证基本的异常安全性：如果有异常被抛出，则左值 optional 将保持为 未初始化- (原来的值会首先用 <codeclass="computeroutput">T<spanclass="special">::~T<spanclass="special">()</code> 销毁)。+<li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>:::<spanclass="identifier">reset ( <spanclass="identifier">T const<spanclass="special">&)</code></li>

+</ul></div>
+<p>

+ Can only guarantee the <spanclass="underline">basic+ exception safety: The lvalue optional is left <spanclass="underline">uninitialized+ if an exception is thrown (any previous value is <spanclass="emphasis">first+ destroyed using <code class="computeroutput"><spanclass="identifier">T::~<spanclass="identifier">T()</code>) + 只能<spanclass="emphasis">保证<spanclass="underline">基本的异常安全性：如果有异常被抛出，则左值+ optional 将保持为 <spanclass="underline">未初始化(原来的值会<spanclass="emphasis">首先用+ <code class="computeroutput">T<spanclass="special">::~T<spanclass="special">()</code> 销毁)。

     </p>
-
-<p>另一方面，<span style="font-style: italic;">去初始化</span>方法：
+<p>

+ On the other hand, the <spanclass="emphasis">uninitializing methods: 另一方面，<spanclass="emphasis">去初始化方法：

     </p>
-
-<div class="itemizedlist">
-<ul type="disc">
-

- <li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="keyword">operator= <spanclass="special">( detail<spanclass="special">::none_t <spanclass="special">)</code></li>

-
-</ul>
-</div>
-

-提供了无抛出保证(假定 <code class="computeroutput"><spanclass="identifier">T::~<spanclass="identifier">T()</code> 是无抛出的)。

+<div class="itemizedlist"><ul type="disc">

+<li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="keyword">operator= <spanclass="special">( detail<spanclass="special">::none_t <spanclass="special">)</code></li>+<li><code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="identifier">reset()</code></li>

+</ul></div>
+<p>

+ Provide the no-throw guarantee (assuming a no-throw <codeclass="computeroutput">T<spanclass="special">::~T<spanclass="special">()</code>) +提供了无抛出保证(假定<code class="computeroutput">T<spanclass="special">::~T<spanclass="special">()</code>

+      &#26159;&#26080;&#25243;&#20986;&#30340;)&#12290;
     </p>
-

-不过，由于 <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>- 本身不抛出任何异常，所以在这里异常的唯一来源是 <codeclass="computeroutput">T</code> 的构造函数，如果你知道 <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T (- T <spanclass="keyword">const& <spanclass="special">)</code> 的异常安全性保证，那么你就可以知道 <codeclass="computeroutput">optional</code> 的赋值和重置都具有相同的保证。

+<p>

+ However, since <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>+ itself doesn't throw any exceptions, the only source for exceptionshere are+ <code class="computeroutput"><spanclass="identifier">T</code>'s constructor, so if you+ know the exception guarantees for <code class="computeroutput"><spanclass="identifier">T::<spanclass="identifier">T (+ T <spanclass="keyword">const& <spanclass="special">)</code>, you+ know that <code class="computeroutput"><spanclass="identifier">optional</code>'s assignment+ and reset has the same guarantees. 不过，由于 <code class="computeroutput"><spanclass="identifier">optional<spanclass="special"><></code>本身不抛出任何异常，所以在这里异常的唯一来源是+ <code class="computeroutput"><spanclass="identifier">T</code>的构造函数，如果你知道+ <code class="computeroutput">T<spanclass="special">::T <spanclass="special">( T

+      <span class="keyword">const</span><span class="special">&amp;</span>

+ )</code>的异常安全性保证，那么你就可以知道+ <code class="computeroutput"><spanclass="identifier">optional</code>的赋值和重置都具有相同的保证。

     </p>
-

-<pre class="programlisting">// <spanclass="comment">// Case 1: 在赋值时抛出异常。 <spanclass="comment">// T <spanclass="identifier">v0(<spanclass="number">123);

+<pre class="programlisting"><span class="comment">//
+</span><span class="comment">// Case 1: Exception thrown during assignment.

+// Case 1:在赋值时抛出异常。

+</span><span class="comment">//

+T <spanclass="identifier">v0(<spanclass="number">123);optional<spanclass="special"><T<spanclass="special">> opt0<spanclass="special">(v0<spanclass="special">);

 <span class="keyword">try</span>
 <span class="special">{</span>
@@ -121,67 +95,72 @@

optional<spanclass="special"><T<spanclass="special">> opt1<spanclass="special">(v1<spanclass="special">);opt0 =opt1 ;

- // 如果没有异常抛出，则赋值成功。 assert( <spanclass="special">*opt0 <spanclass="special">== v1 <spanclass="special">) ;+ // If no exception was thrown, assignmentsucceeded.+ //如果没有异常抛出，则赋值成功。+ assert<spanclass="special">( *<spanclass="identifier">opt0 == <spanclass="identifier">v1 ) <spanclass="special">;

 <span class="special">}</span>
 <span class="keyword">catch</span><span class="special">(...)</span>
 <span class="special">{</span>

- // 如果有任何异常抛出，则 'opt0' 被重置为未初始化。 assert<spanclass="special">( !<spanclass="identifier">opt0 ) <spanclass="special">;+ // If any exception was thrown, 'opt0' is resetto uninitialized.+ //如果有任何异常抛出，则 'opt0'被重置为未初始化。+ assert<spanclass="special">( !<spanclass="identifier">opt0 ) <spanclass="special">;

 <span class="special">}</span>

-// // Case 2: 在reset(v) 时抛出异常 // <spanclass="identifier">T v0<spanclass="special">(123<spanclass="special">);

+<span class="comment">//
+</span><span class="comment">// Case 2: Exception thrown during reset(v)

+// Case 2: 在 reset(v)时抛出异常

+</span><span class="comment">//

+T <spanclass="identifier">v0(<spanclass="number">123);optional<spanclass="special"><T<spanclass="special">> opt<spanclass="special">(v0<spanclass="special">);

 <span class="keyword">try</span>
 <span class="special">{</span>

T <spanclass="identifier">v1(<spanclass="number">456);opt.<spanclass="identifier">reset ( <spanclass="identifier">v1 ) <spanclass="special">;

- // 如果没有异常抛出，则重置成功。 assert( <spanclass="special">*opt <spanclass="special">== v1 <spanclass="special">) ;

+    <span class="comment">// If no exception was thrown, reset succeeded.

+ //如果没有异常抛出，则重置成功。+ assert<spanclass="special">( *<spanclass="identifier">opt == <spanclass="identifier">v1 ) <spanclass="special">;

 <span class="special">}</span>
 <span class="keyword">catch</span><span class="special">(...)</span>
 <span class="special">{</span>

- // 如果有任何异常抛出，则 'opt' 被重置为未初始化。 assert<spanclass="special">( !<spanclass="identifier">opt ) <spanclass="special">;+ // If any exception was thrown, 'opt' is resetto uninitialized.+ //如果有任何异常抛出，则 'opt'被重置为未初始化。+ assert<spanclass="special">( !<spanclass="identifier">opt ) <spanclass="special">;

 <span class="special">}</span>
 </pre>
-
-<a name="boost_optional.exception_safety_guarantees.swap"></a>
-<h4>
-<a name="id2664646"></a>

- <a class="link"href="exception_safety_guarantees.html#boost_optional.exception_safety_guarantees.swap">交换</a>

+<a name="boost_optional.exception_safety_guarantees.swap_______"></a><h4>
+<a name="id4894853"></a>

+ <a class="link"href="exception_safety_guarantees.html#boost_optional.exception_safety_guarantees.swap_______">Swap

+      &#20132;&#25442;</a>
     </h4>
-
 <p>

<code class="computeroutput">void <spanclass="identifier">swap( <spanclass="identifier">optional<<spanclass="identifier">T>&,- optional<spanclass="special"><T<spanclass="special">>& )</code> 在两个 optional 均已初始化时，具有与 <code>swap(T&,T&)</code> 相同的异常保证。如果只有一个-optional 是已初始化的，则它提供与 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="identifier">reset( <spanclass="identifier">T const<spanclass="special">& )</code> 一样的基本异常保证(因为 <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">>::reset<spanclass="special">( T <spanclass="keyword">const& <spanclass="special">)</code> 不会抛出)。如果两个 optional

-均未初始化，则它具有无抛出保证，因为这是一个空操作。

+ optional<spanclass="special"><T<spanclass="special">>& )</code> hasthe same exception guarantee as <code class="computeroutput"><spanclass="identifier">swap(<spanclass="identifier">T&,<spanclass="identifier">T&)</code>+ when both optionals are initialized. If only one of the optionals isinitialized,+ it gives the same basicexception guarantee as <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="identifier">reset( <spanclass="identifier">T const<spanclass="special">& )</code> (since+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="identifier">reset()</code>doesn't throw). If none of the optionals+ is initialized, it has no-throw guarantee since it is a no-op. <code class="computeroutput">void <spanclass="identifier">swap( <spanclass="identifier">optional<<spanclass="identifier">T>&,+ optional<spanclass="special"><T<spanclass="special">>& )</code>在两个 <code class="computeroutput"><spanclass="identifier">optional</code>+均已初始化时，具有与<code class="computeroutput">swap<spanclass="special">(T<spanclass="special">&,T<spanclass="special">&)</code>相同的异常保证。+ 如果只有一个 <codeclass="computeroutput">optional</code>+是已初始化的，则它提供与<code class="computeroutput">optional<spanclass="special"><T<spanclass="special">>::reset<spanclass="special">( T

+      <span class="keyword">const</span><span class="special">&amp;</span>

+ )</code> 一样的<spanclass="emphasis">基本异常保证+ (因为 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T>::<spanclass="identifier">reset( <spanclass="identifier">T const<spanclass="special">& )</code>不会抛出)。如果两个+ <code class="computeroutput"><spanclass="identifier">optional</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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/implementation_notes.htmlThu Sep 4 19:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/implementation_notes.htmlWed Mar 24 00:54:49 2010

@@ -1,96 +1,63 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Implementation Notes</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

-
-  <link rel="prev" href="type_requirements.html" title="Type requirements">
-

- <link rel="next" href="dependencies_and_portability.html"title="Dependencies and Portability">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Implementation Notes &#23454;&#29616;&#35828;&#26126;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="type_requirements.html" title="Type requirements类型要求">+<link rel="next" href="dependencies_and_portability.html"title="Dependencies and Portability依赖性和可移植性">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="type_requirements.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="dependencies_and_portability.html"><imgsrc="../../../../../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_optional.implementation_notes"></a><a class="link"href="implementation_notes.html" title="Implementation Notes">实现说明</a>

-</h2>
-</div>
-</div>
-</div>
-
-
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.implementation_notes"></a><a class="link"href="implementation_notes.html" title="Implementation Notes实现说明"> Implementation Notes

+    &#23454;&#29616;&#35828;&#26126;</a>
+</h2></div></div></div>
 <p>

- <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T> </code>当前的实现使用了一个由 <code>alignment_of</code> 和<code>type_with_alignment</code> (均来自-Type Traits)构建的定制对齐存储工具。它使用一个独立的布尔标志来标识初始化状态。带有 <code class="computeroutput"><spanclass="identifier">T</code> 的复制构造函数的 Placement new 以及 <code class="computeroutput">T</code>的析构函数被显式用于初始化、复制和销毁 optional 的值。这样可以有效地绕过 <code class="computeroutput">T</code>-的缺省构造函数，但是异常保证只能是基本的。有计划用其它具有更强异常安全性的方法来替代当前的实现，如未来的 <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">variant</code>.+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code> is+ currently implemented using a custom aligned storage facility builtfrom <code class="computeroutput"><spanclass="identifier">alignment_of</code> and <codeclass="computeroutput"><spanclass="identifier">type_with_alignment</code>+ (both from Type Traits). It uses a separate boolean flag to indicatethe initialization+ state. Placement new with <code class="computeroutput"><spanclass="identifier">T</code>'s+ copy constructor and <code class="computeroutput"><spanclass="identifier">T</code>'s destructor+ are explicitly used to initialize,copy and destroy optional values.As a result,+ <code class="computeroutput"><spanclass="identifier">T</code>'s default constructor is+ effectively by-passed, but the exception guarantees are basic. It isplanned+ to replace the current implementation with another with strongerexception+ safety, such as a future <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">variant</code>. + <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T></code>当前的实现使用了一个由+ <code class="computeroutput"><spanclass="identifier">alignment_of</code> 和 <codeclass="computeroutput"><spanclass="identifier">type_with_alignment</code>(均来自 TypeTraits)构建的定制对齐存储工具。+它使用一个独立的布尔标志来标识初始化状态。带有<code class="computeroutput">T</code>的复制构造函数的 Placementnew+ 以及 <code class="computeroutput"><spanclass="identifier">T</code>的析构函数被显式用于初始化、+ 复制和销毁 optional的值。这样可以有效地绕过<code class="computeroutput">T</code>的缺省构造函数，但是异常保证只能是基本的。+有计划用其它具有更强异常安全性的方法来替代当前的实现，如未来的+ <code class="computeroutput"><spanclass="identifier">boost::<spanclass="identifier">variant</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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/in_place_factories.htmlThu Sep 4 19:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/in_place_factories.htmlWed Mar 24 00:54:49 2010

@@ -1,65 +1,42 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>In-Place Factories</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">

- <link rel="next" href="a_note_about_optional_bool_.html" title="A noteabout optional<bool>">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>In-Place Factories &#23601;&#22320;&#21019;&#24314;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">+<link rel="next" href="a_note_about_optional_bool_.html" title="A noteabout optional<bool>关于optional<bool>的说明">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="rebinding_semantics_for_assignment_of_optional_references.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="a_note_about_optional_bool_.html"><imgsrc="../../../../../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_optional.in_place_factories"></a><a class="link"href="in_place_factories.html" title="In-Place Factories">就地创建</a>

-</h2>
-</div>
-</div>
-</div>
-

-使用包装器和容器的一个常见问题是，它们通常会有一个接口提供一个操作，将所含对象初始化或赋值为另一个对象的拷贝。这不仅要求底层的类型是 <ahref="../../../../utility/CopyConstructible.html">可复制构造的</a>，而且还要求一个完全构造的对象，该对象通常是临时的，仅用作复制的来源： 

+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.in_place_factories"></a><a class="link"href="in_place_factories.html" title="In-Place Factories就地创建"> In-Place Factories

+    &#23601;&#22320;&#21019;&#24314;</a>
+</h2></div></div></div>
+<p>

+ One of the typical problems with wrappers and containers is thattheir interfaces+ usually provide an operation to initialize or assign the containedobject as+ a copy of some other object. This not only requires the underlyingtype to+ be <a href="../../../../utility/CopyConstructible.html"target="_top">Copy Constructible</a>,+ but also requires the existence of a fully constructed object, oftentemporary,+ just to follow the copy from: 使用包装器和容器的一个常见问题是，它们通常会有一个接口提供一个操作，将所含对象初始化或赋值为另一个对象的拷贝。+这不仅要求底层的类型是<a href="../../../../utility/CopyConstructible.html" target="_top">Copy+Constructible</a>，而且还要求一个完全构造的对象，该对象通常是临时的，仅用作复制的来源：

     </p>
-

<pre class="programlisting">struct <spanclass="identifier">X

 <span class="special">{</span>

X ( <spanclass="keyword">int, <spanclass="identifier">std:::<spanclass="identifier">string ) <spanclass="special">;

@@ -76,14 +53,17 @@

void foo<spanclass="special">()

 <span class="special">{</span>

- // 创建临时对象 <spanclass="identifier">W ( <spanclass="identifier">X(<spanclass="number">123,<spanclass="string">"hello") <spanclass="special">) ;+ // Temporary object created.创建临时对象+ W <spanclass="special">( X<spanclass="special">(123<spanclass="special">,"hello"<spanclass="special">) ) <spanclass="special">;

 <span class="special">}</span>
 </pre>
-
 <p>

- 解决这一问题的一种方法是，提供在容器的存储中直接构造所含对象的支持。这样一来，用户只需要将相关参数提供给构造函数，用于所含对象的构造。+ A solution to this problem is to support direct construction of thecontained+ object right in the container's storage. In this scheme, the useronly needs+ to supply the arguments to the constructor to use in the wrappedobject construction. +解决这一问题的一种方法是，提供在容器的存储中直接构造所含对象的支持。+这样一来，用户只需要将相关参数提供给构造函数，用于所含对象的构造。

     </p>
-

<pre class="programlisting">class <spanclass="identifier">W

 <span class="special">{</span>

X <spanclass="identifier">wrapped_ ;

@@ -96,18 +76,30 @@

void foo<spanclass="special">()

 <span class="special">{</span>

- // 就地创建所含对象，不再需要创建临时对象。 <spanclass="identifier">W (<spanclass="number">123,<spanclass="string">"hello") <spanclass="special">;

+    <span class="comment">// Wrapped object constructed in-place
+</span>    <span class="comment">// No temporary created.

+ //就地创建所含对象，不再需要创建临时对象。+ W <spanclass="special">(123<spanclass="special">,"hello"<spanclass="special">) ;

 <span class="special">}</span>
 </pre>
-

-这种方法的限制在于，它不适用于带有多个构造函数的被包装对象，也不适用于对构造函数重载不知情的泛型代码。

-在本库中，解决的方法是 InPlaceFactories 和TypedInPlaceFactories-家族。这些工厂是一族类，这些类封装了不同参数数量的构造函数参数，提供一个方法来构造给定类型的一个对象，构造时使用这些被封装的参数，并通过

-placement new 在用户指定的地址进行构造。</p>
-
-<p>例如，这个类族中的其中一个类如下：<br>
-</p>
+<p>

+ A limitation of this method is that it doesn't scale well to wrappedobjects+ with multiple constructors nor to generic code were the constructoroverloads+ are unknown. 这种方法的限制在于，它不适用于带有多个构造函数的被包装对象，也不适用于对构造函数重载不知情的泛型代码。

+    </p>
+<p>

+ The solution presented in this library is the family of <spanclass="bold">InPlaceFactories+ and <spanclass="bold">TypedInPlaceFactories. These factories+ are a family of classes which encapsulate an increasing number ofarbitrary+ constructor parameters and supply a method to construct an object ofa given+ type using those parameters at an address specified by the user viaplacement+ new. 在本库中，解决的方法是InPlaceFactories+ 和 <spanclass="bold">TypedInPlaceFactories家族。这些工厂是一族类，这些类封装了不同参数数量的构造函数参数，提供一个方法来构造给定类型的一个对象，+构造时使用这些被封装的参数，并通过placement new在用户指定的地址进行构造。

+    </p>
+<p>

+ For example, one member of this family looks like: 例如，这个类族中的其中一个类如下：

+    </p>

 <span class="special">{</span>
@@ -120,10 +112,9 @@

void <spanclass="identifier">construct ( <spanclass="keyword">void* <spanclass="identifier">p ) <spanclass="special">{ new <spanclass="special">(p<spanclass="special">) T<spanclass="special">(m_a0<spanclass="special">,m_a1<spanclass="special">) ; <spanclass="special">}

  <span class="special">}</span> <span class="special">;</span>
 </pre>
-
-<p>一个包装类可以这样来使用它：
+<p>

+ A wrapper class aware of this can use it as: 一个包装类可以这样来使用它：

     </p>
-

<pre class="programlisting">class <spanclass="identifier">W

 <span class="special">{</span>

X <spanclass="identifier">wrapped_ ;

@@ -136,33 +127,47 @@

void foo<spanclass="special">()

 <span class="special">{</span>

- // 通过 TypedInPlaceFactory 就地构造被包装对象。无需创建临时对象。 <spanclass="identifier">W ( <spanclass="identifier">TypedInPlaceFactory2<spanclass="special"><X<spanclass="special">,int<spanclass="special">,std<spanclass="special">::string<spanclass="special">&rt<spanclass="special">(123<spanclass="special">,"hello"<spanclass="special">)) ;+ // Wrapped object constructed in-place via aTypedInPlaceFactory.

+</span>    <span class="comment">// No temporary created.

+ // 通过 TypedInPlaceFactory就地构造被包装对象。无需创建临时对象。+ W <spanclass="special">( <spanclass="identifier">TypedInPlaceFactory2<spanclass="special"><X<spanclass="special">,int<spanclass="special">,std<spanclass="special">::string<spanclass="special">>(123<spanclass="special">,"hello"<spanclass="special">)) ;

 <span class="special">}</span>
 </pre>
-
-<p>这些工厂类被分为两组：</p>
-
-<ul>
-  <li><u>TypedInPlaceFactories</u>: 它们以目标类型作为主模板参数。
-  </li>

- <li>InPlaceFactories: 它们以模板化的<code>construct(void*)</code> 成员函数来接受目标类型。

-  </li>
-</ul>
-
-<p>在每一组中，所有类族成员仅在可接受的参数数量上有所不同。</p>
-

-本库还提供了一组重载的模板函数来构造这些工厂类，从而无需给定模板参数： 

-</p>
+<p>

+ The factories are divided in two groups: 这些工厂类被分为两组：

+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>
+<span class="underline">TypedInPlaceFactories</span>: those which

+ take the target type as a primary template parameter. <spanclass="underline">TypedInPlaceFactories:+它们以目标类型作为主模板参数。

+      </li>
+<li>
+<span class="underline">InPlaceFactories</span>: those with a template

+ <code class="computeroutput"><spanclass="identifier">construct(<spanclass="keyword">void*)</code> member+ function taking the target type. <spanclass="underline">InPlaceFactories:+ 它们以模板化的 <codeclass="computeroutput">construct<spanclass="special">(void<spanclass="special">*)</code>+成员函数来接受目标类型。

+      </li>
+</ul></div>
+<p>

+ Within each group, all the family members differ only in the numberof parameters+ allowed. 在每一组中，所有类族成员仅在可接受的参数数量上有所不同。

+    </p>
+<p>

+ This library provides an overloaded set of helper template functionsto construct+ these factories without requiring unnecessary templateparameters: 本库还提供了一组重载的模板函数来构造这些工厂类，从而无需给定模板参数：

+    </p>

<pre class="programlisting">template<spanclass="special"><class <spanclass="identifier">A0,...,<spanclass="keyword">class AN<spanclass="special">>InPlaceFactoryN <spanclass="special"><A0<spanclass="special">,...,AN<spanclass="special">> in_place <spanclass="special">( A0 <spanclass="keyword">const& <spanclass="identifier">a0, <spanclass="special">..., AN <spanclass="keyword">const& <spanclass="identifier">aN) <spanclass="special">;

template<spanclass="special"><class <spanclass="identifier">T,<spanclass="keyword">class A0<spanclass="special">,...,class <spanclass="identifier">AN>TypedInPlaceFactoryN <spanclass="special"><T<spanclass="special">,A0<spanclass="special">,...,AN<spanclass="special">> in_place <spanclass="special">( T <spanclass="keyword">const& <spanclass="identifier">a0, <spanclass="identifier">A0 const<spanclass="special">& a0<spanclass="special">, ..., <spanclass="identifier">AN const<spanclass="special">& aN<spanclass="special">) ;

 </pre>
-
-<p>就地创建可以被包装器和用户泛型地使用，如下：
+<p>

+ In-place factories can be used generically by the wrapper and useras follows: +就地创建可以被包装器和用户泛型地使用，如下：

     </p>
-

<pre class="programlisting">class <spanclass="identifier">W

 <span class="special">{</span>

X <spanclass="identifier">wrapped_ ;

@@ -178,40 +183,31 @@

void foo<spanclass="special">()

 <span class="special">{</span>

- // 通过 InPlaceFactory 就地构造被包装的对象。无需创建临时对象。 <spanclass="identifier">W ( <spanclass="identifier">in_place(<spanclass="number">123,<spanclass="string">"hello") <spanclass="special">) ;+ // Wrapped object constructed in-place via aInPlaceFactory.

+</span>    <span class="comment">// No temporary created.

+ // 通过 InPlaceFactory就地构造被包装的对象。无需创建临时对象。+ W <spanclass="special">( in_place<spanclass="special">(123<spanclass="special">,"hello"<spanclass="special">) ) <spanclass="special">;

 <span class="special">}</span>
 </pre>
-

-这些工厂类在头文件 <ahref="../../../../../boost/utility/in_place_factory.hpp"target="_top">in_place_factory.hpp</a> 和 <ahref="../../../../../boost/utility/typed_in_place_factory.hpp"target="_top">typed_in_place_factory.hpp</a><ahref="../../../boost/utility/typed_in_place_factory.hpp"></a>

-中实现。
+<p>

+ The factories are implemented in the headers: <ahref="../../../../../boost/utility/in_place_factory.hpp"target="_top">in_place_factory.hpp</a>+ and <ahref="../../../../../boost/utility/typed_in_place_factory.hpp"target="_top">typed_in_place_factory.hpp</a> +这些工厂类在头文件 <ahref="../../../../../boost/utility/in_place_factory.hpp"target="_top">in_place_factory.hpp</a>+ 和 <ahref="../../../../../boost/utility/typed_in_place_factory.hpp"target="_top">typed_in_place_factory.hpp</a>

+      &#20013;&#23454;&#29616;&#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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/optional_references.htmlThu Sep 4 19:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/optional_references.htmlWed Mar 24 00:54:49 2010

@@ -1,161 +1,91 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-  <title>Optional references</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

-
-
-

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

-
-
-
-  <link rel="prev" href="examples.html" title="Examples">
-
-
-

- <link rel="next"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Optional references Optional&#24341;&#29992;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

+<link rel="prev" href="examples.html" title="Examples &#20363;&#23376;">

+<link rel="next"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

-
-

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

-
-

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

-
-

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="rebinding_semantics_for_assignment_of_optional_references.html"><imgsrc="../../../../../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_optional.optional_references"></a><a class="link"href="optional_references.html" title="Optional references">Optional 引用</a>

-</h2>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.optional_references"></a><a class="link"href="optional_references.html" title="Optional referencesOptional引用"> Optional references

+    Optional&#24341;&#29992;</a>
+</h2></div></div></div>
+<p>

+ This library allows the template parameter <codeclass="computeroutput">T</code>+ to be of reference type: <code class="computeroutput"><spanclass="identifier">T&</code>, andto some extent, <code class="computeroutput"><spanclass="identifier">T+ const<spanclass="special">&</code>. + 本库允许模板参数<code class="computeroutput">T</code>+可以是引用类型：<codeclass="computeroutput">T<spanclass="special">&</code>,+ 及其扩展 <code class="computeroutput"><spanclass="identifier">T const<spanclass="special">&</code>.

+    </p>
+<p>

+ However, since references are not real objects some restrictionsapply and+ some operations are not available in this case: 不过，由于引用不是真正的对象，所以有一些限制，有些操作不可使用：

+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+ Converting constructors 转换构造函数

+      </li>
+<li>
+        Converting assignment<br> &#36716;&#25442;&#36171;&#20540;
+      </li>
+<li>
+        InPlace construction<br> &#23601;&#22320;&#26500;&#36896;
+      </li>
+<li>
+        InPlace assignment<br> &#23601;&#22320;&#36171;&#20540;
+      </li>
+<li>

+ Value-access via pointer 通过指针的值访问

+      </li>
+</ul></div>
+<p>

+ Also, even though <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ treats it wrapped pseudo-object much as a real value, a true realreference+ is stored so aliasing will ocurr: 而且，虽然 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+在处理其包装的伪对象时与真正的值对象非常相似，但实际上它保存的是一个真正的引用，所以可能发生以下容易混淆的情况：

+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

+ Copies of <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ will copy the references but all these references will nonethelessreefer+ to the same object. 复制 <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">&></code>+将对引用进行复制，但所有被复制的引用都将引向同一个对象。

+      </li>
+<li>

+ Value-access will actually provide access to the referenced objectrather+ than the reference itself. 值访问操作提供对被引用的对象而不是引用本身的访问。

+      </li>
+</ul></div>
 </div>
-
-</div>
-
-</div>
-
-

-本库允许模板参数 T 可以是引用类型：<code class="computeroutput"><spanclass="identifier">T&</code>, 及其扩展 <code class="computeroutput">T- const<spanclass="special">&</code>.

-
-<p>不过，由于引用不是真正的对象，所以有一些限制，有些操作不可使用：</p>
-
-<ul>
-  <li>转换构造函数
-  </li>
-  <li>转换赋值
-  </li>
-  <li>就地构造
-  </li>
-  <li>就地赋值</li>
-  <li>通过指针的值访问</li>
-</ul>
-

-而且，虽然 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>-在处理其包装的伪对象时与真正的值对象非常相似，但实际上它保存的是一个真正的引用，所以可能发生以下容易混淆的情况： 

-
-<ul>

- <li>复制 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code> 将对引用进行复制，但所有被复制的引用都将引向同一个对象。

-  </li>
-  <li>值访问操作提供对被引用的对象而不是引用本身的访问。<br>
-  </li>
-</ul>
-</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">
-

-
-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-
-      </div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
-
 </body>
 </html>
=======================================

---/trunk/libs/optional/doc/html/boost_optional/rebinding_semantics_for_assignment_of_optional_references.htmlThu Sep 4 19:32:19 2008+++/trunk/libs/optional/doc/html/boost_optional/rebinding_semantics_for_assignment_of_optional_references.htmlWed Mar 24 00:54:49 2010

@@ -1,155 +1,170 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Rebinding semantics for assignment of optional references</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="optional_references.html" title="Optionalreferences">

- <link rel="next" href="in_place_factories.html" title="In-PlaceFactories">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">

+<title>Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义</title>

+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="optional_references.html" title="Optionalreferences Optional引用">+<link rel="next" href="in_place_factories.html" title="In-Place Factories就地创建">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="optional_references.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="in_place_factories.html"><imgsrc="../../../../../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;">

-<aname="boost_optional.rebinding_semantics_for_assignment_of_optional_references"></a><aclass="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional references">optional引用赋值操作的重绑定语义</a>

-</h2>
-</div>
-</div>
-</div>
-

-如果你对一个未初始化的 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>-进行赋值，效果将是将它绑定(对于第一次赋值)到某个对象。显然，这里没有其它的选择。

+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<aname="boost_optional.rebinding_semantics_for_assignment_of_optional_references"></a><aclass="link"href="rebinding_semantics_for_assignment_of_optional_references.html"title="Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义">+ Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义</a>

+</h2></div></div></div>
+<p>

+ If you assign to an uninitialized <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ the effect is to bind (for the first time) to the object. Clearly,there is+ no other choice. 如果你对一个<spanclass="emphasis">未初始化的+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+进行赋值，效果将是将它绑定(对于第一次赋值)到某个对象。显然，这里没有其它的选择。

     </p>
-

<pre class="programlisting">int <spanclass="identifier">x = <spanclass="number">1 ;int& <spanclass="identifier">rx = <spanclass="identifier">x ;optional<spanclass="special"><int<spanclass="special">&> ora <spanclass="special">;optional<spanclass="special"><int<spanclass="special">&> orb<spanclass="special">(x<spanclass="special">) ;-ora = <spanclass="identifier">orb ; <spanclass="comment">// 现在 'ora' 通过 'rx' 被绑定到 'x' <spanclass="special">*ora <spanclass="special">= 2 <spanclass="special">; // 通过 'ora' 修改 'x' 的值 assert<spanclass="special">(x<spanclass="special">==2<spanclass="special">); </pre>

-如果你对一个C++裸引用进行赋值，赋值的操作将被前转至被引用的对象；结果是被引用对象的值被改变而引用本身不会被重绑定。+ora = <spanclass="identifier">orb ; <spanclass="comment">// now 'ora' is bound to 'x' through 'rx'现在'ora'通过'rx'被绑定到'x'+*ora= 2 <spanclass="special">; // Changes value of 'x'through 'ora' 通过'ora'修改'x'的值+assert<spanclass="special">(x<spanclass="special">==2<spanclass="special">);

+</pre>
+<p>

+ If you assign to a bare C++ reference, the assignment is forwardedto the referenced+ object; it's value changes but the reference is never rebound. 如果你对一个C++裸引用进行赋值，赋值的操作将被前转至被引用的对象；结果是被引用对象的值被改变而引用本身不会被重绑定。

     </p>
-

<pre class="programlisting">int <spanclass="identifier">a = <spanclass="number">1 ;int& <spanclass="identifier">ra = <spanclass="identifier">a ;int b <spanclass="special">= 2 <spanclass="special">;int& <spanclass="identifier">rb = <spanclass="identifier">b ;-ra = <spanclass="identifier">rb ; <spanclass="comment">// 修改 'a' 的值为 'b' <spanclass="identifier">assert(<spanclass="identifier">a==<spanclass="identifier">b);+ra = <spanclass="identifier">rb ; <spanclass="comment">// Changes the value of 'a' to 'b'修改'a'的值为'b'+assert<spanclass="special">(a<spanclass="special">==b<spanclass="special">);b = <spanclass="number">3 ;-assert(<spanclass="identifier">ra!=<spanclass="identifier">b); <spanclass="comment">// 'ra' 不会重绑定到 'b' </pre>

-现在，如果你对一个已初始化的 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>-进行赋值，结果将是重绑定到新的对象，而不是对引用物进行赋值。这和C++裸引用是不一样的。+assert(<spanclass="identifier">ra!=<spanclass="identifier">b); <spanclass="comment">// 'ra' is not reboundto 'b' 'ra'不会重绑定到'b'

+</span></pre>
+<p>

+ Now, if you assign to an initialized <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>,+ the effect is to rebindto the new object+ instead of assigning the referee. This is unlike bare C++references. +现在，如果你对一个<spanclass="emphasis">已初始化的<code class="computeroutput">optional<spanclass="special"><T<spanclass="special">&></code>+进行赋值，结果将是<spanclass="bold">重绑定到新的对象，而不是对引用物进行赋值。这和C++裸引用是不一样的。

     </p>
-

<pre class="programlisting">int <spanclass="identifier">a = <spanclass="number">1 ;int b <spanclass="special">= 2 <spanclass="special">;int& <spanclass="identifier">ra = <spanclass="identifier">a ;int& <spanclass="identifier">rb = <spanclass="identifier">b ;optional<spanclass="special"><int<spanclass="special">&> ora<spanclass="special">(ra<spanclass="special">) ;optional<spanclass="special"><int<spanclass="special">&> orb<spanclass="special">(rb<spanclass="special">) ;-ora = <spanclass="identifier">orb ; <spanclass="comment">// 'ora' is rebound to 'b' <spanclass="special">*ora <spanclass="special">= 3 <spanclass="special">; // Changes value of 'b'(not 'a') assert<spanclass="special">(a<spanclass="special">==1<spanclass="special">); assert<spanclass="special">(b<spanclass="special">==3<spanclass="special">); </pre>

-<aname="boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale"></a>

-<h4>
-<a name="id2660242"></a>

- <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html#boost_optional.rebinding_semantics_for_assignment_of_optional_references.rationale">原理</a>+ora = <spanclass="identifier">orb ; <spanclass="comment">// 'ora' is reboundto 'b' 'ora'被重绑定至'a'+*ora= 3 <spanclass="special">; // Changes value of 'b'(not 'a') 修改'b'(而不是'a')的值+assert<spanclass="special">(a<spanclass="special">==1<spanclass="special">);+assert(<spanclass="identifier">b==<spanclass="number">3);

+</pre>

+<aname="boost_optional.rebinding_semantics_for_assignment_of_optional_references._rationale_rationale_______"></a><h4>

+<a name="id4889521"></a>

+ <a class="link"href="rebinding_semantics_for_assignment_of_optional_references.html#boost_optional.rebinding_semantics_for_assignment_of_optional_references._rationale_rationale_______">:rationale

+      Rationale &#21407;&#29702;</a>
     </h4>
-

-对已初始化的 <codeclass="computeroutput">optional</code> 引用的赋值操作的重绑定语义提供了对初始化状态的一致性，这是以违反C++裸引用语义为代价的。确实，<codeclass="computeroutput">optional<spanclass="special"><U<spanclass="special">></code> 尽可能表现得和 <codeclass="computeroutput">U</code> 一样，不论它是否已初始化；但是如果 <code class="computeroutput"><spanclass="identifier">U</code> 是 <code class="computeroutput"><spanclass="identifier">T&</code>, 这样做就会导致和左值初始化状态相关的不一致行为。 

-</p>

-设想 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>- 将赋值操作前转至被引用的对象(修改被引用的对象而不是重绑定)，考虑一下以下代码：

+<p>

+ Rebinding semantics for the assignment of <spanclass="emphasis">initialized + <code class="computeroutput"><spanclass="identifier">optional</code> references has been+ chosen to provide consistency amonginitialization states+ even at the expense of lack of consistency with the semantics ofbare C++ references.+ It is true that <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">U></code> strives+ to behave as much as possible as <code class="computeroutput"><spanclass="identifier">U</code>+ does whenever it is initialized; but in the case when <codeclass="computeroutput">U</code>+ is <code class="computeroutput"><spanclass="identifier">T&</code>,+ doing so would result in inconsistent behavior w.r.t to the lvalueinitialization+ state. 对<spanclass="emphasis">已初始化的<code class="computeroutput">optional</code>+引用的赋值操作的重绑定语义提供了<spanclass="bold">对初始化状态的一致性，这是以违反C++裸引用语义为代价的。+ 确实，<code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">U></code>尽可能表现得和+ <code class="computeroutput"><spanclass="identifier">U</code>一样，不论它是否已初始化；但是如果+ <code class="computeroutput"><spanclass="identifier">U</code> 是 <codeclass="computeroutput">T<spanclass="special">&</code>,这样做就会导致和左值初始化状态相关的不一致行为。

     </p>
-
+<p>

+ Imagine <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ forwarding assignment to the referenced object (thus changing thereferenced+ object value but not rebinding), and consider the followingcode: 设想+ <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+将赋值操作前转至被引用的对象(修改被引用的对象而不是重绑定)，考虑一下以下代码：

+    </p>

<pre class="programlisting">optional<spanclass="special"><int<spanclass="special">&> a <spanclass="special">= get<spanclass="special">();int x <spanclass="special">= 1 <spanclass="special">;int& <spanclass="identifier">rx = <spanclass="identifier">x ;optional<spanclass="special"><int<spanclass="special">&> b<spanclass="special">(rx<spanclass="special">);a = <spanclass="identifier">b ;

 </pre>
-
-<p>这个赋值操作会做什么？
+<p>

+ What does the assignment do? 这个赋值操作会做什么？

     </p>
-

-如果 <code class="computeroutput"><spanclass="identifier">a</code> 是未初始化的，那么答案非常清楚：它将被绑定到 <codeclass="computeroutput">x</code> (这样我们就有了第二个到 <code class="computeroutput"><spanclass="identifier">x</code> 的引用)。但是如果 <codeclass="computeroutput">a</code> 已经<spanstyle="font-style: italic;">初始化了呢？那么这个赋值操作可能会修改被引用对象(无论它是什么)的值，但是这样做就会和在未初始化情形下的行为不一致。-如果 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>- 的赋值只是象 <code class="computeroutput"><spanclass="identifier">T&</code> 那样做，你就永远不能在没有显式处理过原先的已初始化状态的时候使用 Optional 的赋值，除非你的代码能够判断在这个赋值之后，<code class="computeroutput"><spanclass="identifier">a</code> 是 <code class="computeroutput"><spanclass="identifier">b</code>

-      的别名抑或不是。</p>
-<p>即，你不得不为了一致性而进行分别处理。</p>
-

-如果将引用绑定到另一个对象对于你的代码来说是错误的，那么在第一次的时候通过赋值操作来绑定而不是初始化很可能也是错误的。在这种情况下，赋值到一个未初始化的 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code> 应该被禁止。很可能这种情况下前提条件是，左值必须是已初始化的。如果重绑定是错误的而第一次的绑定(通过赋值操作)不是，则你可以用一个辨别操作来避免重绑定语义： 

-</p>
+<p>

+ If <code class="computeroutput"><spanclass="identifier">a</code> is <spanclass="emphasis">uninitialized,+ the answer is clear: it binds to <code class="computeroutput"><spanclass="identifier">x</code>+ (we now have another reference to <code class="computeroutput"><spanclass="identifier">x</code>).+ But what if <code class="computeroutput"><spanclass="identifier">a</code> is already <spanclass="emphasis">initialized?+ it would change the value of the referenced object (whatever thatis); which+ is inconsistent with the other possible case. 如果<code class="computeroutput">a</code>+ 是<spanclass="emphasis">未初始化的，那么答案非常清楚：它将被绑定到+ <code class="computeroutput"><spanclass="identifier">x</code>(这样我们就有了第二个到+ <code class="computeroutput"><spanclass="identifier">x</code> 的引用)。但是如果+ <code class="computeroutput"><spanclass="identifier">a</code> 已经<spanclass="emphasis">初始化了呢？那么这个赋值操作可能会修改被引用对象(无论它是什么)的值，但是这样做就会和在未初始化情形下的行为不一致。

+    </p>
+<p>

+ If <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ would assign just like <code class="computeroutput"><spanclass="identifier">T&</code>+ does, you would never be able to use Optional's assignment withoutexplicitly+ handling the previous initialization state unless your code iscapable of functioning+ whether after the assignment, <code class="computeroutput"><spanclass="identifier">a</code>+ aliases the same object as <code class="computeroutput"><spanclass="identifier">b</code>+ or not. 如果 <code class="computeroutput"><spanclass="identifier">optional<<spanclass="identifier">T&></code>+ 的赋值只是象 <codeclass="computeroutput">T<spanclass="special">&</code>+那样做，你就永远不能在没有显式处理过原先的已初始化状态的时候使用+ Optional 的赋值，除非你的代码能够判断在这个赋值之后，<codeclass="computeroutput">a</code> 是<code class="computeroutput">b</code>

+      &#30340;&#21035;&#21517;&#25233;&#25110;&#19981;&#26159;&#12290;
+    </p>
+<p>

+ That is, you would have to discriminate in order to beconsistency. 即，你不得不为了一致性而进行分别处理。

+    </p>
+<p>

+ If in your code rebinding to another object is not an option, thenis very+ likely that binding for the fist time isn't either. In such case,assignment+ to an uninitialized <codeclass="computeroutput">optional<spanclass="special"><T<spanclass="special">&></code>+ shall be prohibited. It is quite possible that in such scenario theprecondition+ that the lvalue must be already initialized exist. If it doesn't,then binding+ for the first time is OK while rebinding is not which is IMO veryunlikely.+ In such scenario, you can assign the value itself directly, asin: 如果将引用绑定到另一个对象对于你的代码来说是错误的，那么在第一次的时候通过赋值操作来绑定而不是初始化很可能也是错误的。+在这种情况下，赋值到一个<spanclass="emphasis">未初始化的<code class="computeroutput">optional<spanclass="special"><T<spanclass="special">&></code>+应该被禁止。很可能这种情况下前提条件是，左值必须是已初始化的。+若非如此，则第一次的绑定是对的，而重绑定是错误的，这通常不大可能。这种情况下你可以直接向它赋值，如：

+    </p>

<pre class="programlisting">assert<spanclass="special">(!!opt<spanclass="special">);*opt<spanclass="special">=value<spanclass="special">;

 </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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/synopsis.html Thu Sep 419:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/synopsis.html Wed Mar 2400:54:49 2010

@@ -1,62 +1,31 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
 <head>
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-  <title>Synopsis</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

-
-  <link rel="prev" href="development.html" title="Development">
-

- <link rel="next" href="detailed_semantics.html" title="DetailedSemantics">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Synopsis &#25688;&#35201;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="development.html" title="Development发展">+<link rel="next" href="detailed_semantics.html" title="Detailed Semantics详细语义">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="development.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="detailed_semantics.html"><imgsrc="../../../../../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_optional.synopsis"></a><a class="link" href="synopsis.html"title="Synopsis">概要</a>

-</h2>
-</div>
-</div>
-</div>
-
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.synopsis"></a><a class="link" href="synopsis.html"title="Synopsis 摘要"> Synopsis 摘要</a>

+</h2></div></div></div>

<pre class="programlisting">namespace <spanclass="identifier">boost {

template<spanclass="special"><class <spanclass="identifier">T>

@@ -64,14 +33,20 @@
 <span class="special">{</span>
     <span class="keyword">public</span> <span class="special">:</span>

- // (如果 T 是引用类型，则以引用传递的参数和结果变为以值传递) + // (If T is of reference type, the parametersand results by reference are by value)+ // (如果 T是引用类型，则以引用传递的参数和结果变为以值传递)

+</span>

optional <spanclass="special">() ; <a class="link"href="detailed_semantics.html#reference_optional_constructor"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

optional <spanclass="special">( none_t <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_constructor_none_t"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

optional <spanclass="special">( T <spanclass="keyword">const& <spanclass="identifier">v ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- // [1.34版本中新增] <spanclass="identifier">optional ( <spanclass="keyword">bool condition<spanclass="special">, T <spanclass="keyword">const& <spanclass="identifier">v ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_bool_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a> optional( optionalconst& <spanclass="identifier">rhs ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+    <span class="comment">// [new in 1.34]

+ //[1.34版本中新增]+ optional <spanclass="special">( bool <spanclass="identifier">condition, <spanclass="identifier">T const<spanclass="special">& v <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_constructor_bool_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+ optional <spanclass="special">( optional <spanclass="keyword">const& <spanclass="identifier">rhs ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

template<spanclass="special"><class <spanclass="identifier">U> <spanclass="keyword">explicit optional( <spanclass="identifier">optional<<spanclass="identifier">U> <spanclass="keyword">const& <spanclass="identifier">rhs ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_other_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>


@@ -79,16 +54,26 @@

template<spanclass="special"><class <spanclass="identifier">TypedInPlaceFactory<spanclass="special">> explicit <spanclass="identifier">optional ( <spanclass="identifier">TypedInPlaceFactory <spanclass="keyword">const& <spanclass="identifier">f ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_constructor_factory"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">none_t ) <spanclass="special">; <spanclass="identifier">optional& <spanclass="keyword">operator = <spanclass="special">( T <spanclass="keyword">const& <spanclass="identifier">v ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_operator_equal_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>+ optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">none_t ) <spanclass="special">;

+ optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">T const<spanclass="special">& v <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_operator_equal_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">optional const<spanclass="special">& rhs <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_operator_equal_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

template<spanclass="special"><class <spanclass="identifier">U> <spanclass="identifier">optional& <spanclass="keyword">operator = <spanclass="special">( optional<spanclass="special"><U<spanclass="special">> const<spanclass="special">& rhs <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_operator_equal_other_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- template<spanclass="special"><class <spanclass="identifier">InPlaceFactory>optional&operator = <spanclass="special">( InPlaceFactoryconst& <spanclass="identifier">f ) <spanclass="special">; <spanclass="keyword">template<<spanclass="keyword">class <spanclass="identifier">TypedInPlaceFactory<spanclass="special">> optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">TypedInPlaceFactory <spanclass="keyword">const& <spanclass="identifier">f ) <spanclass="special">; Tconst& <spanclass="identifier">get() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>+ template<spanclass="special"><class <spanclass="identifier">InPlaceFactory>optional&operator = <spanclass="special">( InPlaceFactoryconst& <spanclass="identifier">f ) <spanclass="special">;

+ template<spanclass="special"><class <spanclass="identifier">TypedInPlaceFactory<spanclass="special">> optional<spanclass="special">& operator <spanclass="special">= ( <spanclass="identifier">TypedInPlaceFactory <spanclass="keyword">const& <spanclass="identifier">f ) <spanclass="special">;

+ T <spanclass="keyword">const& <spanclass="identifier">get() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>T<spanclass="special">& get<spanclass="special">() ; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- // [1.34版本中新增] <spanclass="identifier">T const<spanclass="special">& <spanclass="identifier">get_value_or( <spanclass="identifier">T const<spanclass="special">& default <spanclass="special">) const <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get_value_or_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a> T <spanclass="keyword">const* <spanclass="keyword">operator ->() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_operator_arrow"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+    <span class="comment">// [new in 1.34]

+ //[1.34版本中新增]+ T <spanclass="keyword">const& <spanclass="identifier">get_value_or( <spanclass="identifier">T const<spanclass="special">& default <spanclass="special">) const <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get_value_or_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+ T <spanclass="keyword">const* <spanclass="keyword">operator ->() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_operator_arrow"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>T*operator ->(); <a class="link"href="detailed_semantics.html#reference_optional_operator_arrow"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

T <spanclass="keyword">const& <spanclass="keyword">operator *() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

@@ -101,12 +86,17 @@

bool <spanclass="keyword">operator!() <spanclass="keyword">const ; <a class="link"href="detailed_semantics.html#reference_optional_operator_not"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>


-    <span class="comment">// 被反对的方法<br></span>

- // (被反对的) <spanclass="keyword">void reset<spanclass="special">() ; <a class="link"href="detailed_semantics.html#reference_optional_reset"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- // (被反对的) <spanclass="keyword">void reset <spanclass="special">( T <spanclass="keyword">const& <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_optional_reset_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

- // (被反对的) <spanclass="keyword">bool <spanclass="identifier">is_initialized()const ; <aclass="link"href="detailed_semantics.html#reference_optional_is_initialized"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+    <span class="comment">// deprecated methods

+ //停用的方法

+</span>
+    <span class="comment">// (deprecated)

+ void <spanclass="identifier">reset() <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_reset"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+
+    <span class="comment">// (deprecated)

+ void <spanclass="identifier">reset ( <spanclass="identifier">T const<spanclass="special">& ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_reset_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+
+    <span class="comment">// (deprecated)

+ bool <spanclass="identifier">is_initialized()const ; <aclass="link"href="detailed_semantics.html#reference_optional_is_initialized"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>


 <span class="special">};</span>

@@ -122,11 +112,19 @@

template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline bool <spanclass="keyword">operator >= <spanclass="special">( optional<spanclass="special"><T<spanclass="special">> const<spanclass="special">& x<spanclass="special">, optional<spanclass="special"><T<spanclass="special">> const<spanclass="special">& y <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_operator_compare_greater_or_equal_optional_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

-// [1.34版本中新增] <spanclass="keyword">template<<spanclass="keyword">class T<spanclass="special">> inline <spanclass="identifier">T const<spanclass="special">& <spanclass="identifier">get_optional_value_or <spanclass="special">( optional<spanclass="special"><T<spanclass="special">> const<spanclass="special">& opt<spanclass="special">, T <spanclass="keyword">const& <spanclass="keyword">default ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get_value_or_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a> template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline T <spanclass="keyword">const& <spanclass="identifier">get ( <spanclass="identifier">optional<<spanclass="identifier">T> <spanclass="keyword">const& <spanclass="identifier">opt ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+<span class="comment">// [new in 1.34]

+//[1.34版本中新增]+template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline optional<spanclass="special"><T<spanclass="special">> make_optional( T <spanclass="keyword">const& <spanclass="identifier">v ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_make_optional_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+
+<span class="comment">// [new in 1.34]

+//[1.34版本中新增]+template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline optional<spanclass="special"><T<spanclass="special">> make_optional( bool <spanclass="identifier">condition, <spanclass="identifier">T const<spanclass="special">& v <spanclass="special">) ; <a class="link"href="detailed_semantics.html#reference_make_optional_bool_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+
+<span class="comment">// [new in 1.34]

+//[1.34版本中新增]+template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline T <spanclass="keyword">const& <spanclass="identifier">get_optional_value_or <spanclass="special">( optional<spanclass="special"><T<spanclass="special">> const<spanclass="special">& opt<spanclass="special">, T <spanclass="keyword">const& <spanclass="keyword">default ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get_value_or_value"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

+template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline T <spanclass="keyword">const& <spanclass="identifier">get ( <spanclass="identifier">optional<<spanclass="identifier">T> <spanclass="keyword">const& <spanclass="identifier">opt ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_optional_get"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>


@@ -140,34 +138,20 @@

template<spanclass="special"><class <spanclass="identifier">T> <spanclass="keyword">inline void <spanclass="identifier">swap( <spanclass="identifier">optional<<spanclass="identifier">T>& <spanclass="identifier">x, <spanclass="identifier">optional<<spanclass="identifier">T>& <spanclass="identifier">y ) <spanclass="special">; <a class="link"href="detailed_semantics.html#reference_swap_optional_optional"><spanclass="inlinemediaobject"><img src="../images/callouts/R.png"alt="R"></a>

-} // namespaceboost </pre>

-
+<span class="special">}</span> <span class="comment">// namespace boost
+</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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================

--- /trunk/libs/optional/doc/html/boost_optional/type_requirements.html ThuSep 4 19:32:19 2008+++ /trunk/libs/optional/doc/html/boost_optional/type_requirements.html WedMar 24 00:54:49 2010

@@ -1,88 +1,56 @@
-<!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 requirements</title>
-  <link rel="stylesheet" href="../boostbook.css" type="text/css">
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-

- <link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">

- <link rel="prev" href="exception_safety_guarantees.html"title="Exception Safety Guarantees">

- <link rel="next" href="implementation_notes.html" title="ImplementationNotes">

+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Type requirements &#31867;&#22411;&#35201;&#27714;</title>
+<link rel="stylesheet" href="../boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="up" href="../index.html"title="Chapter 1. Boost.Optional">+<link rel="prev" href="exception_safety_guarantees.html" title="ExceptionSafety Guarantees 异常安全性保证">+<link rel="next" href="implementation_notes.html" title="ImplementationNotes 实现说明">

 </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"><ahref="../../../../libraries.htm">Libraries</a></td>

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

- <td align="center"><ahref="http://www.boost.org/more/faq.htm";>FAQ</a></td>

- <td align="center"><ahref="../../../../../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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="exception_safety_guarantees.html"><imgsrc="../../../../../doc/html/images/prev.png" alt="Prev"></a><aaccesskey="u" href="../index.html"><imgsrc="../../../../../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="implementation_notes.html"><imgsrc="../../../../../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_optional.type_requirements"></a><a class="link"href="type_requirements.html" title="Type requirements">类型要求</a>

-</h2>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="boost_optional.type_requirements"></a><a class="link"href="type_requirements.html" title="Type requirements类型要求"> Type requirements类型要求</a>

+</h2></div></div></div>
+<p>

+ In general, <code class="computeroutput"><spanclass="identifier">T</code> must be <ahref="../../../../utility/CopyConstructible.html" target="_top">CopyConstructible</a> and+ have a no-throw destructor. The copy-constructible requirement isnot needed+ if InPlaceFactories areused. 通常，<code class="computeroutput"><spanclass="identifier">T</code> 必须是 <ahref="../../../../utility/CopyConstructible.html" target="_top">Copy+ Constructible</a>且具有无抛出的析构函数。如果使用<spanclass="bold">InPlaceFactories，则无须要求可复制构造。

+    </p>
+<p>

+ <code class="computeroutput"><spanclass="identifier">T</code> is+ not required to be <ahref="http://www.sgi.com/tech/stl/DefaultConstructible.html";target="_top">Default+ Constructible</a>. <code class="computeroutput"><spanclass="identifier">T</code>+ <spanclass="underline">并不要求是 <ahref="http://www.sgi.com/tech/stl/DefaultConstructible.html";target="_top">Default

+      Constructible</a>&#12290;
+    </p>
 </div>
-</div>
-</div>
-

-通常，<code class="computeroutput"><spanclass="identifier">T</code> 必须是 <ahref="../../../../utility/CopyConstructible.html">可复制构造的</a>-且具有无抛出的析构函数。如果使用 InPlaceFactories，则无须要求可复制构造。-<code class="computeroutput"><spanclass="identifier">T</code> 并不要求是 <ahref="http://www.sgi.com/tech/stl/DefaultConstructible.html";>可缺省构造的</a>。

-</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">

-      <p>

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>

+<td align="left"></td>

       </p>
-
-      </div>
-      </td>
-
-    </tr>
-  </tbody>
-</table>
-
+</div></td>
+</tr></table>
 <hr>
 <div class="spirit-nav">

 </div>
-
 </body>
 </html>
=======================================
--- /trunk/libs/optional/doc/html/index.html    Tue Nov 11 23:43:49 2008
+++ /trunk/libs/optional/doc/html/index.html    Wed Mar 24 00:54:49 2010
@@ -1,357 +1,196 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head>
-
-
-
-  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-
-
-
-
-
-

- <title>Chapter 1. Boost.Optional</title><link rel="stylesheet"href="boostbook.css" type="text/css">

-
-
-
-  <meta name="generator" content="DocBook XSL Stylesheets V1.73.2">
-
-
-

- <link rel="start" href="index.html"title="Chapter 1. Boost.Optional">

-
-
-

- <link rel="next" href="boost_optional/development.html"title="Development"></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"><ahref="../../../libraries.htm">Libraries</a></td>

-
-

- <td align="center"><ahref="http://www.boost.org/people/people.htm";>People</a></td>

-
-

- <td align="center"><ahref="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>Chapter&#160;1.&#160;Boost.Optional</title>
+<link rel="stylesheet" href="boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.73.2">

+<link rel="start" href="index.html"title="Chapter 1. Boost.Optional">+<link rel="next" href="boost_optional/development.html" title="Development发展">

+</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"><ahref="http://www.boost.org/users/people.html";>People</a></td>+<td align="center"><ahref="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="n"href="boost_optional/development.html"><imgsrc="../../../../doc/html/images/next.png" alt="Next"></a></div>

-
-
 <div class="chapter" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title">
-<a name="optional"></a>Chapter&nbsp;1.&nbsp;Boost.Optional</h2>
-
-</div>
-
-
-<div>
-<div class="author">
-<h3 class="author">
+<div class="titlepage"><div>
+<div><h2 class="title">
+<a name="optional"></a>Chapter&#160;1.&#160;Boost.Optional</h2></div>
+<div><div class="author"><h3 class="author">

Fernando Luis <spanclass="surname">Cacciola Carballal

-</h3>
-
-</div>
-
-</div>
-
-
-<div>

-
-</div>
-
-
-<div>
-<div class="legalnotice">
-<a name="id2625900"></a>
-<p>
+</h3></div></div>

+<div><div class="legalnotice">
+<a name="id4850104"></a><p>

Distributed under the Boost Software License, Version 1.0. (Seeaccompanyingfile LICENSE_1_0.txt or copy at <ahref="http://www.boost.org/LICENSE_1_0.txt";target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)

       </p>
-
-
-</div>
-
-</div>
-
-
-</div>
-
-</div>
-
-
+</div></div>
+</div></div>
 <div class="toc">
-<p><b>目录</b></p>
-
-
+<p><b>Table of Contents</b></p>
 <dl>
-
-

- <dt><a href="index.html#optional.motivation">动机</a></dt>

-
-

- <dt><a href="boost_optional/development.html">发展</a></dt>

-
-
-  <dd>
-
-    <dl>
-
-

- <dt><ahref="boost_optional/development.html#boost_optional.development.the_models">模型</a></dt>

-
-

- <dt><ahref="boost_optional/development.html#boost_optional.development.the_semantics">语义</a></dt>

-
-

- <dt><ahref="boost_optional/development.html#boost_optional.development.the_interface">接口</a></dt>

-
-
-
-    </dl>
-
-  </dd>
-
-

- <dt><a href="boost_optional/synopsis.html">概要</a></dt>

-
-

- <dt><ahref="boost_optional/detailed_semantics.html">详细语义</a></dt>

-
-

- <dt><a href="boost_optional/examples.html">例子</a></dt>

-
-
-  <dd>
-
-    <dl>
-
-

- <dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_return_values">可选返回值</a></dt>

-
-

- <dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_local_variables">可选局部变量</a></dt>

-
-

- <dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_data_members">可选数据成员</a></dt>

-
-

- <dt><ahref="boost_optional/examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">避免不必要的昂贵的缺省构造</a></dt>

-
-
-
-    </dl>
-
-  </dd>
-
-

- <dt><ahref="boost_optional/optional_references.html">Optional 引用</a></dt>

-
-

- <dt><ahref="boost_optional/rebinding_semantics_for_assignment_of_optional_references.html">optional引用的赋值操作的重绑定语义</a></dt>

-
-

- <dt><ahref="boost_optional/in_place_factories.html">就地创建</a></dt>

-
-

- <dt><ahref="boost_optional/a_note_about_optional_bool_.html">关于 </a><ahref="boost_optional/a_note_about_optional_bool_.html"><spanclass="section"></a><ahref="boost_optional/a_note_about_optional_bool_.html">optional<bool></a><spanclass="section"><a href="boost_optional/a_note_about_optional_bool_.html">的说明</a></dt>

-
-

- <dt><ahref="boost_optional/exception_safety_guarantees.html">异常安全性保证</a></dt>

-
-

- <dt><ahref="boost_optional/type_requirements.html">类型要求</a></dt>

-
-

- <dt><ahref="boost_optional/implementation_notes.html">实现说明</a></dt>

-
-

- <dt><ahref="boost_optional/dependencies_and_portability.html">依赖性和可移植性</a></dt>

-
-

- <dt><ahref="boost_optional/acknowledgments.html">鸣谢</a></dt>

-
-

+<dt><a href="index.html#optional.motivation">Motivation 动机</a></dt>+<dt><a href="boost_optional/development.html">Development 发展</a></dt>

+<dd><dl>

+<dt><ahref="boost_optional/development.html#boost_optional.development.the_models">The models 模型</a></dt>+<dt><ahref="boost_optional/development.html#boost_optional.development.the_semantics">The semantics

+      &#35821;&#20041;</a></span></dt>

+<dt><ahref="boost_optional/development.html#boost_optional.development.the_interface">The Interface

+      &#25509;&#21475;</a></span></dt>
+</dl></dd>

+<dt><a href="boost_optional/synopsis.html"> Synopsis摘要</a></dt>+<dt><ahref="boost_optional/detailed_semantics.html"> Detailed Semantics

+    &#35814;&#32454;&#35821;&#20041;</a></span></dt>

+<dt><a href="boost_optional/examples.html"> Examples例子</a></dt>

+<dd><dl>

+<dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_return_values">Optional

+      return values Optional&#36820;&#22238;&#20540;</a></span></dt>

+<dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_local_variables">Optional+ local variablesOptional局部变量</a></dt>+<dt><ahref="boost_optional/examples.html#boost_optional.examples.optional_data_members">Optional

+      data members Optional&#25968;&#25454;&#25104;&#21592;</a></span></dt>

+<dt><ahref="boost_optional/examples.html#boost_optional.examples.bypassing_expensive_unnecessary_default_construction">+ Bypassing expensive unnecessary default construction避免不必要的昂贵的缺省构造</a></dt>

+</dl></dd>

+<dt><ahref="boost_optional/optional_references.html"> Optional references

+    Optional&#24341;&#29992;</a></span></dt>

+<dt><ahref="boost_optional/rebinding_semantics_for_assignment_of_optional_references.html">+ Rebinding semantics for assignment of optional referencesoptional引用赋值操作的重绑定语义</a></dt>+<dt><ahref="boost_optional/in_place_factories.html"> In-Place Factories

+    &#23601;&#22320;&#21019;&#24314;</a></span></dt>

+<dt><ahref="boost_optional/a_note_about_optional_bool_.html"> A note about+ optional<bool>关于optional<bool>的说明</a></dt>+<dt><ahref="boost_optional/exception_safety_guarantees.html"> Exception+ Safety Guarantees异常安全性保证</a></dt>+<dt><a href="boost_optional/type_requirements.html">Type requirements 类型要求</a></dt>+<dt><ahref="boost_optional/implementation_notes.html"> Implementation Notes

+    &#23454;&#29616;&#35828;&#26126;</a></span></dt>

+<dt><ahref="boost_optional/dependencies_and_portability.html"> Dependencies+ and Portability依赖性和可移植性</a></dt>+<dt><a href="boost_optional/acknowledgments.html">Acknowledgments 鸣谢</a></dt>

 </dl>
-
-
 </div>
-
-
 <div class="section" lang="en">
-<div class="titlepage">
-<div>
-<div>
-<h2 class="title" style="clear: both;">

-<a name="optional.motivation"></a><a class="link"href="index.html#optional.motivation" title="Motivation">动机</a>

-</h2>
-
-</div>
-
-</div>
-
-</div>
-
-
-<p>请看一下以下几个返回一个值的函数，它们也可能没有值可以返回：
-
-</p>
-
-<div class="itemizedlist">
-<ul type="disc">
-
-  <li>
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">

+<a name="optional.motivation"></a><a class="link"href="index.html#optional.motivation" title="Motivation 动机">Motivation 动机</a>

+</h2></div></div></div>
+<p>

+ Consider these functions which should return a value but which mightnot have+ a value to return: 请看一下以下几个返回一个值的函数，它们也可能没有值可以返回：

+    </p>
+<div class="itemizedlist"><ul type="disc">
+<li>

(A) <code class="computeroutput"><spanclass="keyword">double sqrt<spanclass="special">(double <spanclass="identifier">n

         <span class="special">);</span></code>
-  </li>
-
-  <li>
+</li>
+<li>

(B) <code class="computeroutput">charget_async_input<spanclass="special">();</code>

-  </li>
-
-  <li>

- (C) <code class="computeroutput"><spanclass="identifier">point <spanclass="identifier">polygon::<spanclass="identifier">get_any_point_effectively_inside<spanclass="special">();</code> 

-
-  </li>
-
-</ul>
-
-</div>
-
-<p>通常有几种不同的方法来处理无值可以返回的情形。</p>
-
-

-最典型的方法是将有效的返回值视为后续条件，则如果函数不能计算出要返回的值，那么它要么具有未定义行为(也可以在调试的构建中使用断言)，要么使-用运行期检查并在违反后续条件时抛出一个异常。对于函数(A)这是一个合理的选择，因为无法得到正确的返回值是直接由无效的参数(超出参数域)所引起的，

-所以要求调用者只能提供有效域内的参数是适合的。</p>
-
-

-但是对于函数(B)，由于它本身的异步性，不应该仅仅因为不能找到可返回的值就认为是失败；所以将这种情况视为错误或抛出异常都是不正确的。该函数必须返回，并且一定要通知调用者它没有返回一个有意义的值的。

-
-

-类似的情形也发生在函数(C)上：询问一个空的多边形并返回一个内部点在概念上是错误的，但是在多数应用程序中，由于性能的原因，将它视为一个错误-是不切实际的(因为在调用之前检测一个多边形是否为空可能代价很高)，要么返回任意一个点(通常是无限远)，要么以高效的方法通知调用者没有这样的点。

-
-

-有多种机制来让函数通告返回值是无效的。其中最常用的一种机制没有或只有很小的开销，就是用一个保留的特殊值来通告。这种特殊值的一个典型例子包括 <codeclass="computeroutput">EOF</code>, <codeclass="computeroutput">string<spanclass="special">::npos</code>, 位于无限远的点，等等...

-
-

-如果存在这样的值，即返回类型可以持有所有有意义的值再<spanstyle="font-style: italic;">加上这个信号值，那么这种机制就非常适合。不幸的是，有些情形下不存在这样的值。这时，通常可用的方法是，要么使用一个更宽的类型，如用-'int' 代替 'char'; 或者使用复合类型，如 <code class="computeroutput"><spanclass="identifier">std::<spanclass="identifier">pair<<spanclass="identifier">point,<spanclass="keyword">bool></code>. 

-
-

-返回一个 <code class="computeroutput"><spanclass="identifier">std::<spanclass="identifier">pair<<spanclass="identifier">point,<spanclass="keyword">bool></code>,-要在结果之后添加一个布尔标志，用于表示该结果是否有效，该方法的好处是，无论函数要返回什么类型，都可以用作 pair-的第一个元素，这可以成为一种通用的惯用法。例如，前例中的后两个函数可以具有以下接口： 

-
-</p>
-
+</li>
+<li>

+ (C) <code class="computeroutput"><spanclass="identifier">point <spanclass="identifier">polygon::<spanclass="identifier">get_any_point_effectively_inside<spanclass="special">();</code>

+</li>
+</ul></div>
+<p>

+ There are different approaches to the issue of not having a value toreturn. +通常有几种不同的方法来处理无值可以返回的情形。

+    </p>
+<p>

+ A typical approach is to consider the existence of a valid returnvalue as+ a postcondition, so that if the function cannot compute the value toreturn,+ it has either undefined behavior (and can use assert in a debugbuild) or uses+ a runtime check and throws an exception if the postcondition isviolated. This+ is a reasonable choice for example, for function (A), because thelack of a+ proper return value is directly related to an invalid parameter (outof domain+ argument), so it is appropriate to require the callee to supply onlyparameters+ in a valid domain for execution to continue normally. 最典型的方法是将有效的返回值视为后续条件，则如果函数不能计算出要返回的值，那么它要么具有未定义行为+(也可以在调试的构建中使用断言)，要么使用运行期检查并在违反后续条件时抛出一个异常。+对于函数(A)这是一个合理的选择，因为无法得到正确的返回值是直接由无效的参数(超出参数域)所引起的，+所以要求调用者只能提供有效域内的参数是适合的。

+    </p>
+<p>

+ However, function (B), because of its asynchronous nature, does notfail just+ because it can't find a value to return; so it is incorrect toconsider such+ a situation an error and assert or throw an exception. This functionmust return,+ and somehow, must tell the callee that it is not returning ameaningful value. +但是对于函数(B)，由于它本身的异步性，不应该仅仅因为不能找到可返回的值就认为是失败；+所以将这种情况视为错误或抛出异常都是不正确的。该函数必须返回，并且一定要通知调用者它没有返回一个有意义的值的。

+    </p>
+<p>

+ A similar situation occurs with function (C): it is conceptually anerror to+ ask a null-area polygon toreturn a point inside itself,+ but in many applications, it is just impractical for performancereasons to+ treat this as an error (because detecting that the polygon has noarea might+ be too expensive to be required to be tested previously), and eitheran arbitrary+ point (typically at infinity) is returned, or some efficient way totell the+ callee that there is no such point is used. 类似的情形也发生在函数(C)上：询问一个空的多边形并返回一个内部点在概念上是错误的，但是在多数应用程序中，+由于性能的原因，将它视为一个错误是不切实际的(因为在调用之前检测一个多边形是否为空可能代价很高)，+要么返回任意一个点(通常是无限远)，要么以高效的方法通知调用者没有这样的点。

+    </p>
+<p>

+ There are various mechanisms to let functions communicate that thereturned+ value is not valid. One such mechanism, which is quite common sinceit has+ zero or negligible overhead, is to use a special value which isreserved to+ communicate this. Classical examples of such special values are<code class="computeroutput">EOF</code>,<code class="computeroutput">string<spanclass="special">::npos</code>, points+ at infinity, etc... 有多种机制来让函数通告返回值是无效的。其中最常用的一种机制没有或只有很小的开销，就是用一个保留的特殊值来通告。+这种特殊值的一个典型例子包括<code class="computeroutput">EOF</code>,+ <code class="computeroutput"><spanclass="identifier">string::<spanclass="identifier">npos</code>,位于无限远的点，等等...

+    </p>
+<p>

+ When those values exist, i.e. the return type can hold allmeaningful values+ plus the <spanclass="emphasis">signal value, this mechanism+ is quite appropriate and well known. Unfortunately, there are caseswhen such+ values do not exist. In these cases, the usual alternative is eitherto use+ a wider type, such as <code class="computeroutput"><spanclass="keyword">int</code> in place+ of <code class="computeroutput"><spanclass="keyword">char</code>; or a compound type, such+ as <code class="computeroutput"><spanclass="identifier">std::<spanclass="identifier">pair<<spanclass="identifier">point,<spanclass="keyword">bool></code>. 如果存在这样的值，即返回类型可以持有所有有意义的值再<spanclass="emphasis">加上这个<spanclass="emphasis">信号值，那么这种机制就非常适合。+不幸的是，有些情形下不存在这样的值。这时，通常可用的方法是，要么使用一个更宽的类型，如用+ <code class="computeroutput">int</code>代替 <code class="computeroutput"><spanclass="keyword">char</code>;+或者使用复合类型，如<code class="computeroutput">std<spanclass="special">::pair<spanclass="special"><point<spanclass="special">,bool<spanclass="special">></code>.

+    </p>
+<p>

+ Returning a <code class="computeroutput"><spanclass="identifier">std::<spanclass="identifier">pair<<spanclass="identifier">T,<spanclass="keyword">bool></code>, thusattaching a boolean flag to the result+ which indicates if the result is meaningful, has the advantage thatcan be+ turned into a consistent idiom since the first element of the paircan be whatever+ the function would conceptually return. For example, the last twofunctions+ could have the following interface: 返回一个 <code class="computeroutput"><spanclass="identifier">std::<spanclass="identifier">pair<<spanclass="identifier">point,<spanclass="keyword">bool></code>,要在结果之后添加一个布尔标志，用于表示该结果是否有效，+该方法的好处是，无论函数要返回什么类型，都可以用作+ pair的第一个元素，这可以成为一种通用的惯用法。例如，前例中的后两个函数可以具有以下接口：

+    </p>

<pre class="programlisting">std<spanclass="special">::pair<spanclass="special"><char<spanclass="special">,bool<spanclass="special">> <spanclass="identifier">get_async_input();std::<spanclass="identifier">pair<<spanclass="identifier">point,<spanclass="keyword">bool> <spanclass="identifier">polygon::<spanclass="identifier">get_any_point_effectively_inside<spanclass="special">();

 </pre>
-
-
-<p>这些函数使用了统一的接口来处理返回值不存在的可能性：<br>
-
-</p>
-
+<p>

+ These functions use a consistent interface for dealing with possiblyinexistent+ results: 这些函数使用了统一的接口来处理返回值不存在的可能性：

+    </p>

<pre class="programlisting">std<spanclass="special">::pair<spanclass="special"><point<spanclass="special">,bool<spanclass="special">> p <spanclass="special">= poly<spanclass="special">.<spanclass="identifier">get_any_point_effectively_inside<spanclass="special">();if ( <spanclass="identifier">p.<spanclass="identifier">second )flood_fill<spanclass="special">(p<spanclass="special">.first<spanclass="special">);

 </pre>
-
-

-不过，这不仅是语法上的负担，还会容易出错，因为用户很容易不检查函数结果(pair的第一个元素)是否有效就直接使用它。

-
-
-<p>显然，我们需要更好的方法。<br>
-
-</p>
-
-</div>
-
-
 <p>
-  </p>
-
-
-<a name="optional_refassign"></a>

+ However, not only is this quite a burden syntactically, it is alsoerror prone+ since the user can easily use the function result (first element ofthe pair)+ without ever checking if it has a valid value. 不过，这不仅是语法上的负担，还会容易出错，因为用户很容易不检查函数结果(pair的第一个元素)是否有效就直接使用它。

+    </p>
 <p>
-  </p>
-
-
-<a name="optional_in_place_factories"></a>

+ Clearly, we need a better idiom. 显然，我们需要更好的方法。

+    </p>
+</div>
 <p>
   </p>
-
-
-<a name="optional_implementation_notes"></a>
-<p>
-  </p>
-
-
 </div>
-
-

-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%">

-
-  <tbody>
-
-    <tr>
-
-
-      <td align="left">
-
-      <p><small>Last revised: October 10, 2008 at 20:53:37 GMT</small></p>
-
-      </td>
-
-
-      <td align="right">
-
-      <div class="copyright-footer"></div>
-
-      </td>
-
-
-    </tr>
-
-
-  </tbody>
-</table>
-
-

+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision";width="100%"><tr>+<td align="left">Last revised: March 24, 2010 at 07:48:57GMT</td>

+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
 <hr>

<div class="spirit-nav"><a accesskey="n"href="boost_optional/development.html"><imgsrc="../../../../doc/html/images/next.png" alt="Next"></a></div>

-
-
-</body></html>
+</body>
+</html>
=======================================

--- /trunk/libs/optional/doc/implementation_notes.qbk Mon Feb 8 07:24:102010+++ /trunk/libs/optional/doc/implementation_notes.qbk Wed Mar 24 00:54:492010

@@ -10,7 +10,7 @@



-[section Implementation Notes]
+[section:implementation_notes Implementation Notes 实现说明]

`optional<T>` is currently implemented using a custom aligned storagefacilitybuilt from `alignment_of` and `type_with_alignment` (both from TypeTraits). It

@@ -20,7 +20,13 @@

As a result, `T`'s default constructor is effectively by-passed, but theexception

 guarantees are basic.

It is planned to replace the current implementation with another withstronger

-exception safety, such as a future `boost::variant`.
+exception safety, such as a future `boost::variant`.\n

+`optional<T>` 当前的实现使用了一个由 `alignment_of` 和`type_with_alignment` (均来自 Type Traits)构建的定制对齐存储工具。+它使用一个独立的布尔标志来标识初始化状态。带有 `T` 的复制构造函数的Placement new 以及 `T` 的析构函数被显式用于初始化、+复制和销毁 optional 的值。这样可以有效地绕过 `T` 的缺省构造函数，但是异常保证只能是基本的。+有计划用其它具有更强异常安全性的方法来替代当前的实现，如未来的`boost::variant`.

+
+

 [endsect]

=======================================
--- /trunk/libs/optional/doc/optional.qbk       Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/optional.qbk       Wed Mar 24 00:54:49 2010
@@ -44,16 +44,18 @@
 [def __GO_TO__ [$images/callouts/R.png]]


-[section Motivation]
+[section:motivation Motivation 动机]

Consider these functions which should return a value but which might nothave

-a value to return:
+a value to return:\n
+请看一下以下几个返回一个值的函数，它们也可能没有值可以返回：

 * (A) `double sqrt(double n );`
 * (B) `char get_async_input();`
 * (C) `point polygon::get_any_point_effectively_inside();`

-There are different approaches to the issue of not having a value toreturn.+There are different approaches to the issue of not having a value toreturn.\n

+通常有几种不同的方法来处理无值可以返回的情形。

A typical approach is to consider the existence of a valid return value asapostcondition, so that if the function cannot compute the value to return,it

@@ -62,13 +64,19 @@
 is a reasonable choice for example, for function (A), because the lack of a

proper return value is directly related to an invalid parameter (out ofdomainargument), so it is appropriate to require the callee to supply onlyparameters

-in a valid domain for execution to continue normally.
+in a valid domain for execution to continue normally.\n

+最典型的方法是将有效的返回值视为后续条件，则如果函数不能计算出要返回的值，那么它要么具有未定义行为+(也可以在调试的构建中使用断言)，要么使用运行期检查并在违反后续条件时抛出一个异常。+对于函数(A)这是一个合理的选择，因为无法得到正确的返回值是直接由无效的参数(超出参数域)所引起的，

+所以要求调用者只能提供有效域内的参数是适合的。

However, function (B), because of its asynchronous nature, does not failjustbecause it can't find a value to return; so it is incorrect to considersuch

 a situation an error and assert or throw an exception. This function must

return, and somehow, must tell the callee that it is not returning ameaningful

-value.
+value.\n

+但是对于函数(B)，由于它本身的异步性，不应该仅仅因为不能找到可返回的值就认为是失败；+所以将这种情况视为错误或抛出异常都是不正确的。该函数必须返回，并且一定要通知调用者它没有返回一个有意义的值的。

A similar situation occurs with function (C): it is conceptually an errorto

 ask a ['null-area] polygon to return a point inside itself, but in many
@@ -76,31 +84,43 @@

an error (because detecting that the polygon has no area might be tooexpensive

 to be required to be tested previously), and either an arbitrary point

(typically at infinity) is returned, or some efficient way to tell thecallee

-that there is no such point is used.
+that there is no such point is used.\n

+类似的情形也发生在函数(C)上：询问一个空的多边形并返回一个内部点在概念上是错误的，但是在多数应用程序中，+由于性能的原因，将它视为一个错误是不切实际的(因为在调用之前检测一个多边形是否为空可能代价很高)，

+要么返回任意一个点(通常是无限远)，要么以高效的方法通知调用者没有这样的点。

 There are various mechanisms to let functions communicate that the returned
 value is not valid. One such mechanism, which is quite common since it has
 zero or negligible overhead, is to use a special value which is reserved to
 communicate this. Classical examples of such special values are `EOF`,
-`string::npos`, points at infinity, etc...
+`string::npos`, points at infinity, etc...\n

+有多种机制来让函数通告返回值是无效的。其中最常用的一种机制没有或只有很小的开销，就是用一个保留的特殊值来通告。

+这种特殊值的一个典型例子包括 `EOF`, `string::npos`, 位于无限远的点，等等...

When those values exist, i.e. the return type can hold all meaningfulvalues['plus] the ['signal] value, this mechanism is quite appropriate and wellknown.Unfortunately, there are cases when such values do not exist. In thesecases,the usual alternative is either to use a wider type, such as `int` inplace of

-`char`; or a compound type, such as `std::pair<point,bool>`.
+`char`; or a compound type, such as `std::pair<point,bool>`.\n

+如果存在这样的值，即返回类型可以持有所有有意义的值再['加上]这个['信号]值，那么这种机制就非常适合。+不幸的是，有些情形下不存在这样的值。这时，通常可用的方法是，要么使用一个更宽的类型，如用 `int` 代替 `char`;

+或者使用复合类型，如 `std::pair<point,bool>`.

Returning a `std::pair<T,bool>`, thus attaching a boolean flag to theresult

 which indicates if the result is meaningful, has the advantage that can be
 turned into a consistent idiom since the first element of the pair can be
 whatever the function would conceptually return. For example, the last two
-functions could have the following interface:
+functions could have the following interface:\n

+返回一个 `std::pair<point,bool>`, 要在结果之后添加一个布尔标志，用于表示该结果是否有效，+该方法的好处是，无论函数要返回什么类型，都可以用作 pair 的第一个元素，这可以成为一种通用的惯用法。

+例如，前例中的后两个函数可以具有以下接口：

     std::pair<char,bool> get_async_input();
     std::pair<point,bool> polygon::get_any_point_effectively_inside();

These functions use a consistent interface for dealing with possiblyinexistent

-results:
+results:\n
+这些函数使用了统一的接口来处理返回值不存在的可能性：

     std::pair<point,bool> p = poly.get_any_point_effectively_inside();
     if ( p.second )
@@ -108,9 +128,11 @@

However, not only is this quite a burden syntactically, it is also errorpronesince the user can easily use the function result (first element of thepair)

-without ever checking if it has a valid value.
-
-Clearly, we need a better idiom.
+without ever checking if it has a valid value.\n

+不过，这不仅是语法上的负担，还会容易出错，因为用户很容易不检查函数结果(pair的第一个元素)是否有效就直接使用它。

+
+Clearly, we need a better idiom.\n
+显然，我们需要更好的方法。

 [endsect]

=======================================
--- /trunk/libs/optional/doc/reference.qbk      Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/reference.qbk      Wed Mar 24 00:54:49 2010
@@ -9,7 +9,7 @@
 ]


-[section Synopsis]
+[section:synopsis Synopsis 摘要]

     namespace boost {

@@ -19,6 +19,7 @@
         public :

// (If T is of reference type, the parameters and results byreference are by value)

+        // (如果 T 是引用类型，则以引用传递的参数和结果变为以值传递)

         optional () ; ``[link reference_optional_constructor __GO_TO__]``

@@ -27,6 +28,7 @@

optional ( T const& v ) ; ``[linkreference_optional_constructor_value __GO_TO__]``


         // [new in 1.34]
+        // [1.34版本中新增]

optional ( bool condition, T const& v ) ; ``[linkreference_optional_constructor_bool_value __GO_TO__]``

optional ( optional const& rhs ) ; ``[linkreference_optional_constructor_optional __GO_TO__]``

@@ -53,6 +55,7 @@
         T&       get() ; ``[link reference_optional_get __GO_TO__]``

         // [new in 1.34]
+        // [1.34版本中新增]

T const& get_value_or( T const& default ) const ; ``[linkreference_optional_get_value_or_value __GO_TO__]``

T const* operator ->() const ; ``[linkreference_optional_operator_arrow __GO_TO__]``

@@ -69,6 +72,7 @@

bool operator!() const ; ``[link reference_optional_operator_not__GO_TO__]``


         // deprecated methods
+        // 停用的方法

         // (deprecated)
         void reset() ; ``[link reference_optional_reset __GO_TO__]``
@@ -94,12 +98,15 @@

template<class T> inline bool operator >= ( optional<T> const& x,optional<T> const& y ) ; ``[linkreference_operator_compare_greater_or_equal_optional_optional __GO_TO__]``


     // [new in 1.34]
+    // [1.34版本中新增]

template<class T> inline optional<T> make_optional ( T const& v ) ;``[link reference_make_optional_value __GO_TO__]``


     // [new in 1.34]
+    // [1.34版本中新增]

template<class T> inline optional<T> make_optional ( bool condition, Tconst& v ) ; ``[link reference_make_optional_bool_value __GO_TO__]``


     // [new in 1.34]
+    // [1.34版本中新增]

template<class T> inline T const& get_optional_value_or ( optional<T>const& opt, T const& default ) ; ``[linkreference_optional_get_value_or_value __GO_TO__]``

template<class T> inline T const& get ( optional<T> const& opt ) ;``[link reference_optional_get __GO_TO__]``

@@ -121,29 +128,35 @@

 [endsect]

-[section Detailed Semantics]
+[section:detailed_semantics Detailed Semantics 详细语义]

 Because `T` might be of reference type, in the sequel, those entries whose

semantic depends on `T` being of reference type or not will bedistinguished

-using the following convention:
+using the following convention:\n

+因为 `T` 可能是引用类型，所以，那些语义与 `T` 的类型是否为引用相关的项，将使用以下约定：


 * If the entry reads: `optional<T`['(not a ref)]`>`, the description
-corresponds only to the case where `T` is not of reference type.
+corresponds only to the case where `T` is not of reference type.\n

+ 如果该项为：`optional<T`['(非引用)]`>`, 则对应的描述仅适作于 `T` 不是引用类型时的情况。

 * If the entry reads: `optional<T&>`, the description corresponds only to
-the case where `T` is of reference type.
+the case where `T` is of reference type.\n
+  如果该项为：`optional<T&>`, 则对应的描述仅适用于 `T` 是引用类型时的情况。
 * If the entry reads: `optional<T>`, the description is the same for both
-cases.
+cases.\n
+  如果该项为：`optional<T>`, 则对应的描述适用于两种情况。

 [note

The following section contains various `assert()` which are used only toshow

 the postconditions as sample code. It is not implied that the type `T` must
 support each particular expression but that if the expression is supported,
-the implied condition holds.
+the implied condition holds.\n
+以下章节中包含多个 `assert()`，仅用于示范后续条件的例子代码。

+它并不意味着类型 `T` 必须支持每个单独的表达式，但是如果它支持某个表达式，则满足相应的条件。

 ]

 __SPACE__

-[heading optional class member functions]
+[heading optional class member functions  optional类的成员函数]

 __SPACE__

@@ -151,11 +164,16 @@

 [: `optional<T>::optional();`]

-* [*Effect:] Default-Constructs an `optional`.
-* [*Postconditions:] `*this` is [_uninitialized].
-* [*Throws:] Nothing.
-* Notes: T's default constructor [_is not] called.
-* [*Example:]
+* [*Effect:] Default-Constructs an `optional`.\n
+  [*作用：]缺省构造一个 `optional`.
+* [*Postconditions:] `*this` is [_uninitialized].\n
+  [*后续条件：]`*this` 为 [_未初始化的]。
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* Notes: T's default constructor [_is not] called.\n
+  [*说明：]T 的缺省构造函数[_未被]调用。
+* [*Example:]\n
+  [*例子：]
 ``
 optional<T> def ;
 assert ( !def ) ;
@@ -167,13 +185,18 @@

 [: `optional<T>::optional( none_t );`]

-* [*Effect:] Constructs an `optional` uninitialized.
-* [*Postconditions:] `*this` is [_uninitialized].
-* [*Throws:] Nothing.
+* [*Effect:] Constructs an `optional` uninitialized.\n
+  [*作用：]构造一个未初始化的 `optional`.
+* [*Postconditions:] `*this` is [_uninitialized].\n
+  [*后续条件：]`*this` 为 [_未初始化的]。
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
 * [*Notes:] `T`'s default constructor [_is not] called. The expression
 `boost::none` denotes an instance of `boost::none_t` that can be used as
-the parameter.
-* [*Example:]
+the parameter.\n

+ [*说明：]`T` 的缺省构造函数[_未被]调用。表达式 `boost::none` 表示一个`boost::none_t` 实例，可用作本构造函数的参数。

+* [*Example:]\n
+  [*例子：]
 ``
 #include <boost/none.hpp>
 optional<T> n(none) ;
@@ -186,14 +209,20 @@

 [: `optional<T `['(not a ref)]`>::optional( T const& v )`]

-* [*Effect:] Directly-Constructs an `optional`.
+* [*Effect:] Directly-Constructs an `optional`.\n
+  [*作用：]直接构造一个 `optional`.
 * [*Postconditions:] `*this` is [_initialized] and its value is a['copy]
-of `v`.
-* [*Throws:] Whatever `T::T( T const& )` throws.
-* [*Notes: ] `T::T( T const& )` is called.
+of `v`.\n
+  [*后续条件：]`*this` 为 [_已初始化的]，它的值为 `v` 的['拷贝]。
+* [*Throws:] Whatever `T::T( T const& )` throws.\n
+  [*抛出：]`T::T( T const& )` 所抛出的任何异常。
+* [*Notes: ] `T::T( T const& )` is called.\n
+  [*说明：]调用 `T::T( T const& )`.
 * [*Exception Safety:] Exceptions can only be thrown during
-`T::T( T const& );` in that case, this constructor has no effect.
-* [*Example:]
+`T::T( T const& );` in that case, this constructor has no effect.\n
+  [*异常安全性：]仅会在 `T::T( T const& );` 中抛出异常，这时构造函数无效。
+* [*Example:]\n
+  [*例子：]
 ``
 T v;
 optional<T> opt(v);
@@ -204,11 +233,15 @@

 [: `optional<T&>::optional( T& ref )`]

-* [*Effect:] Directly-Constructs an `optional`.
+* [*Effect:] Directly-Constructs an `optional`.\n
+  [*作用：]直接构造一个 `optional`.
 * [*Postconditions:] `*this` is [_initialized] and its value is an instance
-of an internal type wrapping the reference `ref`.
-* [*Throws:] Nothing.
-* [*Example:]
+of an internal type wrapping the reference `ref`.\n

+ [*后续条件：]`*this` 为 [_已初始化的]，它的值为某个内部类型的实例，包装了引用 `ref`.

+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Example:]\n
+  [*例子：]
 ``
 T v;
 T& vref = v ;
@@ -225,12 +258,14 @@

[: `optional<T` ['(not a ref)]`>::optional( bool condition, T const& v) ;` ]

 [: `optional<T&>           ::optional( bool condition, T&       v ) ;` ]

-* If condition is true, same as:
+* If condition is true, same as:\n
+  如果 condition 为 true, 则相当于：

 [: `optional<T` ['(not a ref)]`>::optional( T const& v )`]
 [: `optional<T&>           ::optional( T&       v )`]

-* otherwise, same as:
+* otherwise, same as:\n
+  否则相当于：

 [: `optional<T ['(not a ref)]>::optional()`]
 [: `optional<T&>           ::optional()`]
@@ -241,14 +276,20 @@

 [: `optional<T `['(not a ref)]`>::optional( optional const& rhs );`]

-* [*Effect:] Copy-Constructs an `optional`.
+* [*Effect:] Copy-Constructs an `optional`.\n
+  [*作用：]复制构造一个 `optional`.
 * [*Postconditions:] If rhs is initialized, `*this` is initialized and

-its value is a ['copy] of the value of `rhs`; else `*this` isuninitialized.

-* [*Throws:] Whatever `T::T( T const& )` throws.
-* [*Notes:] If rhs is initialized, `T::T(T const& )` is called.

+its value is a ['copy] of the value of `rhs`; else `*this` isuninitialized.\n+ [*后续条件：]如果 `rhs` 是已初始化的，则 `*this` 为已初始化的，且值为`rhs` 的值的['拷贝]；否则 `*this` 为未初始化的。

+* [*Throws:] Whatever `T::T( T const& )` throws.\n
+  [*抛出：]`T::T( T const& )` 所抛出的任何异常。
+* [*Notes:] If rhs is initialized, `T::T(T const& )` is called.\n
+  [*说明：]如果 `rhs` 是已初始化的，则调用 `T::T(T const& )` .
 * [*Exception Safety:] Exceptions can only be thrown during
-`T::T( T const& );` in that case, this constructor has no effect.
-* [*Example:]
+`T::T( T const& );` in that case, this constructor has no effect.\n
+  [*异常安全性：]仅会在 `T::T( T const& );` 中抛出异常，这时构造函数无效。
+* [*Example:]\n
+  [*例子：]
 ``
 optional<T> uninit ;
 assert (!uninit);
@@ -267,14 +308,19 @@

 [: `optional<T&>::optional( optional const& rhs );`]

-* [*Effect:] Copy-Constructs an `optional`.
+* [*Effect:] Copy-Constructs an `optional`.\n
+  [*作用：]复制构造一个 `optional`.

* [*Postconditions:] If `rhs` is initialized, `*this` is initialized andits

 value is another reference to the same object referenced by `*rhs`; else
-`*this` is uninitialized.
-* [*Throws:] Nothing.
+`*this` is uninitialized.\n

+ [*后续条件：]如果 `rhs` 是已初始化的，则 `*this` 为已初始化的，且值为`*rhs` 所引用的同一个对象的另一个引用；否则 `*this` 为未初始化的。

+* [*Throws:] Nothing.\n
+  [*抛出：]无。

* [*Notes:] If `rhs` is initialized, both `*this` and `*rhs` will reeferto the

-same object (they alias).
-* [*Example:]
+same object (they alias).\n

+ [*说明：]如果 `rhs` 是已初始化的，则 `*this` 与 `*rhs` 均引向同一个对象(它们互为别名)。

+* [*Example:]\n
+  [*例子：]
 ``
 optional<T&> uninit ;
 assert (!uninit);
@@ -301,16 +347,22 @@

[: `template explicit optional<T` ['(not a ref)]`>::optional(optional const& rhs );`]


-* [*Effect:] Copy-Constructs an `optional`.
+* [*Effect:] Copy-Constructs an `optional`.\n
+  [*作用：]复制构造一个 `optional`.

* [*Postconditions:] If `rhs` is initialized, `*this` is initialized anditsvalue is a ['copy] of the value of rhs converted to type `T`; else `*this`is

-uninitialized.
-* [*Throws:] Whatever `T::T( U const& )` throws.
+uninitialized.\n

+ [*后续条件：]如果 `rhs` 是已初始化的，则 `*this` 为已初始化的，且值为`rhs` 转换为类型T的值的拷贝；否则 `*this` 为未初始化的。

+* [*Throws:] Whatever `T::T( U const& )` throws.\n
+  [*抛出：]`T::T( U const& )` 所抛出的任何异常。

* [*Notes: ] `T::T( U const& )` is called if `rhs` is initialized, whichrequires a

-valid conversion from `U` to `T`.
+valid conversion from `U` to `T`.\n

+ [*说明：]如果 `rhs` 已初始化，则调用 `T::T( U const& )`, 要求有从 `U` 到`T` 的有效转换。* [*Exception Safety:] Exceptions can only be thrown during `T::T( Uconst& );`

-in that case, this constructor has no effect.
-* [*Example:]
+in that case, this constructor has no effect.\n
+  [*异常安全性：]仅会在 `T::T( U const& );` 中抛出异常，这时构造函数无效。
+* [*Example:]\n
+  [*例子：]
 ``
 optional<double> x(123.4);
 assert ( *x == 123.4 ) ;
@@ -327,15 +379,21 @@

[: `template<TypedInPlaceFactory> explicit optional<T` ['(not aref)]`>::optional( TypedInPlaceFactory const& f );`]


 * [*Effect:] Constructs an `optional` with a value of `T` obtained from the
-factory.
+factory.\n
+  [*作用：]构造一个 `optional`，`T` 的值从工厂获得。

* [*Postconditions: ] `*this` is [_initialized] and its value is['directly given]

-from the factory `f` (i.e., the value [_is not copied]).
-* [*Throws:] Whatever the `T` constructor called by the factory throws.
-* [*Notes:] See [link boost_optional.in_place_factories In-Place Factories]
+from the factory `f` (i.e., the value [_is not copied]).\n

+ [*后续条件：]`*this` [_已初始化] 且其值['直接]由工厂 `f` 取得(即该值[_不是复制的])。

+* [*Throws:] Whatever the `T` constructor called by the factory throws.\n
+  [*抛出：]由工厂所调用的 `T` 构造函数所抛出的任何异常。

+* [*Notes:] See [link boost_optional.in_place_factories In-PlaceFactories]\n

+  [*说明：]请见 [link boost_optional.in_place_factories 就地创建]
 * [*Exception Safety:] Exceptions can only be thrown during the call to
 the `T` constructor used by the factory; in that case, this constructor has
-no effect.
-* [*Example:]
+no effect.\n

+ [*异常安全性：]仅会在工厂调用 `T` 的构造函数时抛出异常，这时构造函数无效。

+* [*Example:]\n
+  [*例子：]
 ``
 class C { C ( char, double, std::string ) ; } ;

@@ -354,17 +412,24 @@

 [: `optional& optional<T` ['(not a ref)]`>::operator= ( T const& rhs ) ;`]

-* [*Effect:] Assigns the value `rhs` to an `optional`.

-* [*Postconditions: ] `*this` is initialized and its value is a ['copy] of`rhs`.-* [*Throws:] Whatever `T::operator=( T const& )` or `T::T(T const&)`throws.

+* [*Effect:] Assigns the value `rhs` to an `optional`.\n
+  [*作用：]将值 `rhs` 赋给一个 `optional`.

+* [*Postconditions: ] `*this` is initialized and its value is a ['copy] of`rhs`.\n

+  [*后续条件：]`*this` 为已初始化的，其值为 `rhs` 的['拷贝]。

+* [*Throws:] Whatever `T::operator=( T const& )` or `T::T(T const&)`throws.\n+ [*抛出：]由 `T::operator=( T const& )` 或 `T::T(T const&)` 抛出的任何异常。

 * [*Notes:] If `*this` was initialized, `T`'s assignment operator is used,
-otherwise, its copy-constructor is used.
+otherwise, its copy-constructor is used.\n

+ [*说明：]如果 `*this` 是已初始化的，则使用 `T` 的赋值操作符，否则使用它的复制构造函数。

 * [*Exception Safety:] In the event of an exception, the initialization

state of `*this` is unchanged and its value unspecified as far as`optional`

 is concerned (it is up to `T`'s `operator=()`). If `*this` is initially
 uninitialized and `T`'s ['copy constructor] fails, `*this` is left properly
-uninitialized.
-* [*Example:]
+uninitialized.\n

+ [*异常安全性：]如果发生异常，`*this` 的初始化状态不会改变，它的值是不确定的直至 `optional` 被关联(由 `T` 的 `operator=()` 进行)。+ 如 `*this` 原来是未初始化的，且 `T` 的['复制构造函数] 失败了，则 `*this`仍为未初始化的。

+* [*Example:]\n
+  [*例子：]
 ``
 T x;
 optional<T> def ;
@@ -381,12 +446,17 @@

 [: `optional<T&>& optional<T&>::operator= ( T& const& rhs ) ;`]

-* [*Effect:] (Re)binds thee wrapped reference.
+* [*Effect:] (Re)binds thee wrapped reference.\n
+  [*作用：](重)绑定被包装的引用。
 * [*Postconditions: ] `*this` is initialized and it references the same
-object referenced by `rhs`.
+object referenced by `rhs`.\n
+  [*后续条件：]`*this` 已初始化且引向由 `rhs` 所引向的对象。
 * [*Notes:] If `*this` was initialized, is is ['rebound] to the new object.

-See [linkboost_optional.rebinding_semantics_for_assignment_of_optional_referenceshere] for details on this behavior.

-* [*Example:]

+See [linkboost_optional.rebinding_semantics_for_assignment_of_optional_referenceshere] for details on this behavior.\n

+  [*说明：]如果 `*this` 已初始化，则['重绑定]到新的对象。有关细节请见

+ [linkboost_optional.rebinding_semantics_for_assignment_of_optional_references 这里]。

+* [*Example:]\n
+  [*例子：]
 ``
 int a = 1 ;
 int b = 2 ;
@@ -412,19 +482,28 @@

[: `optional& optional<T` ['(not a ref)]`>::operator= ( optional const&rhs ) ;`]


-* [*Effect:] Assigns another `optional` to an `optional`.
+* [*Effect:] Assigns another `optional` to an `optional`.\n
+  [*作用：]将另一个 `optional` 赋值给一个 `optional`.
 * [*Postconditions:] If `rhs` is initialized, `*this` is initialized and

-its value is a ['copy] of the value of `rhs`; else `*this` isuninitialized.-* [*Throws:] Whatever `T::operator( T const&)` or `T::T( T const& )`throws.+its value is a ['copy] of the value of `rhs`; else `*this` isuninitialized.\n+ [*后续条件：]如果 `rhs` 已初始化，则 `*this` 为已初始化且其值为 `rhs` 值的['拷贝]；否则 `*this` 为未初始化。+* [*Throws:] Whatever `T::operator( T const&)` or `T::T( T const& )`throws.\n+ [*抛出：]由 `T::operator( T const&)` 或 `T::T( T const& )` 抛出的任何异常。

 * [*Notes:] If both `*this` and `rhs` are initially initialized, `T`'s

['assignment operator] is used. If `*this` is initially initialized but`rhs` isuninitialized, `T`'s [destructor] is called. If `*this` is initiallyuninitialized

-but `rhs` is initialized, `T`'s ['copy constructor] is called.
+but `rhs` is initialized, `T`'s ['copy constructor] is called.\n
+  [*说明：]如果 `*this` 和 `rhs` 均已初始化，则使用 `T` 的 ['赋值操作符]。
+  如果 `*this` 已初始化而 `rhs` 未初始化，则调用 `T` 的 ['析构函数]。
+  如果 `*this` 未初始化而 `rhs` 已初始化，则调用 `T` 的 ['复制构造函数]。

* [*Exception Safety:] In the event of an exception, the initializationstate of`*this` is unchanged and its value unspecified as far as optional isconcerned(it is up to `T`'s `operator=()`). If `*this` is initially uninitializedand

-`T`'s ['copy constructor] fails, `*this` is left properly uninitialized.
-* [*Example:]
+`T`'s ['copy constructor] fails, `*this` is left properly uninitialized.\n

+ [*异常安全性：]发生异常时，`*this` 的初始化状态不改变，其值是不确定的直至 `optional` 被关联(由 T 的 `operator=()` 进行)。+ 如果 `*this` 原来是未初始化的而且 `T` 的 ['复制构造函数] 失败，则`*this` 保持为未初始化]

+* [*Example:]\n
+  [*例子：]
 ``
 T v;
 optional<T> opt(v);
@@ -433,19 +512,25 @@
 opt = def ;
 assert ( !def ) ;
 // previous value (copy of 'v') destroyed from within 'opt'.
+// 'opt'的原值('v'的拷贝)被销毁
 ``

 __SPACE__

 [: `optional<T&> & optional<T&>::operator= ( optional<T&> const& rhs ) ;`]

-* [*Effect:] (Re)binds thee wrapped reference.
+* [*Effect:] (Re)binds thee wrapped reference.\n
+  [*作用：](重)绑定被包装的引用。

* [*Postconditions:] If `*rhs` is initialized, `*this` is initialized andit

 references the same object referenced by `*rhs`; otherwise, `*this` is
-uninitialized (and references no object).
+uninitialized (and references no object).\n

+ [*后续条件：]如果 `*rhs` 已初始化，则 `*this` 为已初始化的且引向且引向由`*rhs` 所引向的对象；否则 `*this` 为未初始化(不引向任何对象)。* [*Notes:] If `*this` was initialized and so is *rhs, this is is['rebound] to-the new object. See [linkboost_optional.rebinding_semantics_for_assignment_of_optional_referenceshere] for details on this behavior.

-* [*Example:]

+the new object. See [linkboost_optional.rebinding_semantics_for_assignment_of_optional_referenceshere] for details on this behavior.\n+ [*说明：]如果 `*this` 已初始化且 `*rhs` 也是，则['重绑定]到新的对象。有关细节请见+ [linkboost_optional.rebinding_semantics_for_assignment_of_optional_references 这里]。

+* [*Example:]\n
+  [*例子：]
 ``
 int a = 1 ;
 int b = 2 ;
@@ -473,22 +558,31 @@

[: `template optional& optional<T` ['(not a ref)]`>::operator= (optional const& rhs ) ;`]


-* [*Effect:] Assigns another convertible optional to an optional.
+* [*Effect:] Assigns another convertible optional to an optional.\n
+  [*作用：]将另一个可转换的 `optional` 赋值给一个 `optional`.
 * [*Postconditions:] If `rhs` is initialized, `*this` is initialized and
 its value is a ['copy] of the value of `rhs` ['converted] to type `T`; else
-`*this` is uninitialized.

-* [*Throws:] Whatever `T::operator=( U const& )` or `T::T( U const& )`throws.

+`*this` is uninitialized. \n

+ [*后续条件：]如果 `rhs` 已初始化，则 `*this` 也是已初始化的，且其值为`rhs` ['转换]为类型 `T` 后的值的['拷贝]；否则 `*this` 为未初始化。+* [*Throws:] Whatever `T::operator=( U const& )` or `T::T( U const& )`throws.\n+ [*抛出：]由 `T::operator=( U const& )` 或 `T::T( U const& )` 抛出的任何异常。

 * [*Notes:] If both `*this` and rhs are initially initialized, `T`'s

['assignment operator] (from `U`) is used. If `*this` is initiallyinitialized

 but `rhs` is uninitialized, `T`'s ['destructor] is called. If `*this` is

initially uninitialized but rhs is initialized, `T`'s ['convertingconstructor]

-(from `U`) is called.
+(from `U`) is called.\n

+ [*说明：]如果 `*this` 和 `rhs` 均已初始化，则使用 `T` 的 ['赋值操作符](赋值自 `U`)。

+  如果 `*this` 已初始化而 `rhs` 未初始化，则调用 `T` 的 ['析构函数]。

+ 如果 `*this` 未初始化而 `rhs` 已初始化，则调用 `T` 的 ['转换构造函数] (转换自 `U`)。* [*Exception Safety:] In the event of an exception, the initializationstate

 of `*this` is unchanged and its value unspecified as far as optional is
 concerned (it is up to `T`'s `operator=()`). If `*this` is initially

uninitialized and `T`'s converting constructor fails, `*this` is leftproperly

-uninitialized.
-* [*Example:]
+uninitialized.\n

+ [*异常安全性：]发生异常时，`*this` 的初始化状态不改变，其值是不确定的直至 `optional` 被关联(由 T 的 `operator=()` 进行)。+ 如果 `*this` 原来是未初始化的而且 `T` 的转换构造函数失败，则 `*this` 保持为未初始化。

+* [*Example:]\n
+  [*例子：]
 ``
 T v;
 optional<T> opt0(v);
@@ -503,14 +597,16 @@
 [#reference_optional_reset_value]

 [: `void optional<T` ['(not a ref)]`>::reset( T const& v ) ;`]
-* [*Deprecated:] same as `operator= ( T const& v) ;`
+* [*Deprecated:] same as `operator= ( T const& v) ;`\n
+  [*不建议使用：]相当于 `operator= ( T const& v) ;`

 __SPACE__

 [#reference_optional_reset]

 [: `void optional<T>::reset() ;`]
-* [*Deprecated:] Same as `operator=( detail::none_t );`
+* [*Deprecated:] Same as `operator=( detail::none_t );`\n
+  [*不建议使用：]相当于 `operator=( detail::none_t );`

 __SPACE__

@@ -524,11 +620,16 @@
 [: `inline T const& get ( optional<T` ['(not a ref)]`> const& ) ;`]
 [: `inline T&       get ( optional<T` ['(not a ref)]`> &) ;`]

-* [*Requirements:] `*this` is initialized
-* [*Returns:] A reference to the contained value
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
+* [*Requirements:] `*this` is initialized\n
+  [*要求：]`*this` 已初始化。
+* [*Returns:] A reference to the contained value\n
+  [*返回：]所含值的引用。
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.\n
+  [*说明：]以 `BOOST_ASSERT()` 对前提条件进行断言。
+* [*Example:]\n
+  [*例子：]
 ``
 T v ;
 optional<T> opt ( v );
@@ -549,9 +650,12 @@

[: `inline T const& get_optional_value_or ( optional<T` ['(not a ref)]`>const& o, T const& default ) ;`][: `inline T& get_optional_value_or ( optional<T` ['(not aref)]`>& o, T& default ) ;`]


-* [*Returns:] A reference to the contained value, if any, or `default`.
-* [*Throws:] Nothing.
-* [*Example:]
+* [*Returns:] A reference to the contained value, if any, or `default`.\n
+  [*返回：]如果有，则返回所含值(本身可以是引用)的引用, 否则返回 `default`.
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Example:]\n
+  [*例子：]
 ``
 T v, z ;
 optional<T> def;
@@ -574,11 +678,16 @@
 [: `inline T const& get ( optional<T&> const& ) ;`]
 [: `inline T&       get ( optional<T&> &) ;`]

-* [*Requirements: ] `*this` is initialized
-* [*Returns:] [_The] reference contained.
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
+* [*Requirements: ] `*this` is initialized\n
+  [*要求：]`*this` 已初始化。
+* [*Returns:] [_The] reference contained.\n
+  [*返回：]所包含的引用。
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.\n
+  [*说明：]以 `BOOST_ASSERT()` 对前提条件进行断言。
+* [*Example:]\n
+  [*例子：]
 ``
 T v ;
 T& vref = v ;
@@ -600,11 +709,15 @@
 [: `inline T*       get_pointer ( optional<T` ['(not a ref)]`> &) ;`]

 * [*Returns:] If `*this` is initialized, a pointer to the contained value;
-else `0` (['null]).
-* [*Throws:] Nothing.
+else `0` (['null]).\n

+ [*返回：]如果 `*this` 已初始化，则返回所含值的指针；否则返回 `0`(['null]).

+* [*Throws:] Nothing.\n
+  [*抛出：]无。

* [*Notes:] The contained value is permanently stored within `*this`, soyou

-should not hold nor delete this pointer
-* [*Example:]
+should not hold nor delete this pointer\n
+  [*说明：]所含值被 `*this` 永久保留，所以你不能持有或删除该指针。
+* [*Example:]\n
+  [*例子：]
 ``
 T v;
 optional<T> opt(v);
@@ -622,11 +735,16 @@
 [: `T const* optional<T` ['(not a ref)]`>::operator ->() const ;`]
 [: `T*       optional<T` ['(not a ref)]`>::operator ->()       ;`]

-* [*Requirements: ] `*this` is initialized.
-* [*Returns:] A pointer to the contained value.
-* [*Throws:] Nothing.
-* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.
-* [*Example:]
+* [*Requirements: ] `*this` is initialized.\n
+  [*要求：]`*this` 已初始化。
+* [*Returns:] A pointer to the contained value.\n
+  [*返回：]所含值的指针。
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Notes:] The requirement is asserted via `BOOST_ASSERT()`.\n
+  [*说明：]以 `BOOST_ASSERT()` 对前提条件进行断言。
+* [*Example:]\n
+  [*例子：]
 ``
 struct X { int mdata ; } ;
 X x ;
@@ -641,9 +759,12 @@
 [: `optional<T>::operator `['unspecified-bool-type]`() const ;`]

 * [*Returns:] An unspecified value which if used on a boolean context
-is equivalent to (`get() != 0`)
-* [*Throws:] Nothing.
-* [*Example:]
+is equivalent to (`get() != 0`)\n

+ [*返回：]一个未明确规定的值，该值可用于布尔上下文中，等同于 `(get() !=0)`

+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Example:]\n
+  [*例子：]
 ``
 optional<T> def ;
 assert ( def == 0 );
@@ -658,17 +779,22 @@

 [: `bool optional<T>::operator!() ;`]

-* [*Returns:] If `*this` is uninitialized, `true`; else `false`.
-* [*Throws:] Nothing.
+* [*Returns:] If `*this` is uninitialized, `true`; else `false`.\n
+  [*返回：]如果 `*this` 未初始化，则返回 `true`; 否则返回 `false`.
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
 * [*Notes:] This operator is provided for those compilers which can't
-use the ['unspecified-bool-type operator] in certain boolean contexts.
-* [*Example:]
+use the ['unspecified-bool-type operator] in certain boolean contexts.\n

+ [*说明：]该操作提供给那些不能在布尔上下文中使用 ['unspecified-bool-type操作符] 的编译器使用。

+* [*Example:]\n
+  [*例子：]
 ``
 optional<T> opt ;
 assert ( !opt );
 *opt = some_T ;

 // Notice the "double-bang" idiom here.
+// 注意这里的 "double-bang" 用法。
 assert ( !!opt ) ;
 ``

@@ -678,9 +804,12 @@

 [: `bool optional<T>::is_initialized() const ;`]

-* [*Returns: ] `true` if the `optional` is initialized, `false` otherwise.
-* [*Throws:] Nothing.
-* [*Example:]

+* [*Returns: ] `true` if the `optional` is initialized, `false`otherwise.\n

+  [*返回：]`true` 如果 `optional` 已初始化，否则 `false`.
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
+* [*Example:]\n
+  [*例子：]
 ``
 optional<T> def ;
 assert ( !def.is_initialized() );
@@ -698,8 +827,10 @@

 [: `optional<T` ['(not a ref)]`> make_optional( T const& v )`]

-* [*Returns: ] `optional<T>(v)` for the ['deduced] type `T` of `v`.
-* [*Example:]
+* [*Returns: ] `optional<T>(v)` for the ['deduced] type `T` of `v`.\n
+  [*返回：]`optional<T>(v)`，从 `v` ['推断]类型 `T` .
+* [*Example:]\n
+  [*例子：]
 ``
 template<class T> void foo ( optional<T> const& opt ) ;

@@ -712,8 +843,10 @@

[: `optional<T` ['(not a ref)]`> make_optional( bool condition, T const& v)`]

-* [*Returns: ] `optional<T>(condition,v)` for the ['deduced] type `T` of`v`.

-* [*Example:]

+* [*Returns: ] `optional<T>(condition,v)` for the ['deduced] type `T` of`v`.\n

+  [*返回：]`optional<T>(condition,v)`，从 `v` ['推断]类型 `T`.
+* [*Example:]\n
+  [*例子：]
 ``
 optional<double> calculate_foo()
 {
@@ -733,13 +866,18 @@
 [: `bool operator == ( optional<T> const& x, optional<T> const& y );`]

 * [*Returns:] If both `x` and `y` are initialized, `(*x == *y)`. If only
-`x` or `y` is initialized, `false`. If both are uninitialized, `true`.
-* [*Throws:] Nothing.
+`x` or `y` is initialized, `false`. If both are uninitialized, `true`.\n

+ [*返回：]如果 `x` 和 `y` 均已初始化，则返回 `(*x == *y)`. 如果只有 `x`或 `y` 已初始化，则返回 `false`. 如果均未初始化，则返回 `true`.

+* [*Throws:] Nothing.\n
+  [*抛出：]无。
 * [*Notes:] Pointers have shallow relational operators while `optional` has
 deep relational operators. Do not use `operator ==` directly in generic
 code which expect to be given either an `optional<T>` or a pointer; use
-__FUNCTION_EQUAL_POINTEES__ instead
-* [*Example:]
+__FUNCTION_EQUAL_POINTEES__ instead\n
+  [*说明：]指针的比较操作符是"浅比较"的，而 `optional` 是"深比较"的。

+ 不要在使用 `optional<T>` 或指针的泛型代码中直接使用 `operator ==`；应使用 __FUNCTION_EQUAL_POINTEES__ 来替代。

+* [*Example:]\n
+  [*例子：]
 ``
 T x(12);
 T y(12);
@@ -750,17 +888,17 @@
 optional<T> optY(y);
 optional<T> optZ(z);

-// Identity always hold
+// Identity always hold 总是保持同一性
 assert ( def0 == def0 );
 assert ( optX == optX );

-// Both uninitialized compare equal
+// Both uninitialized compare equal 未初始化的对象是相等的
 assert ( def0 == def1 );

-// Only one initialized compare unequal.
+// Only one initialized compare unequal. 只有一个初始化对象则是不等的
 assert ( def0 != optX );

-// Both initialized compare as (*lhs == *rhs)

+// Both initialized compare as (*lhs == *rhs) 已初始化的对象则要比较 (*lhs== *rhs)

 assert ( optX == optY ) ;
 assert ( optX != optZ ) ;
 ``
@@ -773,12 +911,18 @@

 * [*Returns:] If `y` is not initialized, `false`. If `y` is initialized
 and `x` is not initialized, `true`. If both `x` and `y` are initialized,
-`(*x < *y)`.
-* [*Throws:] Nothing.
+`(*x < *y)`.\n

+ [*返回：]如果 `y` 未初始化，则返回 `false`. 如果 `y` 已初始而 `x` 未初始化，则返回 `true`.

+  如果 `x` 和 `y` 均已初始化，则返回 `(*x < *y)`.
+* [*Throws:] Nothing.\n
+  [*抛出：]无。
 * [*Notes:] Pointers have shallow relational operators while `optional` has
 deep relational operators. Do not use `operator <` directly in generic code

-which expect to be given either an `optional<T>` or a pointer; use__FUNCTION_LESS_POINTEES__ instead.

-* [*Example:]

+which expect to be given either an `optional<T>` or a pointer; use__FUNCTION_LESS_POINTEES__ instead.\n

+  [*说明：]指针的比较操作符是"浅比较"的，而 `optional` 是"深比较"的。

+ 不要在使用 `optional<T>` 或指针的泛型代码中直接使用 `operator <`；应使用__FUNCTION_LESS_POINTEES__ 来替代。

+* [*Example:]\n
+  [*例子：]
 ``
 T x(12);
 T y(34);
@@ -786,17 +930,17 @@
 optional<T> optX(x);
 optional<T> optY(y);

-// Identity always hold
+// Identity always hold 总是保持同一性
 assert ( !(def < def) );
 assert ( optX == optX );

-// Both uninitialized compare equal
+// Both uninitialized compare equal 两个未初始化对象是相等的
 assert ( def0 == def1 );

-// Only one initialized compare unequal.
+// Only one initialized compare unequal. 只有一个已初始化对象则是不等的
 assert ( def0 != optX );

-// Both initialized compare as (*lhs == *rhs)

+// Both initialized compare as (*lhs == *rhs) 两个已初始化对象则要比较(*lhs == *rhs)

 assert ( optX == optY ) ;
 assert ( optX != optZ ) ;
 ``
@@ -807,8 +951,10 @@

 [: `bool operator != ( optional<T> const& x, optional<T> const& y );`]

-* [*Returns: ] `!( x == y );`
-* [*Throws:] Nothing.
+* [*Returns: ] `!( x == y );`\n
+  [*返回：]`!( x == y );`
+* [*Throws:] Nothing.\n
+  [*抛出：]无。

 __SPACE__

@@ -816,8 +962,10 @@

 [: `bool operator > ( optional<T> const& x, optional<T> const& y );`]

-* [*Returns: ] `( y < x );`
-* [*Throws:] Nothing.
+* [*Returns: ] `( y < x );`\n
+  [*返回：]`( y < x );`
+* [*Throws:] Nothing.\n
+  [*抛出：]无。

 __SPACE__

@@ -825,8 +973,10 @@

 [: `bool operator <= ( optional<T> const& x, optional<T> const& y );`]

-* [*Returns: ] `!( y<x );`
-* [*Throws:] Nothing.
+* [*Returns: ] `!( y<x );`\n
+  [*返回：]`!( y<x );`
+* [*Throws:] Nothing.\n
+  [*抛出：]无。

 __SPACE__

@@ -834,8 +984,10 @@

 [: `bool operator >= ( optional<T> const& x, optional<T> const& y );`]

-* [*Returns: ] `!( x<y );`
-* [*Throws:] Nothing.
+* [*Returns: ] `!( x<y );`\n
+  [*返回：]`!( x<y );`
+* [*Throws:] Nothing.\n
+  [*抛出：]无。

 __SPACE__

@@ -845,18 +997,27 @@

 * [*Effect:] If both `x` and `y` are initialized, calls `swap(*x,*y)`
 using `std::swap`. If only one is initialized, say `x`, calls:
-`y.reset(*x); x.reset();` If none is initialized, does nothing.
-* [*Postconditions:] The states of `x` and `y` interchanged.
+`y.reset(*x); x.reset();` If none is initialized, does nothing.\n

+ [*作用：]如果 `x` 和 `y` 均已初始化，则调用 `swap(*x,*y)`，使用`std::swap`.+ 如果只有一个已初始化，如 `x`, 则调用：`y.reset(*x); x.reset();`. 如果均未初始化，则为空操作。

+* [*Postconditions:] The states of `x` and `y` interchanged.\n
+  [*后续条件：]`x` 和 `y` 的状态被交换。

* [*Throws:] If both are initialized, whatever `swap(T&,T&)` throws. Ifonly

-one is initialized, whatever `T::T ( T const& )` throws.
+one is initialized, whatever `T::T ( T const& )` throws.\n

+ [*抛出：]如果均已初始化，则抛出 `swap(T&,T&)` 所抛出的任何异常。如果只有一个已初始化，则抛出 `T::T ( T const& )` 所抛出的任何异常。

 * [*Notes:] If both are initialized, `swap(T&,T&)` is used unqualified but
 with `std::swap` introduced in scope.
-If only one is initialized, `T::~T()` and `T::T( T const& )` is called.
+If only one is initialized, `T::~T()` and `T::T( T const& )` is called.\n

+ [*说明：]如果均已初始化，则使用未限定的 `swap(T&,T&)`，不过 `std::swap`被引入到当前域中。

+  如果只有一个已初始化，则调用 `T::~T()` 和 `T::T( T const& )` .
 * [*Exception Safety:] If both are initialized, this operation has the
 exception safety guarantees of `swap(T&,T&)`.
 If only one is initialized, it has the same basic guarantee as
-`optional<T>::reset( T const& )`.
-* [*Example:]
+`optional<T>::reset( T const& )`.\n

+ [*异常安全性：]如果均已初始化，则该操作具有 `swap(T&,T&)` 的异常安全性保证。+ 如果只有一个已初始化，则该操作具有和 `optional<T>::reset( T const& )` 一样的基本保证。

+* [*Example:]\n
+  [*例子：]
 ``
 T x(12);
 T y(21);
=======================================
--- /trunk/libs/optional/doc/special_cases.qbk  Mon Feb  8 07:24:10 2010
+++ /trunk/libs/optional/doc/special_cases.qbk  Wed Mar 24 00:54:49 2010
@@ -1,56 +1,71 @@
-
-[section Optional references]
+
+[section:optional_references Optional references  Optional引用]

 This library allows the template parameter `T` to be of reference type:
-`T&`, and to some extent, `T const&`.
+`T&`, and to some extent, `T const&`.\n
+本库允许模板参数 `T` 可以是引用类型：`T&`, 及其扩展 `T const&`.

 However, since references are not real objects some restrictions apply and
-some operations are not available in this case:
-
-* Converting constructors
-* Converting assignment
-* InPlace construction
-* InPlace assignment
-* Value-access via pointer
+some operations are not available in this case:\n
+不过，由于引用不是真正的对象，所以有一些限制，有些操作不可使用：
+
+* Converting constructors\n
+  转换构造函数
+* Converting assignment\n
+  转换赋值
+* InPlace construction\n
+  就地构造
+* InPlace assignment\n
+  就地赋值
+* Value-access via pointer\n
+  通过指针的值访问

 Also, even though `optional<T&>` treats it wrapped pseudo-object much as
-a real value, a true real reference is stored so aliasing will ocurr:
+a real value, a true real reference is stored so aliasing will ocurr:\n
+而且，虽然 `optional<T&>` 在处理其包装的伪对象时与真正的值对象非常相似，
+但实际上它保存的是一个真正的引用，所以可能发生以下容易混淆的情况：

* Copies of `optional<T&>` will copy the references but all thesereferences

-will nonetheless reefer to the same object.
+will nonetheless reefer to the same object.\n

+ 复制 `optional<T&>` 将对引用进行复制，但所有被复制的引用都将引向同一个对象。

 * Value-access will actually provide access to the referenced object
-rather than the reference itself.
+rather than the reference itself.\n
+  值访问操作提供对被引用的对象而不是引用本身的访问。

 [endsect]

-[section Rebinding semantics for assignment of optional references]

+[section:rebinding_semantics_for_assignment_of_optional_referencesRebinding semantics for assignment of optional references

+optional引用赋值操作的重绑定语义]

If you assign to an ['uninitialized ] `optional<T&>` the effect is to bind(for

-the first time) to the object. Clearly, there is no other choice.
+the first time) to the object. Clearly, there is no other choice.\n

+如果你对一个['未初始化的] `optional<T&>` 进行赋值，效果将是将它绑定(对于第一次赋值)到某个对象。显然，这里没有其它的选择。


     int x = 1 ;
     int& rx = x ;
     optional<int&> ora ;
     optional<int&> orb(x) ;
-    ora = orb ; // now 'ora' is bound to 'x' through 'rx'
-    *ora = 2 ; // Changes value of 'x' through 'ora'

+ ora = orb ; // now 'ora' is bound to 'x' through 'rx' 现在'ora'通过'rx'被绑定到'x'

+    *ora = 2 ; // Changes value of 'x' through 'ora'  通过'ora'修改'x'的值
     assert(x==2);

 If you assign to a bare C++ reference, the assignment is forwarded to the
-referenced object; it's value changes but the reference is never rebound.
+referenced object; it's value changes but the reference is never rebound.\n

+如果你对一个C++裸引用进行赋值，赋值的操作将被前转至被引用的对象；结果是被引用对象的值被改变而引用本身不会被重绑定。


     int a = 1 ;
     int& ra = a ;
     int b = 2 ;
     int& rb = b ;
-    ra = rb ; // Changes the value of 'a' to 'b'
+    ra = rb ; // Changes the value of 'a' to 'b'  修改'a'的值为'b'
     assert(a==b);
     b = 3 ;
-    assert(ra!=b); // 'ra' is not rebound to 'b'
+    assert(ra!=b); // 'ra' is not rebound to 'b'  'ra'不会重绑定到'b'

 Now, if you assign to an ['initialized ] `optional<T&>`, the effect is to

[*rebind] to the new object instead of assigning the referee. This isunlike

-bare C++ references.
+bare C++ references.\n

+现在，如果你对一个['已初始化的] `optional<T&>` 进行赋值，结果将是[*重绑定]到新的对象，而不是对引用物进行赋值。这和C++裸引用是不一样的。


     int a = 1 ;
     int b = 2 ;
@@ -58,23 +73,26 @@
     int& rb = b ;
     optional<int&> ora(ra) ;
     optional<int&> orb(rb) ;
-    ora = orb ; // 'ora' is rebound to 'b'
-    *ora = 3 ; // Changes value of 'b' (not 'a')
+    ora = orb ; // 'ora' is rebound to 'b'  'ora'被重绑定至'a'
+    *ora = 3 ; // Changes value of 'b' (not 'a')  修改'b'(而不是'a')的值
     assert(a==1);
     assert(b==3);

-[heading Rationale]
+[heading:rationale Rationale 原理]

Rebinding semantics for the assignment of ['initialized ] `optional`references hasbeen chosen to provide [*consistency among initialization states] even atthe

 expense of lack of consistency with the semantics of bare C++ references.
 It is true that `optional<U>` strives to behave as much as possible as `U`

does whenever it is initialized; but in the case when `U` is `T&`, doingso would

-result in inconsistent behavior w.r.t to the lvalue initialization state.
+result in inconsistent behavior w.r.t to the lvalue initialization state.\n

+对['已初始化的] `optional` 引用的赋值操作的重绑定语义提供了[*对初始化状态的一致性]，这是以违反C++裸引用语义为代价的。+确实，`optional` 尽可能表现得和 `U` 一样，不论它是否已初始化；但是如果`U` 是 `T&`, 这样做就会导致和左值初始化状态相关的不一致行为。


 Imagine `optional<T&>` forwarding assignment to the referenced object (thus
 changing the referenced object value but not rebinding), and consider the
-following code:
+following code:\n

+设想 `optional<T&>` 将赋值操作前转至被引用的对象(修改被引用的对象而不是重绑定)，考虑一下以下代码：


     optional<int&> a = get();
     int x = 1 ;
@@ -82,20 +100,26 @@
     optional<int&> b(rx);
     a = b ;

-What does the assignment do?
+What does the assignment do?\n
+这个赋值操作会做什么？

If `a` is ['uninitialized], the answer is clear: it binds to `x` (we nowhave

 another reference to `x`).
 But what if `a` is already ['initialized]? it would change the value of the
 referenced object (whatever that is); which is inconsistent with the other
-possible case.
+possible case.\n

+如果 `a` 是['未初始化的]，那么答案非常清楚：它将被绑定到 `x` (这样我们就有了第二个到 `x` 的引用)。+但是如果 `a` 已经['初始化]了呢？那么这个赋值操作可能会修改被引用对象(无论它是什么)的值，但是这样做就会和在未初始化情形下的行为不一致。

If `optional<T&>` would assign just like `T&` does, you would never beable to

 use Optional's assignment without explicitly handling the previous
 initialization state unless your code is capable of functioning whether
-after the assignment, `a` aliases the same object as `b` or not.
-
-That is, you would have to discriminate in order to be consistency.
+after the assignment, `a` aliases the same object as `b` or not.\n

+如果 `optional<T&>` 的赋值只是象 `T&` 那样做，你就永远不能在没有显式处理过原先的已初始化状态的时候使用 Optional 的赋值，

+除非你的代码能够判断在这个赋值之后，`a` 是 `b` 的别名抑或不是。
+
+That is, you would have to discriminate in order to be consistency.\n
+即，你不得不为了一致性而进行分别处理。

 If in your code rebinding to another object is not an option, then is very

likely that binding for the fist time isn't either. In such case,assignment

@@ -103,20 +127,25 @@
 that in such scenario the precondition that the lvalue must be already
 initialized exist. If it doesn't, then binding for the first time is OK
 while rebinding is not which is IMO very unlikely.
-In such scenario, you can assign the value itself directly, as in:
+In such scenario, you can assign the value itself directly, as in:\n

+如果将引用绑定到另一个对象对于你的代码来说是错误的，那么在第一次的时候通过赋值操作来绑定而不是初始化很可能也是错误的。+在这种情况下，赋值到一个['未初始化的] `optional<T&>` 应该被禁止。很可能这种情况下前提条件是，左值必须是已初始化的。+若非如此，则第一次的绑定是对的，而重绑定是错误的，这通常不大可能。这种情况下你可以直接向它赋值，如：


     assert(!!opt);
     *opt=value;

 [endsect]

-[section In-Place Factories]
+[section:in_place_factories In-Place Factories 就地创建]

 One of the typical problems with wrappers and containers is that their
 interfaces usually provide an operation to initialize or assign the
 contained object as a copy of some other object. This not only requires the

underlying type to be __COPY_CONSTRUCTIBLE__, but also requires theexistence of

-a fully constructed object, often temporary, just to follow the copy from:

+a fully constructed object, often temporary, just to follow the copyfrom:\n+使用包装器和容器的一个常见问题是，它们通常会有一个接口提供一个操作，将所含对象初始化或赋值为另一个对象的拷贝。+这不仅要求底层的类型是 __COPY_CONSTRUCTIBLE__，而且还要求一个完全构造的对象，该对象通常是临时的，仅用作复制的来源：


     struct X
     {
@@ -134,14 +163,16 @@

     void foo()
     {
-        // Temporary object created.
+        // Temporary object created.  创建临时对象
         W ( X(123,"hello") ) ;
     }

 A solution to this problem is to support direct construction of the
 contained object right in the container's storage.
 In this scheme, the user only needs to supply the arguments to the
-constructor to use in the wrapped object construction.
+constructor to use in the wrapped object construction.\n
+解决这一问题的一种方法是，提供在容器的存储中直接构造所含对象的支持。
+这样一来，用户只需要将相关参数提供给构造函数，用于所含对象的构造。

     class W
     {
@@ -157,21 +188,27 @@
     {
         // Wrapped object constructed in-place
         // No temporary created.
+        // 就地创建所含对象，不再需要创建临时对象。
         W (123,"hello") ;
     }

 A limitation of this method is that it doesn't scale well to wrapped
 objects with multiple constructors nor to generic code were the constructor
-overloads are unknown.
+overloads are unknown.\n

+这种方法的限制在于，它不适用于带有多个构造函数的被包装对象，也不适用于对构造函数重载不知情的泛型代码。


 The solution presented in this library is the family of [*InPlaceFactories]
 and [*TypedInPlaceFactories].
 These factories are a family of classes which encapsulate an increasing
 number of arbitrary constructor parameters and supply a method to construct
 an object of a given type using those parameters at an address specified by
-the user via placement new.
-
-For example, one member of this family looks like:
+the user via placement new.\n

+在本库中，解决的方法是 [*InPlaceFactories] 和 [*TypedInPlaceFactories] 家族。+这些工厂是一族类，这些类封装了不同参数数量的构造函数参数，提供一个方法来构造给定类型的一个对象，

+构造时使用这些被封装的参数，并通过 placement new 在用户指定的地址进行构造。
+
+For example, one member of this family looks like:\n
+例如，这个类族中的其中一个类如下：

     template<class T,class A0, class A1>
     class TypedInPlaceFactory2
@@ -185,7 +222,8 @@
         void construct ( void* p ) { new (p) T(m_a0,m_a1) ; }
      } ;

-A wrapper class aware of this can use it as:
+A wrapper class aware of this can use it as:\n
+一个包装类可以这样来使用它：

     class W
     {
@@ -201,21 +239,27 @@
     {
         // Wrapped object constructed in-place via a TypedInPlaceFactory.
         // No temporary created.
+        // 通过 TypedInPlaceFactory 就地构造被包装对象。无需创建临时对象。
         W ( TypedInPlaceFactory2<X,int,std::string>(123,"hello")) ;
     }

-The factories are divided in two groups:
+The factories are divided in two groups:\n
+这些工厂类被分为两组：

 * [_TypedInPlaceFactories]: those which take the target type as a primary
-template parameter.
+template parameter.\n
+  [_TypedInPlaceFactories]: 它们以目标类型作为主模板参数。
 * [_InPlaceFactories]: those with a template `construct(void*)` member
-function taking the target type.
+function taking the target type.\n

+ [_InPlaceFactories]: 它们以模板化的 `construct(void*)` 成员函数来接受目标类型。


 Within each group, all the family members differ only in the number of
-parameters allowed.
+parameters allowed.\n
+在每一组中，所有类族成员仅在可接受的参数数量上有所不同。

 This library provides an overloaded set of helper template functions to

-construct these factories without requiring unnecessary templateparameters:+construct these factories without requiring unnecessary templateparameters:\n

+本库还提供了一组重载的模板函数来构造这些工厂类，从而无需给定模板参数：

     template<class A0,...,class AN>

InPlaceFactoryN <A0,...,AN> in_place ( A0 const& a0, ..., AN const&aN) ;

@@ -223,7 +267,8 @@
     template<class T,class A0,...,class AN>

TypedInPlaceFactoryN <T,A0,...,AN> in_place ( T const& a0, A0 const&a0, ..., AN const& aN) ;

-In-place factories can be used generically by the wrapper and user asfollows:+In-place factories can be used generically by the wrapper and user asfollows:\n

+就地创建可以被包装器和用户泛型地使用，如下：

     class W
     {
@@ -242,28 +287,36 @@
     {
         // Wrapped object constructed in-place via a InPlaceFactory.
         // No temporary created.
+        // 通过 InPlaceFactory 就地构造被包装的对象。无需创建临时对象。
         W ( in_place(123,"hello") ) ;
     }

-The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and__TYPED_IN_PLACE_FACTORY_HPP__+The factories are implemented in the headers: __IN_PLACE_FACTORY_HPP__ and__TYPED_IN_PLACE_FACTORY_HPP__\n+这些工厂类在头文件 __IN_PLACE_FACTORY_HPP__ 和__TYPED_IN_PLACE_FACTORY_HPP__ 中实现。


 [endsect]

-[section A note about optional<bool>]
-
-`optional<bool>` should be used with special caution and consideration.

+[section:a_note_about_optional_bool_ A note about optional<bool> 关于optional<bool>的说明]

+
+`optional<bool>` should be used with special caution and consideration.\n
+`optional<bool>` 在使用时需要特别小心和留意。

 First, it is functionally similar to a tristate boolean (false,maybe,true)

--such as __BOOST_TRIBOOL__-- except that in a tristate boolean, the maybestate[_represents a valid value], unlike the corresponding state of anuninitialized

 `optional<bool>`.

It should be carefully considered if an `optional<bool>` instead of a`tribool`

-is really needed.
+is really needed.\n

+首先，它的功能类似于三态布尔类型(false,maybe,true) -- 如 __BOOST_TRIBOOL__-- 只有一点区别，+即在三态布尔类型中，maybe 状态[_代表了一个有效的值]，而不是未初始化的`optional<bool>` 的相应状态。

+如果真的要用 `optional<bool>` 替代 `tribool`，你要非常小心谨慎。

 Second, `optional<>` provides an implicit conversion to `bool`. This

conversion refers to the initialization state and not to the containedvalue.

 Using `optional<bool>` can lead to subtle errors due to the implicit `bool`
-conversion:
+conversion:\n

+其次，`optional<>` 提供了到 `bool` 的隐式转换。该转换表示了所含值是否为已初始化状态。

+使用 `optional<bool>` 可能会由于这个到 `bool` 的隐式转换而导致微妙的错误：

     void foo ( bool v ) ;
     void bar()
@@ -271,20 +324,24 @@
         optional<bool> v = try();

         // The following intended to pass the value of 'v' to foo():
+        // 下面将 'v' 的值传递给 foo():
         foo(v);
         // But instead, the initialization state is passed
         // due to a typo: it should have been foo(*v).
+        // 但是实际上，被传递的是初始化状态。正确的写法应该是：foo(*v).
     }

 The only implicit conversion is to `bool`, and it is safe in the sense that
 typical integral promotions don't apply (i.e. if `foo()` takes an `int`
-instead, it won't compile).
+instead, it won't compile).\n

+隐式转换只是转为 `bool`, 不会对其进行整型类型的提升，所以它还是安全的(例如，如果 `foo()` 接受的是一个 `int`, 它将不能编译)。


 [endsect]

-[section Exception Safety Guarantees]
-

-Because of the current implementation (see [linkboost_optional.implementation_notes Implementation Notes]), all of theassignment methods:+[section:exception_safety_guarantees Exception Safety Guarantees 异常安全性保证]

+Because of the current implementation (see [linkboost_optional.implementation_notes Implementation Notes]), all of theassignment methods:\n+由于当前的实现(请见 [link boost_optional.implementation_notes 实现说明])，所有赋值方法：


 * `optional<T>::operator= ( optional<T> const& )`
 * `optional<T>::operator= ( T const& )`
@@ -295,22 +352,28 @@

 Can only ['guarantee] the [_basic exception safety]: The lvalue optional is

left [_uninitialized] if an exception is thrown (any previous value is['first]

-destroyed using `T::~T()`)
-
-On the other hand, the ['uninitializing] methods:
+destroyed using `T::~T()`)\n

+只能['保证][_基本的异常安全性]：如果有异常被抛出，则左值 optional 将保持为[_未初始化] (原来的值会['首先]用 `T::~T()` 销毁)。

+
+On the other hand, the ['uninitializing] methods:\n
+另一方面，['去初始化]方法：

 * `optional<T>::operator= ( detail::none_t )`
 * `optional<T>::reset()`

-Provide the no-throw guarantee (assuming a no-throw `T::~T()`)
+Provide the no-throw guarantee (assuming a no-throw `T::~T()`)\n
+提供了无抛出保证(假定 `T::~T()` 是无抛出的)。

 However, since `optional<>` itself doesn't throw any exceptions, the only

source for exceptions here are `T`'s constructor, so if you know theexceptionguarantees for `T::T ( T const& )`, you know that `optional`'s assignmentand

-reset has the same guarantees.
+reset has the same guarantees.\n

+不过，由于 `optional<>` 本身不抛出任何异常，所以在这里异常的唯一来源是 `T`的构造函数，+如果你知道 `T::T ( T const& )` 的异常安全性保证，那么你就可以知道`optional` 的赋值和重置都具有相同的保证。


     //
     // Case 1: Exception thrown during assignment.
+    // Case 1: 在赋值时抛出异常。
     //
     T v0(123);
     optional<T> opt0(v0);
@@ -321,16 +384,19 @@
         opt0 = opt1 ;

         // If no exception was thrown, assignment succeeded.
+        // 如果没有异常抛出，则赋值成功。
         assert( *opt0 == v1 ) ;
     }
     catch(...)
     {
         // If any exception was thrown, 'opt0' is reset to uninitialized.
+        // 如果有任何异常抛出，则 'opt0' 被重置为未初始化。
         assert( !opt0 ) ;
     }

     //
     // Case 2: Exception thrown during reset(v)
+    // Case 2: 在 reset(v) 时抛出异常
     //
     T v0(123);
     optional<T> opt(v0);
@@ -340,15 +406,17 @@
         opt.reset ( v1 ) ;

         // If no exception was thrown, reset succeeded.
+        // 如果没有异常抛出，则重置成功。
         assert( *opt == v1 ) ;
     }
     catch(...)
     {
         // If any exception was thrown, 'opt' is reset to uninitialized.
+        // 如果有任何异常抛出，则 'opt' 被重置为未初始化。
         assert( !opt ) ;
     }

-[heading Swap]
+[heading Swap 交换]

 `void swap( optional<T>&, optional<T>& )` has the same exception guarantee
 as `swap(T&,T&)` when both optionals are initialized.
@@ -356,16 +424,21 @@
 exception guarantee as `optional<T>::reset( T const& )` (since
 `optional<T>::reset()` doesn't throw).
 If none of the optionals is initialized, it has no-throw guarantee
-since it is a no-op.
+since it is a no-op.\n

+`void swap( optional<T>&, optional<T>& )` 在两个 `optional` 均已初始化时，具有与 `swap(T&,T&)` 相同的异常保证。+如果只有一个 `optional` 是已初始化的，则它提供与 `optional<T>::reset( Tconst& )` 一样的['基本]异常保证+(因为 `optional<T>::reset( T const& )` 不会抛出)。如果两个 `optional` 均未初始化，则它具有无抛出保证，因为这是一个空操作。


 [endsect]

-[section Type requirements]
+[section:type_requirements Type requirements 类型要求]

In general, `T` must be __COPY_CONSTRUCTIBLE__ and have a no-throwdestructor.-The copy-constructible requirement is not needed if [*InPlaceFactories]are used.

-
-`T` [_is not] required to be __SGI_DEFAULT_CONSTRUCTIBLE__.

+The copy-constructible requirement is not needed if [*InPlaceFactories]are used.\n+通常，`T` 必须是 __COPY_CONSTRUCTIBLE__ 且具有无抛出的析构函数。如果使用[*InPlaceFactories]，则无须要求可复制构造。

+
+`T` [_is not] required to be __SGI_DEFAULT_CONSTRUCTIBLE__.\n
+`T` [_并不]要求是 __SGI_DEFAULT_CONSTRUCTIBLE__。

 [endsect]

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

Other related posts: