最終更新日時:
が更新

履歴 編集

型特性

Boost Type Traits Libraryでは、型がどういった特徴を持っているかを判定するメタ関数が多く提供されている。

インデックス

型の分類を判定する

配列型かどうかを判定する

boost::is_array<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_array.hpp>
  • <boost/type_traits.hpp>

例:

is_array<int[2]>::value == true
is_array<char[2][3]>::type == true
is_array<double[]>::value == true

クラスかどうかを判定する

boost::is_class<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_class.hpp>
  • <boost/type_traits.hpp>

例:

class MyClass;

is_class<MyClass>::value == true
is_class<MyClass const>::value == true
is_class<MyClass&>::value == false
is_class<MyClass*>::value == false

std::complex型かどうかを判定する

boost::is_complex<T>メタ関数を使用する。

インクルード: - <boost/type_traits/is_complex.hpp> - <boost/type_traits.hpp>

例:

is_complex<std::complex<T> >::value == true

enum型かどうかを判定する

boost::is_enum<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_enum.hpp>
  • <boost/type_traits.hpp>

例:

enum my_enum { one, two };

is_enum<my_enum>::value == true
is_enum<my_enum const>::type == true
is_enum<my_enum&>::value == false
is_enum<my_enum*>::value == false

浮動小数点数型かどうかを判定する

boost::is_floating_point<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_floating_point.hpp>
  • <boost/type_traits.hpp>

例:

is_floating_point<float>::value == true
is_floating_point<double>::value == true
is_floating_point<long double>::value == true

関数型かどうかを判定する

boost::is_function<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_function.hpp>
  • <boost/type_traits.hpp>

例:

is_function<int (void)>::value == true
is_function<long (double, int)>::value == true

is_function<long (*)(double, int)>::value == false // 関数型ではなく関数へのポインタ
is_function<long (&)(double, int)>::value == false // 関数型ではなく関数への参照

is_function<long (MyClass::*)(double, int)>::value == false // メンバ関数へのポインタ

整数型かどうかを判定する

boost::is_integral<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_integral.hpp>
  • <boost/type_traits.hpp>

例:

is_integral<int>::value == true
is_integral<const char>::value == true
is_integral<long>::value == true

メンバ関数ポインタかどうかを判定する

boost::is_member_function<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_member_function.hpp>
  • <boost/type_traits.hpp>

例:

is_member_function_pointer<int (MyClass::*)(void)>::value == true
is_member_function_pointer<int (MyClass::*)(char)>::value == true
is_member_function_pointer<int (MyClass::*)(void)const>::value == true
is_member_function_pointer<int (MyClass::*)>::value == false // データメンバへのポインタ

メンバ変数ポインタかどうかを判定する

boost::is_member_object<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_member_object.hpp>
  • <boost/type_traits.hpp>

例:

is_member_object_pointer<int (MyClass::*)>::value == true
is_member_object_pointer<double (MyClass::*)>::value == true
is_member_object_pointer<const int (MyClass::*)>::value == true
is_member_object_pointer<int (MyClass::*)(void)>::value == false // メンバ関数ポインタ

ポインタかどうかを判定する

boost::is_pointer<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_pointer.hpp>
  • <boost/type_traits.hpp>

例:

is_pointer<int*>::value == true
is_pointer<char* const>::type == true
is_pointer<int (*)(long)>::value == true
is_pointer<int (MyClass::*)(long)>::value == false
is_pointer<int (MyClass::*)>::value == false

左辺値参照かどうかを判定する

boost::is_lvalue_reference<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_lvalue_reference.hpp>
  • <boost/type_traits.hpp>

例:

is_lvalue_reference<int&>::value == true
is_lvalue_reference<int const&>::value == true
is_lvalue_reference<int const&&>::value == false
is_lvalue_reference<int (&)(long)>::value == true

右辺値参照かどうかを判定する

boost::is_rvalue_reference<T>メタ関数を使用する。

インクルード: - <boost/type_traits/is_rvalue_reference.hpp> - <boost/type_traits.hpp>

例:

is_rvalue_reference<int&&>::value == true
is_rvalue_reference<int const&&>::value == true
is_rvalue_reference<int const&>::value == false
is_rvalue_reference<int (&&)(long)>::value == true

共用体かどうかを判定する

boost::is_union<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_union.hpp>
  • <boost/type_traits.hpp>

例:

is_union<void>::value == true
is_union<const void>::value == true
is_union<void*>::value == false

voidかどうかを判定する

boost::is_void<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_void.hpp>
  • <boost/type_traits.hpp>

例:

is_void<void>::value == true
is_void<const void>::value == true
is_void<void*>::value == false

算術型かどうかを判定する

boost::is_arithmetic<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_arithmetic.hpp>
  • <boost/type_traits.hpp>

算術型は以下を含む:

例:

is_arithmetic<int>::value == true
is_arithmetic<char>::value == true
is_arithmetic<double>::value == true

複合型かどうかを判定する

boost::is_compound<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_compound.hpp>
  • <boost/type_traits.hpp>

複合型は、基本型(is_fundamental)以外の型である。

例:

is_compound<MyClass>::value == true
is_compound<MyEnum>::value == true
is_compound<int*>::value == true
is_compound<int&>::value == true
is_compound<int>::value == false

基本型かどうかを判定する

boost::is_fundamental<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_fundamental.hpp>
  • <boost/type_traits.hpp>

基本型は以下を含む:

例:

is_fundamental<int)>::value == true
is_fundamental<double const>::value == true
is_fundamental<void>::value == true

メンバポインタかどうかの判定

boost::is_member_pointer<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_member_pointer.hpp>
  • <boost/type_traits.hpp>

メンバポインタは以下を含む:

例:

is_member_pointer<int (MyClass::*)>::value == true
is_member_pointer<int (MyClass::*)(char)>::value == true
is_member_pointer<int (MyClass::*)(void)const>::value == true

オブジェクト型かどうかを判定する

boost::is_object<T>メタ関数を使用する。

インクルード: - <boost/type_traits/is_object.hpp> - <boost/type_traits.hpp>

オブジェクト型は、参照、void、関数型以外の型である。

例:

is_object<int>::value == true
is_object<int*>::value == true
is_object<int (*)(void)>::value == true
is_object<int (MyClass::*)(void)const>::value == true
is_object<int &>::value == false // 参照型はオブジェクトではない
is_object<int (double)>::value == false // 参照型はオブジェクトではない
is_object<const void>::value == false // void型はオブジェクトではない

参照型かどうかを判定する

boost::is_referece<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_reference.hpp>
  • <boost/type_traits.hpp>

参照型は、左辺値参照と右辺値参照を含む型である。

例:

is_reference<int&>:: == true
is_reference<int const&>::value == true
is_reference<int const&&>::value == true
is_reference<int (&)(long)>::value == true // 関数への参照

スカラ型かどうかを判定する

boost::is_scalar<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_scalar.hpp>
  • <boost/type_traits.hpp>

スカラ型は以下を含む:

例:

is_scalar<int*>::value == true
is_scalar<int>::value == true
is_scalar<double>::value == true
is_scalar<int (*)(long)>::value == true
is_scalar<int (MyClass::*)(long)>::value == true
is_scalar<int (MyClass::*)>::value == true

型の性質

アライメントを取得する

boost::alignment_of<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/alignment_of.hpp>
  • <boost/type_traits.hpp>

例:

const std::size_t a = alignment_of<int>::value;

new演算子を持っている型かどうかを判定する

boost::has_new_operator<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_new_operator.hpp>
  • <boost/type_traits.hpp>

例:

class A { void* operator new(std::size_t); };
class B { void* operator new(std::size_t, const std::nothrow&); };
class C { void* operator new(std::size_t, void*); };
class D { void* operator new[](std::size_t); };
class E { void* operator new[](std::size_t, const std::nothrow&); };
class F { void* operator new[](std::size_t, void*); };

has_new_operator<A>::value == true
has_new_operator<B>::value == true
has_new_operator<C>::value == true
has_new_operator<D>::value == true
has_new_operator<E>::value == true
has_new_operator<F>::value == true

例外を投げない代入演算子を持っている型かどうかを判定する

boost::has_nothrow_assign<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_nothrow_assign.hpp>
  • <boost/type_traits.hpp>

例外を投げないコンストラクタを持っている型かどうかを判定する

boost::has_nothrow_constructor<T>もしくはboost::has_nothrow_default_constructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_nothrow_constructor.hpp>
  • <boost/type_traits.hpp>

例外を投げないコピーコンストラクタを持っている型かどうかを判定する

boost::has_nothrow_copy<T>もしくはboost::has_nothrow_copy_constructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_nothrow_copy.hpp>
  • <boost/type_traits/has_nothrow_copy_constructor.hpp>
  • <boost/type_traits.hpp>

自明な代入演算子を持っている型かどうかを判定する

boost::has_trivial_assign<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_trivial_assign.hpp>
  • <boost/type_traits.hpp>

例:

has_trivial_assign<int>::value == true
has_trivial_assign<char*>::value == true
has_trivial_assign<int (*)(long)>::value == true
has_trivial_assign<MyClass>::value == false

自明なコンストラクタを持っている型かどうかを判定する

boost::has_trivial_constructor<T>もしくはboost::has_trivial_default_constructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_trivial_constructor.hpp>
  • <boost/type_traits.hpp>

例:

has_trivial_constructor<int>::value == true
has_trivial_constructor<char*>::value == true
has_trivial_constructor<int (*)(long)>::value == true
has_trivial_constructor<MyClass>::value == false

自明なコピーコンストラクタを持っている型か判定する

boost::has_trivial_copy<T>もしくはboost::has_trivial_copy_constructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_trivial_copy.hpp>
  • <boost/type_traits.hpp>

例:

has_trivial_copy<int>::value == true
has_trivial_copy<char*>::value == true
has_trivial_copy<int (*)(long)>::value == true
has_trivial_copy<MyClass>::value == false

自明なデストラクタを持っている型かどうかを判定する

boost::has_trivial_destructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_trivial_destructor.hpp>
  • <boost/type_traits.hpp>

例:

has_trivial_destructor<int>::value == true
has_trivial_destructor<char*>::value == true
has_trivial_destructor<int (*)(long)>::value == true
has_trivial_destructor<MyClass>::value == false

仮想デストラクタを持っている型かどうかを判定する

boost::has_virtual_destructor<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/has_virtual_destructor.hpp>
  • <boost/type_traits.hpp>

抽象型かどうかを判定する

boost::is_abstract<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_abstract.hpp>
  • <boost/type_traits.hpp>

例:

class abc{ virtual ~abc() = 0; }; 

is_abstract<abc>::value == true
is_abstract<abc const>::value == true

const修飾された型かどうかを判定する

boost::is_const<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_const.hpp>
  • `<boost/type_traits.hpp>@

例:

is_const<int const>::value == true
is_const<int const volatile>::value == true
is_const<int* const>::value == true
is_const<int const*>::value == false
is_const<int const&>::value == false
is_const<int>::value == false

空クラスかどうかを判定する

boost::is_empty<T>メタ関数を使用する。

継承してもサイズが増えない型ならtrue

インクルード:

  • <boost/type_traits/is_empty.hpp>
  • <boost/type_traits.hpp>

例:

struct empty_class {}; 

is_empty<empty_class>::value == true
is_empty<empty_class const>::value == true
is_empty<empty_class>::value == true

stateless型かどうかを判定する

boost::is_stateless<T>メタ関数を使用する。

ストレージを持たず、コンストラクタとデストラクタが自明な型ならtrue

インクルード:

  • <boost/type_traits/is_stateless.hpp>
  • <boost/type_traits.hpp>

POD型かどうかを判定する

boost::is_pod<T>メタ関数を使用する。

インクルード:

  • <boost/type_traits/is_pod.hpp>
  • <boost/type_traits.hpp>

例:

is_pod<int>::value == true
is_pod<char*>::value == true
is_pod<int (*)(long)>::value == true
is_pod<MyClass>::value == false

多相的に振る舞う型かどうかを判定する

boost::is_polymorphic<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_polymorphic.hpp
  • boost/type_traits.hpp

例:

class poly{ virtual ~poly(); };

is_polymorphic<poly>::value == true
is_polymorphic<poly const>::value == true
is_polymorphic<poly>::value == true

符号付き整数型かどうかを判定する

boost::is_signed<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_signed.hpp
  • boost/type_traits.hpp

例:

is_signed<int>::value == true
is_signed<int const volatile>::value == true
is_signed<unsigned int>::value == false
is_signed<myclass>::value == false
is_signed<char>::valueは、charの符号性質に依存する
is_signed<long long>::value == true

符号なし整数型かどうかを判定する

boost::is_unsigned<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_unsigned.hpp
  • boost/type_traits.hpp

例:

is_unsigned<unsigned int>::value == true
is_unsigned<unsigned int const volatile>::value == true
is_unsigned<int>::value == false
is_unsigned<myclass>::value == false
is_unsigned<char>::valueは、charの符号性質に依存する
is_unsigned<unsigned long long>::value == true

volatile修飾された型かどうかを判定する

boost::is_volatile<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_volatile.hpp
  • boost/type_traits.hpp

例:

is_volatile<volatile int>::value == true
is_volatile<const volatile int>::value == true
is_volatile<int* volatile>::value == true
is_volatile<int volatile*>::value == false

配列のN次元目の要素数を取得する

boost::extent<T>もしくはboost::extent<T, N>メタ関数を使用する。

インクルード:

  • boost/type_traits/extent.hpp
  • boost/type_traits.hpp

例:

extent<int[1]>::value == 1
extent<double[2][3][4], 0>::value == 2
extent<double[2][3][4], 1>::value
extent<double[2][3][4], 3>::value == 4
extent<int[][2]>::value == 0
extent<int[][2], 1>::value == 2
extent<int*>::value == 0
extent<boost::array<int, 3> >::value == 0

配列の次元数を取得する

boost::rank<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/rank.hpp
  • boost/type_traits.hpp

例:

rank<int[]>::value == 1
rank<double[2][3][4]>::value == 3
rank<int[1]>::value == 1
rank<int[][2]>::value == 2
rank<int*>::value == 0
rank<boost::array<int, 3> >::value == 0

2つの型の関係性

継承関係にある型かどうかを判定する

boost::is_base_of<Base, Derived>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_base_of.hpp
  • boost/type_traits.hpp

例:

class Base{};
class Derived : public Base{}; 

is_base_of<Base, Derived>::value == true
is_base_of<Base, Base>::value == true

仮想継承の関係にある型かどうかを判定する

boost::is_virtual_base_of<Base, Derived>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_virtual_base_of.hpp
  • boost/type_traits.hpp

例:

class Base{};
class Derived : public virtual Base{}; 

is_virtual_base_of<Base, Derived>::value == true
is_virtual_base_of<Base, Base>::value == true

変換可能な型かどうかを判定する

boost::is_convertible<From, To>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_convertible.hpp
  • boost/type_traits.hpp

例:

is_convertible<int, double>::value == true
is_convertible<const int, double>::value == true
is_convertible<int* const, int*>::value == true
is_convertible<int const*, int*>::value == false // const_castが必要
is_convertible<int const&, long>::value == true
is_convertible<int, int>::value == true

2つの型が同じかを判定する

boost::is_same<T, U>メタ関数を使用する。

インクルード:

  • boost/type_traits/is_same.hpp
  • boost/type_traits.hpp

例:

is_same<int, int>::value == true
is_same<int const, int>::value == false
is_same<int&, int>::value == false

型の変換する

const修飾を付加する

boost::add_const<T>メタ関数を使用する。

T const型を返す。

インクルード:

  • boost/type_traits/add_const.hpp
  • boost/type_traits.hpp

例:

add_const<int>::type       : int const
add_const<int&>::type      : int&
add_const<int*>::type      : int* const
add_const<int const>::type : int const

volatile修飾を付加する

boost::add_volatile<T>メタ関数を使用する。

T volatile型を返す。

インクルード:

  • boost/type_traits/add_volatile.hpp
  • boost/type_traits.hpp

例:

add_volatile<int>::type : int volatile
add_volatile<int&>::type : int&
add_volatile<int*>::type : int* volatile
add_volatile<int const>::type : int const volatile

const volatile修飾を付加する

boost::add_cv<T>メタ関数を使用する。

T const volatile型を返す。

インクルード:

  • boost/type_traits/add_cv.hpp
  • boost/type_traits.hpp

例:

add_cv<int>::type       : int const volatile
add_cv<int&>::type      : int&
add_cv<int*>::type      : int* const volatile
add_cv<int const>::type : int const volatile

左辺値参照を付加する

boost::add_lvalue_reference<T>メタ関数を使用する。

T&型を返す。

インクルード:

  • boost/type_traits/add_lvalue_reference.hpp
  • boost/type_traits.hpp

例:

add_lvalue_reference<int>::type        : int&
add_lvalue_reference<int const&>::type : int const&
add_lvalue_reference<int*>::type       : int*&
add_lvalue_reference<int*&>::type      : int*&
add_lvalue_reference<int&&>::type      : int&
add_lvalue_reference<void>::type       : void

右辺値参照を付加する

boost::add_rvalue_reference<T>メタ関数を使用する。

T&&型を返す。

インクルード:

  • boost/type_traits/add_rvalue_reference.hpp
  • boost/type_traits.hpp例:

add_rvalue_reference<int>::type        : int&&
add_rvalue_reference<int const&>::type : int const&
add_rvalue_reference<int*>::type       : int*&&
add_rvalue_reference<int*&>::type      : int*&
add_rvalue_reference<int&&>::type      : int&&
add_rvalue_reference<void>::type       : void

参照を付加する

boost::add_reference<T>メタ関数を使用する。

T&型を返す。

インクルード:

  • boost/type_traits/add_reference.hpp
  • boost/type_traits.hpp

例:

add_reference<int>::type        : int&
add_reference<int const&>::type : int const&
add_reference<int*>::type       : int*&
add_reference<int*&>::type      : int*&

ポインタを付加する

boost::add_pointer<T>メタ関数を使用する。

T*型を返す。

インクルード:

  • boost/type_traits/add_pointer.hpp
  • boost/type_traits.hpp

例:

add_pointer<int>::type        : int*
add_pointer<int const&>::type : int const*
add_pointer<int*>::type       : int**
add_pointer<int*&>::type      : int**

条件によって型を選択する

boost::conditional<Cond, Then, Else>メタ関数を使用する。

コンパイル時条件Condtrueの場合はThen型を返し、それ以外の場合はElse型を返す。

インクルード:

  • boost/type_traits/conditional.hpp
  • boost/type_traits.hpp

例:

conditional<true, int, char>::type  : int
conditional<false, int, char>::type : char

共通の型を取得する

boost::common_type<T...>メタ関数を使用する。

複数の型から、共通に変換可能な型を推定して返す。

インクルード:

  • boost/type_traits/common_type.hpp
  • boost/type_traits.hpp

例:

template <class ...T>
typename common_type<T...>::type min(T... t);

推論される型の取得する

boost::decay<T>メタ関数を使用する。

以下のような関数テンプレートによって推論される型を取得する。

template<class T> void f(T x);

インクルード:

  • <boost/type_traits/decay.hpp>
  • <boost/type_traits.hpp>

例:

decay<int[2][3]>::type      : int[3]*
decay<int(&)[2]>::type      : int*
decay<int(&)(double)>::type : int(*)(double)
int(*)(double)              : int(*)(double)
int(double)                 : int(*)(double)

浮動小数点数型を昇格する

booost::floating_point_promotion<T>メタ関数を使用する。

floatdoubledoublelong doubleに昇格。

インクルード:

  • boost/type_traits/floating_point_promotion.hpp
  • boost/type_traits.hpp

例:

floating_point_promotion<float const>::type : double const
floating_point_promotion<float&>::type      : float&
floating_point_promotion<short>::type       : short

整数型を昇格する

boost::integral_promotion<T>メタ関数を使用する。

shortintintlongに、といった昇格を行う。

インクルード:

  • boost/type_traits/integral_promotion.hpp
  • boost/type_traits.hpp

例:

integral_promotion<short const>::type                 : int const
integral_promotion<short&>::type                      : short&
integral_promotion<enum std::float_round_style>::type : int

型を昇格する

boost::promote<T>メタ関数を使用する。

整数型もしくは浮動小数点数型を昇格。

インクルード:

  • boost/type_traits/promote.hpp
  • boost/type_traits.hpp

例:

promote<short volatile>::type : int volatile
promote<float const>::type    : double const
promote<short&>::type         : short&

符号なし型から符号あり型に変換する

boost::make_signed<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/make_signed.hpp
  • boost/type_traits.hpp

例:

make_signed<int>::type                      : int
make_signed<unsigned int const>::type       : int const
make_signed<const unsigned long long>::type : const long long
make_signed<my_enum>::type                  : enumと同じ幅を持つ符号付き整数型
make_signed<wchar_t>::type                  : wchar_tと同じ幅を持つ符号付き整数型

符号あり型から符号なし型に変換する

boost::make_unsigned<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/make_unsigned.hpp
  • boost/type_traits.hpp

例:

make_unsigned<int>::type                      : unsigned int
make_unsigned<unsigned int const>::type       : unsigned int const
make_unsigned<const unsigned long long>::type : const unsigned long long
make_unsigned<my_enum>::type                  : enumと同じ幅を持つ符号なし整数型
make_unsigned<wchar_t>::type                  : wchar_tと同じ幅を持つ符号なし整数型

配列の次元を削除する

boost::remove_extent<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_extent.hpp
  • boost/type_traits.hpp

例:

remove_extent<int>::type          : int
remove_extent<int const[2]>::type : int const
remove_extent<int[2][4]>::type    : int[4]
remove_extent<int[][2]>::type     : int[2]
remove_extent<int const*>::type   : int const*

配列の次元を全て削除する

boost::remove_all_extents<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_all_extents.hpp
  • boost/type_traits.hpp

例:

remove_all_extents<int>::type          : int
remove_all_extents<int const[2]>::type : int const
remove_all_extents<int[][2]>::type     : int
remove_all_extents<int[2][3][4]>::type : int
remove_all_extents<int const*>::type   : int const*

const修飾を削除する

boost::remove_const<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_const.hpp
  • boost/type_traits.hpp

例:

remove_const<int>::type : int
remove_const<int const>::type : int
remove_const<int const volatile>::type : int volatile
remove_const<int const&>::type : int const&
remove_const<int const*>::type : int const*

volatile修飾を削除する

boost::remove_volatile<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_volatile.hpp
  • boost/type_traits.hpp

例:

remove_volatile<int>::type                : int
remove_volatile<int volatile>::type       : int
remove_volatile<int const volatile>::type : int const
remove_volatile<int volatile&>::type      : int volatile&
remove_volatile<int volatile*>::type      : int volatile*

const volatile修飾を削除する

boost::remove_cv<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_cv.hpp
  • boost/type_traits.hpp

例:

remove_cv<int>::type                : int
remove_cv<int const>::type          : int
remove_cv<int const volatile>::type : int
remove_cv<int const&>::type         : int const&
remove_cv<int const*>::type         : int const*

ポインタを削除する

boost::remove_pointer<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_pointer.hpp
  • boost/type_traits.hpp

例:

remove_pointer<int>::type         : int
remove_pointer<int const*>::type  : int const
remove_pointer<int const**>::type : int const*
remove_pointer<int&>::type        : int&
remove_pointer<int*&>::type       : int*&

参照を削除する

boost::remove_reference<T>メタ関数を使用する。

インクルード:

  • boost/type_traits/remove_reference.hpp
  • boost/type_traits.hpp

例:

remove_reference<int>::type        : int
remove_reference<int const&>::type : int const
remove_reference<int&&>::type      : int
remove_reference<int*>::type       : int*
remove_reference<int*&>::type      : int*

特定アライメントを持った型の合成

特定のアライメントを持つ型の取得する

boost::type_with_alignment<Align>メタ関数を使用する。

インクルード:

  • boost/type_traits/type_with_alignment.hpp
  • boost/type_traits.hpp

例:

#include <iostream>
#include <boost/type_traits/alignment_of.hpp>
#include <boost/type_traits/type_with_alignment.hpp>

int main()
{
    std::cout << typeid(
        boost::type_with_alignment<
            boost::alignment_of<char>::value
        >::type
    ).name() << std::endl;
}

実行結果:

union boost::detail::lower_alignment<1>

適切にアライメントされた型を作成する

boost::aligned_storage<Len, Align>メタ関数を使用する。

Alignアライメント、LenサイズのPOD型を返す。

インクルード:

  • boost/type_traits/aligned_storage.hpp
  • boost/type_traits.hpp

例:

// via http://d.hatena.ne.jp/Cryolite/20051102#p1

template<class T>
class scoped_destroy : boost::noncopyable
{
public:
    explicit scoped_destroy(T* p) : ptr_(p) {}
    ~scoped_destroy(){ptr_->~T();}
    T& operator*()const{return *ptr_;}
    T* operator->()const{return ptr_;}
    T* get()const{return ptr_;}
private:
    T* ptr_;
};

int main()
{
    boost::aligned_storage<
        sizeof(MyClass), boost::alignment_of<MyClass>::value
    >::type buf;

    scoped_destroy<MyClass> p(::new (static_cast<void*>(&buf)) MyClass());

    ... // p.get(), p->(), *p を用いて構築したオブジェクトを利用する

    // ここで明示的なデストラクタの呼び出しは不要
}