C++11：type_traits (3) type properties

• std::is_const : 判断一个类型是否有const限定。
  可能的实现为：

template struct is_const          : std::false_type {};
template struct is_const : std::true_type {};

代码示例如下：

EXPECT_FALSE(std::is_const::value); // false
EXPECT_TRUE(std::is_const::value); // true
EXPECT_FALSE(std::is_const::value); // false
EXPECT_TRUE(std::is_const::value); // true
EXPECT_FALSE(std::is_const::value); // false
EXPECT_TRUE(std::is_const::type>::value); // true

• std::is_volatile : 判断一个类型是否为volatile限定。
  可能的实现为：

template struct is_volatile             : std::false_type {};
template struct is_volatile : std::true_type {};

代码示例如下：

EXPECT_FALSE(std::is_volatile::value);
EXPECT_TRUE(std::is_volatile::value);

• std::is_trivial : 判断一个类型是否是trivial。
  trivial type：或者是scalar type，或者是有trivial 默认构造函数的平凡可拷贝的类，或者是上述类型的数组。这些类型可能是有const和volatile限定的。
  可能的实现为：

template< class T >
struct is_trivial : std::integral_constant< 
    bool,
    std::is_trivially_copyable::value &&
    std::is_trivially_default_constructible::value 
> {};

代码示例如下：

struct A 
{
    int m;
};

struct B 
{
    B() {}
};
EXPECT_TRUE(std::is_trivial::value);
EXPECT_FALSE(std::is_trivial::value);

• std::is_trivially_copyable : 判断一个类型是否有trivil拷贝函数
  可能的实现为：

代码示例如下：

struct A 
{
    int m;
};

struct B 
{
    B(B const&) {}
};

struct C 
{
    virtual void foo()
};

struct D 
{
    int m;

    D(D const&) = default; // -> trivially copyable
    D(int x) : m(x + 1) {}
};
    
EXPECT_TRUE(std::is_trivially_copyable::value);
EXPECT_FALSE(std::is_trivially_copyable::value);
EXPECT_FALSE(std::is_trivially_copyable::value);
EXPECT_TRUE(std::is_trivially_copyable::value);

• std::is_standard_layout : 判断一个类型是否为标准布局类型

struct A 
{
    int m;
};

struct B 
{
    int m1;
private:
    int m2;
};

struct C 
{
    virtual void foo()
}
};

EXPECT_TRUE(std::is_standard_layout::value);
EXPECT_FALSE(std::is_standard_layout::value);
EXPECT_FALSE(std::is_standard_layout::value);

• std::is_pod : 判断一个类型是否为POD类型

struct A
{
    int m;
};

struct B
{
    int m1;
private:
    int m2;
};

struct C 
{
    virtual void foo()
}
};

EXPECT_TRUE(std::is_pod::value);
EXPECT_FALSE(std::is_pod::value);
EXPECT_FALSE(std::is_pod::value);

• std::is_literal_type : checks if a type is a literal type

struct A 
{
    int m;
};

struct B 
{
    virtual ~B();
};
    
EXPECT_TRUE(std::is_literal_type::value);
EXPECT_FALSE(std::is_literal_type::value);

• std::is_empty : 判断一个类（非联合）是否为没有静态数据成员。

struct A {};

struct B 
{
    int m;
};

struct C 
{
    static int m;
};

struct D 
{
    virtual ~D();
};

union E {};

struct F 
{
    [[no_unique_address]] E e;
};

EXPECT_TRUE(std::is_empty::value);
EXPECT_FALSE(std::is_empty::value);
EXPECT_TRUE(std::is_empty::value);
EXPECT_FALSE(std::is_empty::value);
EXPECT_FALSE(std::is_empty::value);
EXPECT_FALSE(std::is_empty::value);

• std::is_polymorphic : 判断一个类型是否为多态类型

可能的实现：

namespace detail {
 
template 
std::true_type detect_is_polymorphic(
    decltype(dynamic_cast(static_cast(nullptr)))
);
template 
std::false_type detect_is_polymorphic(...);
 
} // namespace detail
 
template 
struct is_polymorphic : decltype(detail::detect_is_polymorphic(nullptr)) {};

代码示例如下：

struct A 
{
    int m;
};

struct B 
{
    virtual void foo();
};

struct C : B {};

EXPECT_FALSE(std::is_polymorphic::value);
EXPECT_TRUE(std::is_polymorphic::value);
EXPECT_TRUE(std::is_polymorphic::value);

• std::is_abstract : 判断一个类型是否为抽象类型

struct A 
{
    int m;
};

struct B 
{
    virtual void foo();
};

struct C 
{
    virtual void foo() = 0;
};

struct D : C {};

EXPECT_FALSE(std::is_abstract::value);
EXPECT_FALSE(std::is_abstract::value);
EXPECT_TRUE(std::is_abstract::value);
EXPECT_TRUE(std::is_abstract::value);

• std::is_signed : 判断一个类型是否为signed的算数类型。
  可能的实现为：

namespace detail {
template::value>
struct is_signed : std::integral_constant {};
 
template
struct is_signed : std::false_type {};
} // namespace detail
 
template
struct is_signed : detail::is_signed::type {};

class A {};
enum B : int {};
enum class C : int {};

EXPECT_FALSE(std::is_signed::value);
EXPECT_TRUE(std::is_signed::value);
EXPECT_TRUE(std::is_signed::value);
EXPECT_FALSE(std::is_signed::value);
EXPECT_FALSE(std::is_signed::value);
EXPECT_FALSE(std::is_signed::value);
EXPECT_TRUE(std::is_signed());
EXPECT_FALSE(std::is_signed());

• std::is_unsigned : 判断一个类型是否为unsigned算数类型。
  可能的实现：

namespace detail {
template::value>
struct is_unsigned : std::integral_constant {};
 
template
struct is_unsigned : std::false_type {};
} // namespace detail
 
template
struct is_unsigned : detail::is_unsigned::type {};

代码示例如下：

class A {};
enum B : unsigned {};
enum class C : unsigned {};

EXPECT_FALSE(std::is_unsigned::value);
EXPECT_FALSE(std::is_unsigned::value);
EXPECT_FALSE(std::is_unsigned::value);
EXPECT_TRUE(std::is_unsigned::value);
EXPECT_FALSE(std::is_unsigned::value);
EXPECT_FALSE(std::is_unsigned::value);

（未完待续）