Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

TR1 的分類

引用包裝器
智能指針
類模板 result_of.
函數模板 mem_fn.
函數對像綁定器
多態函數包裝器
Type Traits.
隨機數生成器和分發
Tuples.
std::pair 的 tuple 接口
固定大小數組
散列函數對像
正則表達式
複數算法重載
其它複數算法
無序關聯集合(散列表).
無序關聯映射(散列表).
數學特殊函數
C99 數學特殊函數

引 用包裝器

#include <boost/tr1/functional.hpp>

#include <functional>

Ref 庫是一個小庫,用於將引用傳遞給通常要對參數進行複製的函數模板(算法)。它定義了類模板 reference_wrapper<T>, 以及返回 reference_wrapper<T> 實例的兩個函數 refcref. 更 多信息請參見 Boost.Bind.

namespace std {
namespace tr1 {
template <class T> class reference_wrapper;
template <class T> reference_wrapper<T> ref(T&);
template <class T> reference_wrapper<const T> cref(const T&);
template <class T> reference_wrapper<T> ref(reference_wrapper<T>);
template <class T> reference_wrapper<const T> cref(reference_wrapper<T>);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_REFERENCE_WRAPPER,如果你的標準庫實現了這部分 TR1.

標準符合性:這 一組件的 Boost 版本當前不支持函數調用(2.1.2.4),或是從 std::unary_function 或 std::binary_function 派生(2.1.2 第 3 段和第 4 段)。

Boost 版本不能像 TR 要求的那樣提供到 T& 的隱式轉換。

智 能指針

#include <boost/tr1/memory.hpp>

#include <memory>

shared_ptr 類模板保存一個指向動態分配對象的指針,該對像通常是用 C++ 的new-表達式得到的。當最後一個指向該對象的 shared_ptr 被銷毀或重置時,將確保被指對像被刪除。更多信息,請參考 shared_ptrweak_ptr 的文檔。

namespace std {
namespace tr1 {
class bad_weak_ptr;
// [2.2.3] 類模板 shared_ptr
template<class T> class shared_ptr;
// [2.2.3.6] shared_ptr 的比較操作
template<class T, class U> bool operator==(shared_ptr<T> const& a, shared_ptr<U> const& b);
template<class T, class U> bool operator!=(shared_ptr<T> const& a, shared_ptr<U> const& b);
template<class T, class U> bool operator<(shared_ptr<T> const& a, shared_ptr<U> const& b);
// [2.2.3.8] shared_ptr 的特化算法
template<class T> void swap(shared_ptr<T>& a, shared_ptr<T>& b);
// [2.2.3.9] shared_ptr 的轉型
template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const& r);
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r);
template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r);
// [2.2.3.7] shared_ptr I/O
template<class E, class T, class Y>
basic_ostream<E, T>& operator<< (basic_ostream<E, T>& os, shared_ptr<Y> const& p);
// [2.2.3.10] shared_ptr get_deleter
template<class D, class T> D * get_deleter(shared_ptr<T> const& p);
// [2.2.4] 類模板 weak_ptr
template<class T> class weak_ptr;
// [2.2.4.6] weak_ptr 的比較操作
template<class T, class U> bool operator<(weak_ptr<T> const& a, weak_ptr<U> const& b);
// [2.2.4.7] weak_ptr 的特化算法
template<class T> void swap(weak_ptr<T>& a, weak_ptr<T>& b);
// [2.2.5] 類 enable_shared_from_this
template<class T> class enable_shared_from_this;
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_SHARED_PTR,如果你的標準庫實現了這部分 TR1.

標準符合性:使 用該組件的 Boost 版本時,沒有已知的與標準不符的地方。

類 模板 result_of.

#include <boost/tr1/functional.hpp>

#include <functional>

類模板 result_of 幫助確定函數調用表達式的類型。給定類型 F 的一個左值 f 以及類型分別為  T1, T2, ..., TN 的左值 t1, t2, ..., tN, 類型 result_of<F(T1, T2, ..., TN)>::type 定義了表達式 f(t1, t2, ...,tN) 的結果類型。該實現允許類型 F 為函數指針、函數引用、成員函數指針或類類型。更多信息請 參 見 Boost.Utility 的文檔。

namespace std {
namespace tr1 {
template <class T>
struct result_of
{
typedef unspecified type;
};
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_RESULT_OF,如果你的標準庫實現了這部分 TR1.

標準符合性:沒 有已知的問題。

函 數模板 mem_fn.

#include <boost/tr1/functional.hpp>

#include <functional>

std::tr1::mem_fn 是標準函數 std::mem_funstd::mem_fun_ref 的泛化。它支持多於一個參數的成員函數指針,且返回的函數對象可以以指向一個對像實例的指針、引用或智能指針作為第一個參數。mem_fn 還支持數據成員指針,像不帶參數的函數那樣處理它們,返回該成員的一個(const)引用。更多信息請參見 Boost.Mem_fn 的文檔。

namespace std {
namespace tr1 {
template <class R, class T> unspecified mem_fn(R T::* pm);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_MEM_FN,如果你的標準為實現了這部分 TR1.

標準符合性:Boost 的實現不生成繼承自 std::unary_functionstd::binary_function 的仿函數,也不能正確處理指向 volatile 成員函數的指針(在實際上極為罕見)。

函 數對像綁定器

#include <boost/tr1/functional.hpp>

#include <functional>

std::tr1::bind 是標準函數 std::bind1ststd::bind2nd 的泛化。它支持任意函數對像、函數、函數指針和成員函數指針,而且可以將任何參數綁定到一個特定值或將輸入的參數換到任意位置。bind 對函數對像沒有任何要求;具體說,它不需要 result_type, first_argument_typesecond_argument_type 等標準的 typedefs. 更多信息請參見 Boost.Bind 的文檔

namespace std {
namespace tr1 {
// [3.6] 函數對像綁定器
template<class T> struct is_bind_expression;
template<class T> struct is_placeholder;
template<class F, class T1, ..., class Tn > unspecified bind(F f, T1 t1, ..., Tn tn );
template<class R, class F, class T1, ..., class Tn > unspecified bind(F f, T1 t1, ..., Tn tn );
namespace placeholders {
// M 為實現定義的佔位符數量
extern unspecified _1;
extern unspecified _2;
.
.
.
extern unspecified _M;
}
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_BIND,如果你的標準庫實現了這部分 TR1.

標準符合性:在 Boost 實現中,不支持 traits 類 is_placeholderis_bind_expression.

如果被綁定的對象是函數指針,則不支持命名返回值,例如:

std::tr1::bind(&my_proc, arg1, arg2 /* etc */); // 工作正常。
std::tr1::bind<double>(&my_proc, arg1, arg2 /* etc */); // 引起編譯錯誤。
std::tr1::bind<double>(my_function_object, arg1, arg2 /* etc */); // 工作正常。

另一方面,Boost 實現可以使用指向重載函數的指針,以及可選地支持非標準調用法的函數指針。

多 態函數包裝器

#include <boost/tr1/functional.hpp>

#include <functional>

多態函數包裝器是一族類模板,它們可用於泛型的回調機制。多態函數包裝器共享了函數指針的特性,它們均定義了可被任意代碼所調用的接口 (例如一個接 受兩個整型參數並返回一個浮點值的函數)。但是,多態函數包裝器可以用兼容的調用符號來調用任何可調用對象,可能是函數指針,或者是由 std::tr1::bind 或其它機制產生的函數對象。更多信息請參見 Boost.Function 的文檔

namespace std {
namespace tr1 {
// [3.7] 多態函數包裝器
class bad_function_call;
template<class Function>
class function;
template<class Function>
void swap(function<Function>&, function<Function>&);
template<class Function1, class Function2>
void operator==(const function<Function1>&, const function<Function2>&);
template<class Function1, class Function2>
void operator!=(const function<Function1>&, const function<Function2>&);
template <class Function>
bool operator==(const function<Function>&, unspecified-null-pointer-type );
template <class Function>
bool operator==(unspecified-null-pointer-type , const function<Function>&);
template <class Function>
bool operator!=(const function<Function>&, unspecified-null-pointer-type );
template <class Function>
bool operator!=(unspecified-null-pointer-type , const function<Function>&);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_FUNCTION,如果你的標準庫實現了這部分 TR1.

標準符合性:Boost 版本的 std::tr1::function 缺少成員函數 target_type(),並且在使用時不是繼承自 std::unary_functionstd::binary_function. 當它們被包裝在 mem_fn 中時,成員函數 target() 只能訪問成員指針目標。

Type Traits.

#include <boost/tr1/type_traits.hpp>

#include <type_traits>

Type traits 使得泛型代碼可以訪問一個類型的基本屬性,以決定兩個類型之間的關係,或者將一個類型轉換為另一個相關類型。更多信息請參見 Boost.Type_traits 的文檔

namespace std {
namespace tr1 {
template <class T, T v> struct integral_constant;
typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;
// [4.5.1] 基本類型類別:
template <class T> struct is_void;
template <class T> struct is_integral;
template <class T> struct is_floating_point;
template <class T> struct is_array;
template <class T> struct is_pointer;
template <class T> struct is_reference;
template <class T> struct is_member_object_pointer;
template <class T> struct is_member_function_pointer;
template <class T> struct is_enum;
template <class T> struct is_union;
template <class T> struct is_class;
template <class T> struct is_function;
// [4.5.2] 組合類型類別:
template <class T> struct is_arithmetic;
template <class T> struct is_fundamental;
template <class T> struct is_object;
template <class T> struct is_scalar;
template <class T> struct is_compound;
template <class T> struct is_member_pointer;
// [4.5.3] 類型屬性:
template <class T> struct is_const;
template <class T> struct is_volatile;
template <class T> struct is_pod;
template <class T> struct is_empty;
template <class T> struct is_polymorphic;
template <class T> struct is_abstract;
template <class T> struct has_trivial_constructor;
template <class T> struct has_trivial_copy;
template <class T> struct has_trivial_assign;
template <class T> struct has_trivial_destructor;
template <class T> struct has_nothrow_constructor;
template <class T> struct has_nothrow_copy;
template <class T> struct has_nothrow_assign;
template <class T> struct has_virtual_destructor;
template <class T> struct is_signed;
template <class T> struct is_unsigned;
template <class T> struct alignment_of;
template <class T> struct rank;
template <class T, unsigned I = 0> struct extent;
// [4.6] 類型關係:
template <class T, class U> struct is_same;
template <class Base, class Derived> struct is_base_of;
template <class From, class To> struct is_convertible;
// [4.7.1] const-volatile 更改:
template <class T> struct remove_const;
template <class T> struct remove_volatile;
template <class T> struct remove_cv;
template <class T> struct add_const;
template <class T> struct add_volatile;
template <class T> struct add_cv;
// [4.7.2] 引用的更改:
template <class T> struct remove_reference;
template <class T> struct add_reference;
// [4.7.3] 數組的更改:
template <class T> struct remove_extent;
template <class T> struct remove_all_extents;
// [4.7.4] 指針的更改:
template <class T> struct remove_pointer;
template <class T> struct add_pointer;
// [4.8] 其它轉換:
template <std::size_t Len, std::size_t Align> struct aligned_storage;
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_TYPE_TRAITS,如果你的標準庫實現了這部分 TR1.

標準符合性:沒 有已知的問題。

隨 機數生成器和分發

#include <boost/tr1/random.hpp>

#include <random>

隨機數庫分為三部分:生 成器,它是一些無參的函數對象,生成統一的隨機數。分發器,它也是一些無參的函數對象,將生成器適配為特定種類的分發器。以及類模 板 variate_generator,它將一個生成器和一個分配器進行組合,以 創建一個新的生成器。更多信息請參見 Boost.Random 的文檔

namespace std {
namespace tr1 {
// [5.1.3] 類模板 variate_generator
template<class UniformRandomNumberGenerator, class Distribution>
class variate_generator;
// [5.1.4.1] 類模板 linear_congruential
template<class IntType, IntType a, IntType c, IntType m>
class linear_congruential;
// [5.1.4.2] 類模板 mersenne_twister
template<class UIntType, int w, int n, int m, int r,
UIntType a, int u, int s, UIntType b, int t, UIntType c, int l>
class mersenne_twister;
// [5.1.4.3] 類模板 substract_with_carry
template<class IntType, IntType m, int s, int r>
class subtract_with_carry;
// [5.1.4.4] 類模板 substract_with_carry_01
template<class RealType, int w, int s, int r>
class subtract_with_carry_01;
// [5.1.4.5] 類模板 discard_block
template<class UniformRandomNumberGenerator, int p, int r>
class discard_block;
// [5.1.4.6] 類模板 xor_combine
template<class UniformRandomNumberGenerator1, int s1,
class UniformRandomNumberGenerator2, int s2>
class xor_combine;
// [5.1.5] 預定義的生成器
typedef linear_congruential<
implementation-defined ,
16807,
0,
2147483647> minstd_rand0;
typedef linear_congruential<
implementation-defined ,
48271,
0,
2147483647> minstd_rand;
typedef mersenne_twister<
implementation-defined ,
32, 624, 397, 31,
0x9908b0df, 11, 7,
0x9d2c5680, 15,
0xefc60000, 18> mt19937;
typedef subtract_with_carry_01<
float,
24,
10,
24> ranlux_base_01;
typedef subtract_with_carry_01<
double,
48,
10,
24> ranlux64_base_01;
typedef discard_block<
subtract_with_carry<
implementation-defined ,
(1<<24),
10,
24>,
223,
24> ranlux3;
typedef discard_block<
subtract_with_carry<
implementation-defined,
(1<<24),
10,
24>,
389,
24> ranlux4;
typedef discard_block<
subtract_with_carry_01<
float,
24,
10,
24>,
223,
24> ranlux3_01;
typedef discard_block<
subtract_with_carry_01<
float,
24,
10,
24>,
389,
24> ranlux4_01;
// [5.1.6] 類 random_device
class random_device;
// [5.1.7.1] 類模板 uniform_int
template<class IntType = int>
class uniform_int;
// [5.1.7.2] 類 bernoulli_distribution
class bernoulli_distribution;
// [5.1.7.3] 類模板 geometric_distribution
template<class IntType = int, class RealType = double>
class geometric_distribution;
// [5.1.7.4] 類模板 poisson_distribution
template<class IntType = int, class RealType = double>
class poisson_distribution;
// [5.1.7.5] 類模板 binomial_distribution
template<class IntType = int, class RealType = double>
class binomial_distribution;
// [5.1.7.6] 類模板 uniform_real
template<class RealType = double>
class uniform_real;
// [5.1.7.7] 類模板 exponential_distribution
template<class RealType = double>
class exponential_distribution;
// [5.1.7.8] 類模板 normal_distribution
template<class RealType = double>
class normal_distribution;
// [5.1.7.9] 類模板 gamma_distribution
template<class RealType = double>
class gamma_distribution;
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_RANDOM,如果你的標準庫實現了這部分 TR1.

標準符合性:Boost 實現具有以下限制:

  • linear_congruential 生成器只能完全支持有符號整數類型(無符號類型可能只能在模數為零時使用)。
  • subtract_with_carry 模板不支持以零為模數。
  • 不是所有標準生成器都有 Boost 文檔,不過它們仍被支持。
  • 類模板 variate_generator 沒有無參的模板函數調用操作符 operator(),只有非模板的無參版本。

還是注意,大多隨機數生成器都重新實現了一個對 Boost 版本的小包裝器,以提供符合標準的接口(Boost 版本的生成器均帶有一個額外的、多餘的模板參數,而且是通過迭代器而不是函數對像來初始化)。

Tuples.

#include <boost/tr1/tuple.hpp>

#include <tuple>

tuple 是一個固定大小的元素集合。Pairs, triples, quadruples 等等都是 tuples. 在編程語言中,tuple 是一個以其它對像作為元素的數據對象。這些元素對象可以是不同的類型。Tuple 在許多環境下都很方便使用。例如,tuple 可以很容易地定義返回一個以上值的函數。有些編程語言,如 ML, Python 和 Haskell, 帶有內建的 tuple 結構。不幸的是 C++ 沒有。為了彌補這個"不足",TR1 Tuple 庫用模板實現了一個 tuple 結構。更多信息請參見 Boost Tuple 庫的文檔

namespace std {
namespace tr1 {
// [6.1.3] 類模板 tuple
template <class T1 = unspecified ,
class T2 = unspecified ,
...,
class TM = unspecified > class tuple;
// [6.1.3.2] Tuple 創建函數
const unspecified ignore;
template<class T1, class T2, ..., class TN>
tuple<V1, V2, ..., VN> make_tuple(const T1&, const T2& , ..., const TN&);
// [6.1] Tuple 類型容器
template<class T1, class T2, ..., class TN>
tuple<T1&, T2&, ..., TN&> tie(T1&, T2& , ..., TN&);
// [6.1.3.3] Tuple 輔助類
template <class T> class tuple_size;
template <int I, class T> class tuple_element;
// [6.1.3.4] 元素訪問
template <int I, class T1, class T2, ..., class TN>
RI get(tuple<T1, T2, ..., TN>&);
template <int I, class T1, class T2, ..., class TN>
PI get(const tuple<T1, T2, ..., TN>&);
// [6.1.3.5] 關係操作符
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator==(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator<(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator!=(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator>(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator<=(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
template<class T1, class T2, ..., class TM, class U1, class U2, ..., class UM>
bool operator>=(const tuple<T1, T2, ..., TM>&, const tuple<U1, U2, ..., UM>&);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_TUPLE,如果你的標準庫實現了這部分 TR1.

標準符合性:在 符合標準的編譯器上沒有已知的問題。

std::pair 的 tuple 接口

#include <boost/tr1/utility.hpp>

#include <utility>

已有的類模板 std::pair, 也可以通過 tuple 接口 來訪問。

namespace std {
namespace tr1 {
template <class T> class tuple_size; // 前向聲明
template <int I, class T> class tuple_element; // 前向聲明
template <class T1, class T2> struct tuple_size<std::pair<T1, T2> >;
template <class T1, class T2> struct tuple_element<0, std::pair<T2, T2> >;
template <class T1, class T2> struct tuple_element<1, std::pair<T2, T2> >;
// "P" 的定義見後
template<int I, class T1, class T2> P& get(std::pair<T1, T2>&);
template<int I, class T1, class T2> const P& get(const std::pair<T1, T2>&);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_UTILITY,如果你的標準庫實現了這部分 TR1.

標準符合性:沒 有已知的問題。

固 定大小數組

#include <boost/tr1/array.hpp>

#include <array>

類模板 array 是一個固定大小的數組,比C風格的數組更為安全且沒有降低效率。類 array 幾乎符合可逆容器(見C++標準的第 23.1節, [lib.container.requirements])的所有要求。更多信息請參見 Boost.Array 的文檔

namespace std {
namespace tr1 {
// [6.2.2] 類模板 array
template <class T, size_t N > struct array;
// Array 的比較操作
template <class T, size_t N> bool operator== (const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N> bool operator< (const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N> bool operator!= (const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N> bool operator> (const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N> bool operator>= (const array<T,N>& x, const array<T,N>& y);
template <class T, size_t N> bool operator<= (const array<T,N>& x, const array<T,N>& y);
// [6.2.2.2] 特化的算法
template <class T, size_t N > void swap(array<T,N>& x, array<T,N>& y);
// [6.2.2.5] 類模板 array 的 tuple 接口
template <class T> class tuple_size; // 前向聲明
template <int I, class T> class tuple_element; // 前向聲明
template <class T, size_t N> struct tuple_size<array<T, N> >;
template <int I, class T, size_t N> struct tuple_element<I, array<T, N> >;
template <int I, class T, size_t N> T& get( array<T, N>&);
template <int I, class T, size_t N> const T& get(const array<T, N>&);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_ARRAY,如果你的標準庫實現了這部分 TR1.

標準符合性:沒 有 Boost-1.34 之前的已知問題。

散 列函數對像

#include <boost/tr1/functional.hpp>

#include <functional>

類模板 std::hash 是一個單參函數對象,將某個類型 T 轉換為一個散列值,對於整數、字符、浮點數、指針類型,以及兩個字符串類型 std::string 和 std::wstring 都已提供了 std::hash 的相應特化版本。更多信息請見 Boost.Hash 的文檔。

namespace std {
namespace tr1 {
template <class T>
struct hash : public unary_function<T, size_t>
{
size_t operator()(T val)const;
};
// 散列函數特化
template <> struct hash<bool>;
template <> struct hash<char>;
template <> struct hash<signed char>;
template <> struct hash<unsigned char>;
template <> struct hash<wchar_t>;
template <> struct hash<short>;
template <> struct hash<int>;
template <> struct hash<long>;
template <> struct hash<unsigned short>;
template <> struct hash<unsigned int>;
template <> struct hash<unsigned long>;
template <> struct hash<float>;
template <> struct hash<double>;
template <> struct hash<long double>;
template<class T> struct hash<T*>;
template <> struct hash<std::string>;
template <> struct hash<std::wstring>;
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_HASH,如果你的標準庫已實現了這部分 TR1.

標準符合性:Boost.Hash 增加了比 TR1 更廣範圍的 std::hash 特化版本:Boost.Hash 擔當了 Library Extension Technical Report 問題列表 中的問題 6.18 的測試床。

正 則表達式

#include <boost/tr1/regex.hpp>

#include <regex>

這個庫提供了對正則表達式的全面支持,包括基於迭代器或字符串的匹配、查找、查找並替換、迭代,以及分詞 (tokenization)。支持 POSIX 和 ECMAScript (JavaScript)的正則表達式。更多信息請參見 Boost.Regex 的文檔

namespace std {
namespace tr1 {
// [7.5] Regex 常量
namespace regex_constants {
typedef bitmask_type syntax_option_type;
typedef bitmask_type match_flag_type;
typedef implementation-defined error_type;
} // namespace regex_constants

// [7.6] 類 regex_error
class regex_error;
// [7.7] 類模板 regex_traits
template <class charT> struct regex_traits;
// [7.8] 類模板 basic_regex
template <class charT, class traits = regex_traits<charT> >
class basic_regex;
typedef basic_regex<char> regex;
typedef basic_regex<wchar_t> wregex;
// [7.8.6] basic_regex 交換
template <class charT, class traits>
void swap(basic_regex<charT, traits>& e1,
basic_regex<charT, traits>& e2);
// [7.9] 類模板 sub_match
template <class BidirectionalIterator>
class sub_match;
typedef sub_match<const char*> csub_match;
typedef sub_match<const wchar_t*> wcsub_match;
typedef sub_match<string::const_iterator> ssub_match;
typedef sub_match<wstring::const_iterator> wssub_match;
// [7.9.2] sub_match 非成員操作符

/* 為清晰起見,略過比較操作符.... */
template <class charT, class ST, class BiIter>
basic_ostream<charT, ST>&
operator<<(basic_ostream<charT, ST>& os,
const sub_match<BiIter>& m);
// [7.10] 類模板 match_results
template <class BidirectionalIterator,
class Allocator = allocator<sub_match<BidirectionalIterator> > >
class match_results;
typedef match_results<const char*> cmatch;
typedef match_results<const wchar_t*> wcmatch;
typedef match_results<string::const_iterator> smatch;
typedef match_results<wstring::const_iterator> wsmatch;
// match_results 的比較操作
template <class BidirectionalIterator, class Allocator>
bool operator== (const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
template <class BidirectionalIterator, class Allocator>
bool operator!= (const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
// [7.10.6] match_results 交換
template <class BidirectionalIterator, class Allocator>
void swap(match_results<BidirectionalIterator, Allocator>& m1,
match_results<BidirectionalIterator, Allocator>& m2);
// [7.11.2] 函數模板 regex_match
template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_match(BidirectionalIterator first,
BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator, class charT, class traits>
bool regex_match(BidirectionalIterator first,
BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class Allocator, class traits>
bool regex_match(const charT* str,
match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_match(const basic_string<charT, ST, SA>& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator,Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class traits>
bool regex_match(const charT* str,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class charT, class traits>
bool regex_match(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
// [7.11.3] 函數模板 regex_search
template <class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first,
BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class BidirectionalIterator, class charT, class traits>
bool regex_search(BidirectionalIterator first,
BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class Allocator, class traits>
bool regex_search(const charT* str,
match_results<const charT*, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class charT, class traits>
bool regex_search(const charT* str,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class ST, class SA, class Allocator, class charT, class traits>
bool regex_search(const basic_string<charT, ST, SA>& s,
match_results<typename basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
// [7.11.4] 函數模板 regex_replace
template <class OutputIterator, class BidirectionalIterator, class traits, class charT>
OutputIterator regex_replace(OutputIterator out,
BidirectionalIterator first,
BidirectionalIterator last,
const basic_regex<charT, traits>& e,
const basic_string<charT>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
template <class traits, class charT>
basic_string<charT> regex_replace(const basic_string<charT>& s,
const basic_regex<charT, traits>& e,
const basic_string<charT>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
// [7.12.1] 類模板 regex_iterator
template <class BidirectionalIterator,
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_iterator;
typedef regex_iterator<const char*> cregex_iterator;
typedef regex_iterator<const wchar_t*> wcregex_iterator;
typedef regex_iterator<string::const_iterator> sregex_iterator;
typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
// [7.12.2] 類模板 regex_token_iterator
template <class BidirectionalIterator,
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_token_iterator;
typedef regex_token_iterator<const char*> cregex_token_iterator;
typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_REGEX,如果你的標準庫實現了這部分 TR1.

標準符合性:沒 有已知的問題。

復 數算法重載

#include <boost/tr1/complex.hpp>

#include <complex>

以下函數模板有新加的重載:arg, norm, conj, polar, imag, 和 real.

這些新增的重載函數足以確保:

  • 如果參數類型為 long double, 則重載函數的行為就像這些參數已轉型為 std::complex<long double> 一樣。
  • 否則,如果參數類型為 double 或某個整數類型,則重載函數的行為就像這些參數已轉型為 std::complex<double> 一樣。
  • 否則,如果參數類型為 float, 則重載函數的行為就像這些參數已轉型為 std::complex<float> 一樣。

函數模板 pow 也有新增的重載可以確保,對於至少有一個參數類型為 std::complex<T> 的調用:

  • 如果參數類型為 complex<long double>long double, 則重載函數的行為就像兩個參數均轉型為 std::complex<long double> 一樣。
  • 否則,如果參數類型為 complex<double>, double, 或某個整數類型,則重載函數的行為就像兩個參數均轉型為 std::complex<double> 一樣。
  • 否則,如果參數類型為 complex<float>float, 則重載函數的行為就像兩個參數均轉型為 std::complex<float> 一樣。

在以下摘要中,Real 為浮點類型,Arithmetic 為整數或浮點類型,PROMOTE(X1 ... XN) 則是 X1 到 XN 的最大浮點類型,其中所有非浮點類型均替換為類型 double.

template <class Arithmetic>
PROMOTE(Arithmetic) arg(const Arithmetic& t);
template <class Arithmetic>
PROMOTE(Arithmetic) norm(const Arithmetic& t);
template <class Arithmetic>
complex<PROMOTE(Arithmetic)> conj(const Arithmetic& t);
template <class Arithmetic1, class Arithmetic2>
complex<PROMOTE(Arithmetic1,Arithmetic2)> polar(const Arithmetic1& rho, const Arithmetic2& theta = 0);
template <class Arithmetic>
PROMOTE(Arithmetic) imag(const Arithmetic& );
template <class Arithmetic>
PROMOTE(Arithmetic) real(const Arithmetic& t);
template<class Real1, class Real2>
complex<PROMOTE(Real1, Real2)>
pow(const complex<Real1>& x, const complex<Real2>& y);
template<class Real, class Arithmetic>
complex<PROMOTE(Real, Arithmetic)>
pow (const complex<Real>& x, const Arithmetic& y);
template<class Arithmetic, class Real>
complex<PROMOTE(Real, Arithmetic)>
pow (const Arithmetic& x, const complex<Real>& y);

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_COMPLEX_OVERLOADS,如果你的標準庫實現了已有複數函數的額外重載。

標準符合性:沒 有已知的問題。

其 它複數算法

#include <boost/tr1/complex.hpp>

#include <complex>

算法 acos, asin, atan, acosh, asinh, atanhfabs 均針對參數類型 std::complex<T> 進行了重載。這些算法完全是正統的,其行為符合C99標準第7.3.5節中的規定。更多信息請參見 Boost.Math 的文檔

namespace std {
namespace tr1 {
template<class T> complex<T> acos(complex<T>& x);
template<class T> complex<T> asin(complex<T>& x);
template<class T> complex<T> atan(complex<T>& x);
template<class T> complex<T> acosh(complex<T>& x);
template<class T> complex<T> asinh(complex<T>& x);
template<class T> complex<T> atanh(complex<T>& x);
template<class T> complex<T> fabs(complex<T>& x);
} // namespace tr1
} // namespace std

配置:Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG,如果你的標準庫實現了這些額外的反三角函數。

標準符合性:沒 有已知的問題。

#include <boost/tr1/unordered_set.hpp>

#include <unordered_set>

要基於鍵值查找來訪問數據,C++ 標準庫提供了 std::set, std::map, std::multiset 和 std::multimap。它們通常是用平衡二分樹實現的,所以查找時間具有對數複雜度。這通常是OK的,但是在多數情況下,散列表可以表現得更好,因 為平均來說它訪問數據具有常量時間複雜度。最壞情況下的複雜度是線性的,不過這極少發生,而且只要小心一點,是可以避免的。

考慮到這一點,C++ 標準庫技術報告引入了無序關聯容器,用散列表來實現,而且現在已經將它們增加到C++標準的工作草案中了。

更多信息就參考 Unordered 庫文檔

namespace std {
namespace tr1 {

template <class Value,
class Hash = hash<Value>,
class Pred = std::equal_to<Value>,
class Alloc = std::allocator<Value> >
class unordered_set;

// [6.3.4.5] Class template unordered_multiset
template <class Value,
class Hash = hash<Value>,
class Pred = std::equal_to<Value>,
class Alloc = std::allocator<Value> >
class unordered_multiset;

template <class Value, class Hash, class Pred, class Alloc>
void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
unordered_set<Value, Hash, Pred, Alloc>& y);

template <class Value, class Hash, class Pred, class Alloc>
void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
unordered_multiset<Value, Hash, Pred, Alloc>& y);

} // namespace tr1
} // namespace std

配置: Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_UNORDERED_SET 如果你的標準庫實現了這部分的 TR1.

標準符合性:對於符合標準的編譯器,沒 有已知的問題。

#include <boost/tr1/unordered_map.hpp>

#include <unordered_map>

要基於鍵值查找來訪問數據,C++ 標準庫提供了 std::set, std::map, std::multiset 和 std::multimap。它們通常是用平衡二分樹實現的,所以查找時間具有對數複雜度。這通常是OK的,但是在多數情況下,散列表可以表現得更好,因 為平均來說它訪問數據具有常量時間複雜度。最壞情況下的複雜度是線性的,不過這極少發生,而且只要小心一點,是可以避免的。

考慮到這一點,C++ 標準庫技術報告引入了無序關聯容器,用散列表來實現,而且現在已經將它們增加到C++標準的工作草案中了。

更多信息就參考 Unordered 庫文檔

namespace std {
namespace tr1 {

// [6.3.4.4] Class template unordered_map
template <class Key,
class T,
class Hash = hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, T> > >
class unordered_map;

// [6.3.4.6] Class template unordered_multimap
template <class Key,
class T,
class Hash = hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, T> > >
class unordered_multimap;

template <class Key, class T, class Hash, class Pred, class Alloc>
void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
unordered_map<Key, T, Hash, Pred, Alloc>& y);

template <class Key, class T, class Hash, class Pred, class Alloc>
void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
unordered_multimap<Key, T, Hash, Pred, Alloc>& y);

} // namespace tr1
} // namespace std

配置: Boost.Config 會(自動)定義宏 BOOST_HAS_TR1_UNORDERED_MAP 如果你的標準庫實現了這部分的 TR1.

標準符合性:對於符合標準的編譯器,沒 有已知的問題。

數學特殊函數

TR 在頭文件 <cmatch> 中增加了23個特殊函數(加上 float 和 long double 的重載)。

更多信息請參考 Math 庫文檔

namespace std {
namespace tr1 {

// [5.2.1.1] associated Laguerre polynomials:
double assoc_laguerre(unsigned n, unsigned m, double x);
float assoc_laguerref(unsigned n, unsigned m, float x);
long double assoc_laguerrel(unsigned n, unsigned m, long double x);

// [5.2.1.2] associated Legendre functions:
double assoc_legendre(unsigned l, unsigned m, double x);
float assoc_legendref(unsigned l, unsigned m, float x);
long double assoc_legendrel(unsigned l, unsigned m, long double x);

// [5.2.1.3] beta function:
double beta(double x, double y);
float betaf(float x, float y);
long double betal(long double x, long double y);

// [5.2.1.4] (complete) elliptic integral of the first kind:
double comp_ellint_1(double k);
float comp_ellint_1f(float k);
long double comp_ellint_1l(long double k);

// [5.2.1.5] (complete) elliptic integral of the second kind:
double comp_ellint_2(double k);
float comp_ellint_2f(float k);
long double comp_ellint_2l(long double k);

// [5.2.1.6] (complete) elliptic integral of the third kind:
double comp_ellint_3(double k, double nu);
float comp_ellint_3f(float k, float nu);
long double comp_ellint_3l(long double k, long double nu);

// [5.2.1.7] confluent hypergeometric functions:
double conf_hyperg(double a, double c, double x);
float conf_hypergf(float a, float c, float x);
long double conf_hypergl(long double a, long double c, long double x);

// [5.2.1.8] regular modified cylindrical Bessel functions:
double cyl_bessel_i(double nu, double x);
float cyl_bessel_if(float nu, float x);
long double cyl_bessel_il(long double nu, long double x);

// [5.2.1.9] cylindrical Bessel functions (of the first kind):
double cyl_bessel_j(double nu, double x);
float cyl_bessel_jf(float nu, float x);
long double cyl_bessel_jl(long double nu, long double x);

// [5.2.1.10] irregular modified cylindrical Bessel functions:
double cyl_bessel_k(double nu, double x);
float cyl_bessel_kf(float nu, float x);
long double cyl_bessel_kl(long double nu, long double x);

// [5.2.1.11] cylindrical Neumann functions;
// cylindrical Bessel functions (of the second kind):
double cyl_neumann(double nu, double x);
float cyl_neumannf(float nu, float x);
long double cyl_neumannl(long double nu, long double x);

// [5.2.1.12] (incomplete) elliptic integral of the first kind:
double ellint_1(double k, double phi);
float ellint_1f(float k, float phi);
long double ellint_1l(long double k, long double phi);

// [5.2.1.13] (incomplete) elliptic integral of the second kind:
double ellint_2(double k, double phi);
float ellint_2f(float k, float phi);
long double ellint_2l(long double k, long double phi);

// [5.2.1.14] (incomplete) elliptic integral of the third kind:
double ellint_3(double k, double nu, double phi);
float ellint_3f(float k, float nu, float phi);
long double ellint_3l(long double k, long double nu, long double phi);

// [5.2.1.15] exponential integral:
double expint(double x);
float expintf(float x);
long double expintl(long double x);

// [5.2.1.16] Hermite polynomials:
double hermite(unsigned n, double x);
float hermitef(unsigned n, float x);
long double hermitel(unsigned n, long double x);

// [5.2.1.17] hypergeometric functions:
double hyperg(double a, double b, double c, double x);
float hypergf(float a, float b, float c, float x);
long double hypergl(long double a, long double b, long double c, long double x);

// [5.2.1.18] Laguerre polynomials:
double laguerre(unsigned n, double x);
float laguerref(unsigned n, float x);
long double laguerrel(unsigned n, long double x);

// [5.2.1.19] Legendre polynomials:
double legendre(unsigned l, double x);
float legendref(unsigned l, float x);
long double legendrel(unsigned l, long double x);

// [5.2.1.20] Riemann zeta function:
double riemann_zeta(double);
float riemann_zetaf(float);
long double riemann_zetal(long double);

// [5.2.1.21] spherical Bessel functions (of the first kind):
double sph_bessel(unsigned n, double x);
float sph_besself(unsigned n, float x);
long double sph_bessell(unsigned n, long double x);

// [5.2.1.22] spherical associated Legendre functions:
double sph_legendre(unsigned l, unsigned m, double theta);
float sph_legendref(unsigned l, unsigned m, float theta);
long double sph_legendrel(unsigned l, unsigned m, long double theta);

// [5.2.1.23] spherical Neumann functions;
// spherical Bessel functions (of the second kind):
double sph_neumann(unsigned n, double x);
float sph_neumannf(unsigned n, float x);
long double sph_neumannl(unsigned n, long double x);

} // namespace tr1
} // namespace std

標準符合性:以下函數在該組件的 Boost 版本中不支持:

// [5.2.1.7] confluent hypergeometric functions:
double conf_hyperg(double a, double c, double x);
float conf_hypergf(float a, float c, float x);
long double conf_hypergl(long double a, long double c, long double x);

// [5.2.1.17] hypergeometric functions:
double hyperg(double a, double b, double c, double x);
float hypergf(float a, float b, float c, float x);
long double hypergl(long double a, long double b, long double c, long double x);

TR 在頭文件 <cmath> 中增加了許多在C99標準中首次引入的特殊函數。

更多信息請參考 Math 庫文檔

namespace std {
namespace tr1 {

// types
typedef floating-type double_t;
typedef floating-type float_t;

// functions
double acosh(double x);
float acoshf(float x);
long double acoshl(long double x);

double asinh(double x);
float asinhf(float x);
long double asinhl(long double x);

double atanh(double x);
float atanhf(float x);
long double atanhl(long double x);

double cbrt(double x);
float cbrtf(float x);
long double cbrtl(long double x);

double copysign(double x, double y);
float copysignf(float x, float y);
long double copysignl(long double x, long double y);

double erf(double x);
float erff(float x);
long double erfl(long double x);

double erfc(double x);
float erfcf(float x);
long double erfcl(long double x);

double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);

double expm1(double x);
float expm1f(float x);
long double expm1l(long double x);

double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);

double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);

double fmax(double x, double y);
float fmaxf(float x, float y);
long double fmaxl(long double x, long double y);

double fmin(double x, double y);
float fminf(float x, float y);
long double fminl(long double x, long double y);

double hypot(double x, double y);
float hypotf(float x, float y);
long double hypotl(long double x, long double y);

int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);

double lgamma(double x);
float lgammaf(float x);
long double lgammal(long double x);

long long llrint(double x);
long long llrintf(float x);
long long llrintl(long double x);

long long llround(double x);
long long llroundf(float x);
long long llroundl(long double x);

double log1p(double x);
float log1pf(float x);
long double log1pl(long double x);

double log2(double x);
float log2f(float x);
long double log2l(long double x);

double logb(double x);
float logbf(float x);
long double logbl(long double x);

long lrint(double x);
long lrintf(float x);
long lrintl(long double x);

long lround(double x);
long lroundf(float x);
long lroundl(long double x);

double nan(const char *str);
float nanf(const char *str);
long double nanl(const char *str);

double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);

double nextafter(double x, double y);
float nextafterf(float x, float y);
long double nextafterl(long double x, long double y);

double nexttoward(double x, long double y);
float nexttowardf(float x, long double y);
long double nexttowardl(long double x, long double y);

double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);

double remquo(double x, double y, int *pquo);
float remquof(float x, float y, int *pquo);
long double remquol(long double x, long double y, int *pquo);

double rint(double x);
float rintf(float x);
long double rintl(long double x);

double round(double x);
float roundf(float x);
long double roundl(long double x);

double scalbln(double x, long ex);
float scalblnf(float x, long ex);
long double scalblnl(long double x, long ex);
double scalbn(double x, int ex);
float scalbnf(float x, int ex);
long double scalbnl(long double x, int ex);

double tgamma(double x);
float tgammaf(float x);
long double tgammal(long double x);

double trunc(double x);
float truncf(float x);
long double truncl(long double x);

// C99 macros defined as C++ templates
template<class T> bool signbit(T x);
template<class T> int fpclassify(T x);
template<class T> bool isfinite(T x);
template<class T> bool isinf(T x);
template<class T> bool isnan(T x);
template<class T> bool isnormal(T x);
template<class T> bool isgreater(T x, T y);
template<class T> bool isgreaterequal(T x, T y);
template<class T> bool isless(T x, T y);
template<class T> bool islessequal(T x, T y);
template<class T> bool islessgreater(T x, T y);
template<class T> bool isunordered(T x, T y);

}} // namespaces

標準符合性:以下函數在該組件的 Boost 版本中不支持:

double exp2(double x);
float exp2f(float x);
long double exp2l(long double x);

double fdim(double x, double y);
float fdimf(float x, float y);
long double fdiml(long double x, long double y);

double fma(double x, double y, double z);
float fmaf(float x, float y, float z);
long double fmal(long double x, long double y, long double z);

int ilogb(double x);
int ilogbf(float x);
int ilogbl(long double x);

long long llrint(double x);
long long llrintf(float x);
long long llrintl(long double x);

double log2(double x);
float log2f(float x);
long double log2l(long double x);

double logb(double x);
float logbf(float x);
long double logbl(long double x);

long lrint(double x);
long lrintf(float x);
long lrintl(long double x);

double nan(const char *str);
float nanf(const char *str);
long double nanl(const char *str);

double nearbyint(double x);
float nearbyintf(float x);
long double nearbyintl(long double x);

double remainder(double x, double y);
float remainderf(float x, float y);
long double remainderl(long double x, long double y);

double remquo(double x, double y, int *pquo);
float remquof(float x, float y, int *pquo);
long double remquol(long double x, long double y, int *pquo);

double rint(double x);
float rintf(float x);
long double rintl(long double x);

double scalbln(double x, long ex);
float scalblnf(float x, long ex);
long double scalblnl(long double x, long ex);
double scalbn(double x, int ex);
float scalbnf(float x, int ex);
long double scalbnl(long double x, int ex);

// C99 macros defined as C++ templates
template<class T> bool isgreater(T x, T y);
template<class T> bool isgreaterequal(T x, T y);
template<class T> bool isless(T x, T y);
template<class T> bool islessequal(T x, T y);
template<class T> bool islessgreater(T x, T y);
template<class T> bool isunordered(T x, T y);

Copyright c 2005 John Maddock

PrevUpHomeNext