【C++】 7_ New features of C + + 11 – Standard Library

Time:2021-8-17

tuple

File: test.cpp

#include <iostream>
#include <string>
#include <tuple>

using namespace std;

void test_1()
{
    cout << "test_1: ----------------------" << endl;

    // create and initialize a tuple explicitly
    tuple<int, float, string> t(41, 6.3, "nico");
    cout << "tuple<int, float, string>, sizeof = " << sizeof(t) << endl;

    // iterator over elements
    cout << "t: " << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
}

void test_2()
{
    cout << endl << "test_2: ----------------------" << endl;

    // create tuple with make_tuple()
    auto t = make_tuple(22, 44, "stacy");
    cout << "t: " << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
}

void test_3()
{
    cout << endl << "test_3: ----------------------" << endl;

    auto t1 = make_tuple(41, 6.3, "nico");
    auto t2 = make_tuple(22, 44, "stacy");

    // assign second value in t2 to t1
    get<1>(t1) = get<1>(t2);
    cout << "get<1>(t1) = " << get<1>(t1) << endl;
}

void test_4()
{
    cout << endl << "test_4: ----------------------" << endl;

    auto t1 = make_tuple(41, 6.3, "nico");
    auto t2 = make_tuple(22, 44, "stacy");

    // comparsion
    if (t1 < t2)
    {
        cout << "t1 < t2" << endl;
    }
    else
    {
        cout << "t2 < t1" << endl;
    }

    // assigns values for value
    t1 = t2;
    cout << "t1: " << get<0>(t1) << " " << get<1>(t1) << " " << get<2>(t1) << endl;
    cout << "t2: " << get<0>(t2) << " " << get<1>(t2) << " " << get<2>(t2) << endl;
}

void test_5()
{
    cout << endl << "test_5: ----------------------" << endl;

    tuple<int, float, string> t(77, 1.1, "more light");
    int il;
    float fl;
    string sl;

    //Batch assignment
    //STD:: tie will integrate the references of variables into a tuple to realize batch assignment.
    tie(il, fl, sl) = t;

    cout << "il = " << il << ", fl = " << fl << ", sl = " << sl << endl;
}

void test_6()
{
    cout << endl << "test_6: ----------------------" << endl;

    typedef tuple<int, float, string> TupleType;
    cout << "tuple_size<TupleType>::value = " << tuple_size<TupleType>::value << endl;

    tuple_element<1, TupleType>::type fl = 1.1F;
    cout << "tuple_element<1, TupleType>::type fl : " << fl << endl;

    typedef tuple_element<1, TupleType>::type T;
    T fll = 1.1F;
    cout << "T fll : " << fll << endl;
}

ostream& operator<< (ostream &out, const tuple<int, float, string>& t)
{
    cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
}

void test_7()
{
    cout << endl << "test_7: ----------------------" << endl;

    auto t = make_tuple(41, 6.3, "nico");

    cout << t;
}

int main()
{
    test_1();
    test_2();
    test_3();
    test_4();
    test_5();
    test_6();
    test_7();

    return 0;
}

Output:

test_1: ----------------------
tuple<int, float, string>, sizeof = 32
t: 41 6.3 nico

test_2: ----------------------
t: 22 44 stacy

test_3: ----------------------
get<1>(t1) = 44

test_4: ----------------------
t2 < t1
t1: 22 44 stacy
t2: 22 44 stacy

test_5: ----------------------
il = 77, fl = 1.1, sl = more light

test_6: ----------------------
tuple_size<TupleType>::value = 3
tuple_element<1, TupleType>::type fl : 1.1
T fll : 1.1

test_7: ----------------------
41 6.3 nico

type traits

<type_traits>

This header defines a series of classes to obtain type information on compile-time.

The header contains:

  • Helper classes: Standard classes to assist in creating compile-time constants.
  • Type traits: Classes to obtain characteristics of types in the form of compile-time constant values.
  • Type transformations: Classes to obtain new types by applying specific transformations to existing types.

A basic trait for types is the categories in which they can be classified. This is a chart on how these categories overlap:

【C++】 7_ New features of C + + 11 - Standard Library

Helper classes

integral_constant Integral constant(class template )
true_type True type(class )
false_type False type(class )

Type traits

Primary type categories

is_array Is array(class template )
is_class Is non-union class(class template )
is_enum Is enum(class template )
is_floating_point Is floating point(class template )
is_function Is function(class template )
is_integral Is integral(class template )
is_lvalue_reference Is lvalue reference(class template )
is_member_function_pointer Is member function pointer(class template )
is_member_object_pointer Is member object pointer(class template )
is_pointer Is pointer(class template )
is_rvalue_reference Is rvalue reference(class template )
is_union Is union(class template )
is_void Is void(class template )

Composite type categories

is_arithmetic Is arithmetic type(class template )
is_compound Is compound type(class template )
is_fundamental Is fundamental type(class template )
is_member_pointer Is member pointer type(class template )
is_object Is object type(class template )
is_reference Is reference type(class template )
is_scalar Is scalar type(class template )

Type properties

is_abstract Is abstract class(class template )
is_const Is const-qualified(class template )
is_empty Is empty class(class template )
is_literal_type Is literal type(class template )
is_pod Is POD type(class template )
is_polymorphic Is polymorphic(class template )
is_signed Is signed type(class template )
is_standard_layout Is standard-layout type(class template )
is_trivial Is trivial type(class template )
is_trivially_copyable Is trivially copyable(class template )
is_unsigned Is unsigned type(class template )
is_volatile Is volatile-qualified(class template )

Type features

has_virtual_destructor Has virtual destructor(class template )
is_assignable Is assignable(class template )
is_constructible Is constructible(class template )
is_copy_assignable Is copy assignable(class template )
is_copy_constructible Is copy constructible(class template )
is_destructible Is destructible(class template )
is_default_constructible Is default constructible(class template )
is_move_assignable Is move assignable(class template )
is_move_constructible Is move constructible(class template )
is_trivially_assignable Is trivially assignable(class template )
is_trivially_constructible Is trivially constructible(class template )
is_trivially_copy_assignable Is trivially copy assignable(class template )
is_trivially_copy_constructible Is trivially copy constructible(class template )
is_trivially_destructible Is trivially destructible(class template )
is_trivially_default_constructible Is trivially default constructible(class template )
is_trivially_move_assignable Is trivially move assignable(class template )
is_trivially_move_constructible Is trivially move constructible(class template )
is_nothrow_assignable Is assignable throwing no exceptions(class template )
is_nothrow_constructible Is constructible throwing no exceptions(class template )
is_nothrow_copy_assignable Is copy assignable throwing no exceptions(class template )
is_nothrow_copy_constructible Is copy constructible throwing no exceptions(class template )
is_nothrow_destructible Is nothrow destructible(class template )
is_nothrow_default_constructible Is default constructible throwing no exceptions(class template )
is_nothrow_move_assignable Is move assignable throwing no exception(class template )
is_nothrow_move_constructible Is move constructible throwing no exceptions(class template )

Type relationships

is_base_of Is base class of(class template )
is_convertible Is convertible(class template )
is_same Is same type(class template )

Property queries

alignment_of Alignment of(class template )
extent Array dimension extent(class template )
rank Array rank(class template )

Type transformations

Const-volatile qualifications

add_const Add const qualification(class template )
add_cv Add const volatile qualification(class template )
add_volatile Add volatile qualification(class template )
remove_const Remove const qualification(class template )
remove_cv Remove cv qualification(class template )
remove_volatile Remove volatile qualification(class template )

Compound type alterations

add_pointer Add pointer(class template )
add_lvalue_reference Add lvalue reference(class template )
add_rvalue_reference Add rvalue reference(class template )
decay Decay type(class template )
make_signed Make signed(class template )
make_unsigned Make unsigned(class template )
remove_all_extents Remove all array extents(class template )
remove_extent Remove array extent(class template )
remove_pointer Remove pointer(class template )
remove_reference Remove reference(class template )
underlying_type Underlying type of enum(class template )

Other type generators

aligned_storage Aligned storage(class template )
aligned_union Aligned union(class template )
common_type Common type(class template )
conditional Conditional type(class template )
enable_if Enable type if condition is met(class template )
result_of Result of call(class template )

test

#include <iostream>
#include <typeinfo>
#include <type_traits>
#include <string>
#include <complex>

using namespace std;

template <typename T>
void type_traits_output(const T& x)
{
    cout << "\ntyoe traitd for type : " << typeid(T).name() << endl;

    cout << "is_array\t" << is_array<T>::value << endl;
    cout << "is_class\t" << is_class<T>::value << endl;
    cout << "is_enum\t" << is_enum<T>::value << endl;
    cout << "is_floating_point\t" << is_floating_point<T>::value << endl;
    cout << "is_function\t" << is_function<T>::value << endl;
    cout << "is_integral\t" << is_integral<T>::value << endl;
    cout << "is_lvalue_reference\t" << is_lvalue_reference<T>::value << endl;
    cout << "is_member_function_pointer\t" << is_member_function_pointer<T>::value << endl;
    cout << "is_member_object_pointer\t" << is_member_object_pointer<T>::value << endl;
    cout << "is_pointer\t" << is_pointer<T>::value << endl;
    cout << "is_rvalue_reference\t" << is_rvalue_reference<T>::value << endl;
    cout << "is_union\t" << is_union<T>::value << endl;
    cout << "is_void\t" << is_void<T>::value << endl;
    cout << "is_arithmetic\t" << is_arithmetic<T>::value << endl;
    cout << "is_compound\t" << is_compound<T>::value << endl;
    cout << "is_fundamental\t" << is_fundamental<T>::value << endl;
    cout << "is_member_pointer\t" << is_member_pointer<T>::value << endl;
    cout << "is_object\t" << is_object<T>::value << endl;
    cout << "is_reference\t" << is_reference<T>::value << endl;
    cout << "is_scalar\t" << is_scalar<T>::value << endl;
    cout << "is_abstract\t" << is_abstract<T>::value << endl;
    cout << "is_const\t" << is_const<T>::value << endl;
    cout << "is_empty\t" << is_empty<T>::value << endl;
    cout << "is_pod\t" << is_pod<T>::value << endl;
    cout << "is_polymorphic\t" << is_polymorphic<T>::value << endl;
    cout << "is_literal_type\t" << is_literal_type<T>::value << endl;
    cout << "is_signed\t" << is_signed<T>::value << endl;
    cout << "is_standard_layout\t" << is_standard_layout<T>::value << endl;
    cout << "is_trivial\t" << is_trivial<T>::value << endl;
    cout << "is_trivially_copyable\t" << is_trivially_copyable<T>::value << endl;
    cout << "is_unsigned\t" << is_unsigned<T>::value << endl;
    cout << "is_volatile\t" << is_volatile<T>::value << endl;
    cout << "has_virtual_destructor\t" << has_virtual_destructor<T>::value << endl;
    cout << "is_constructible\t" << is_constructible<T>::value << endl;
    cout << "is_copy_assignable\t" << is_copy_assignable<T>::value << endl;
    cout << "is_copy_constructible\t" << is_copy_constructible<T>::value << endl;
    cout << "is_destructible\t" << is_destructible<T>::value << endl;
    cout << "is_default_constructible\t" << is_default_constructible<T>::value << endl;
    cout << "is_move_assignable\t" << is_move_assignable<T>::value << endl;
    cout << "is_move_constructible\t" << is_move_constructible<T>::value << endl;
    cout << "is_trivially_constructible\t" << is_trivially_constructible<T>::value << endl;
    cout << "is_trivially_copy_assignable\t" << is_trivially_copy_assignable<T>::value << endl;
    cout << "is_trivially_copy_constructible\t" << is_trivially_copy_constructible<T>::value << endl;
    cout << "is_trivially_destructible\t" << is_trivially_destructible<T>::value << endl;
    cout << "is_trivially_default_constructible\t" << is_trivially_default_constructible<T>::value << endl;
    cout << "is_trivially_move_assignable\t" << is_trivially_move_assignable<T>::value << endl;
    cout << "is_trivially_move_constructible\t" << is_trivially_move_constructible<T>::value << endl;
    cout << "is_nothrow_constructible\t" << is_nothrow_constructible<T>::value << endl;
    cout << "is_nothrow_copy_assignable\t" << is_nothrow_copy_assignable<T>::value << endl;
    cout << "is_nothrow_copy_constructible\t" << is_nothrow_copy_constructible<T>::value << endl;
    cout << "is_nothrow_destructible\t" << is_nothrow_destructible<T>::value << endl;
    cout << "is_nothrow_default_constructible\t" << is_nothrow_default_constructible<T>::value << endl;
    cout << "is_nothrow_move_assignable\t" << is_nothrow_move_assignable<T>::value << endl;
    cout << "is_nothrow_move_constructible\t" << is_nothrow_move_constructible<T>::value << endl;
}

String test

int main()
{
    type_traits_output(string());

    return 0;
}

Output:

is_void 0
is_arithmetic   0
is_compound     1
is_fundamental  0
is_member_pointer       0
is_object       1
is_reference    0
is_scalar       0
is_abstract     0
is_const        0
is_empty        0
is_pod  0
is_polymorphic  0
is_literal_type 0
is_signed       0
is_standard_layout      1
is_trivial      0
is_trivially_copyable   0
is_unsigned     0
is_volatile     0
has_virtual_destructor  0
is_constructible        1
is_copy_assignable      1
is_copy_constructible   1
is_destructible 1
is_default_constructible        1
is_move_assignable      1
is_move_constructible   1
is_trivially_constructible      0
is_trivially_copy_assignable    0
is_trivially_copy_constructible 0
is_trivially_destructible       0
is_trivially_default_constructible      0
is_trivially_move_assignable    0
is_trivially_move_constructible 0
is_nothrow_constructible        1
is_nothrow_copy_assignable      0
is_nothrow_copy_constructible   0
is_nothrow_destructible 1
is_nothrow_default_constructible        1
is_nothrow_move_assignable      1
is_nothrow_move_constructible   1

Complex test

int main()
{
    type_traits_output(complex<float>());

    return 0;
}

Output:

tyoe traitd for type : St7complexIfE
is_array        0
is_class        1
is_enum 0
is_floating_point       0
is_function     0
is_integral     0
is_lvalue_reference     0
is_member_function_pointer      0
is_member_object_pointer        0
is_pointer      0
is_rvalue_reference     0
is_union        0
is_void 0
is_arithmetic   0
is_compound     1
is_fundamental  0
is_member_pointer       0
is_object       1
is_reference    0
is_scalar       0
is_abstract     0
is_const        0
is_empty        0
is_pod  0
is_polymorphic  0
is_literal_type 1
is_signed       0
is_standard_layout      1
is_trivial      0
is_trivially_copyable   1
is_unsigned     0
is_volatile     0
has_virtual_destructor  0
is_constructible        1
is_copy_assignable      1
is_copy_constructible   1
is_destructible 1
is_default_constructible        1
is_move_assignable      1
is_move_constructible   1
is_trivially_constructible      0
is_trivially_copy_assignable    1
is_trivially_copy_constructible 1
is_trivially_destructible       1
is_trivially_default_constructible      0
is_trivially_move_assignable    1
is_trivially_move_constructible 1
is_nothrow_constructible        1
is_nothrow_copy_assignable      1
is_nothrow_copy_constructible   1
is_nothrow_destructible 1
is_nothrow_default_constructible        1
is_nothrow_move_assignable      1
is_nothrow_move_constructible   1

List test

int main()
{
    type_traits_output(list<int>());

    return 0;
}

Output:

tyoe traitd for type : NSt7__cxx114listIiSaIiEEE
is_array        0
is_class        1
is_enum 0
is_floating_point       0
is_function     0
is_integral     0
is_lvalue_reference     0
is_member_function_pointer      0
is_member_object_pointer        0
is_pointer      0
is_rvalue_reference     0
is_union        0
is_void 0
is_arithmetic   0
is_compound     1
is_fundamental  0
is_member_pointer       0
is_object       1
is_reference    0
is_scalar       0
is_abstract     0
is_const        0
is_empty        0
is_pod  0
is_polymorphic  0
is_literal_type 0
is_signed       0
is_standard_layout      0
is_trivial      0
is_trivially_copyable   0
is_unsigned     0
is_volatile     0
has_virtual_destructor  0
is_constructible        1
is_copy_assignable      1
is_copy_constructible   1
is_destructible 1
is_default_constructible        1
is_move_assignable      1
is_move_constructible   1
is_trivially_constructible      0
is_trivially_copy_assignable    0
is_trivially_copy_constructible 0
is_trivially_destructible       0
is_trivially_default_constructible      0
is_trivially_move_assignable    0
is_trivially_move_constructible 0
is_nothrow_constructible        1
is_nothrow_copy_assignable      0
is_nothrow_copy_constructible   0
is_nothrow_destructible 1
is_nothrow_default_constructible        1
is_nothrow_move_assignable      1
is_nothrow_move_constructible   1

Custom class test

class Goo
{
public:
    virtual ~Goo()
    { }
private:
    int d1;
    int d2;
};

int main()
{
    type_traits_output(Goo());

    return 0;
}

Output:

tyoe traitd for type : 3Goo
is_array        0
is_class        1
is_enum 0
is_floating_point       0
is_function     0
is_integral     0
is_lvalue_reference     0
is_member_function_pointer      0
is_member_object_pointer        0
is_pointer      0
is_rvalue_reference     0
is_union        0
is_void 0
is_arithmetic   0
is_compound     1
is_fundamental  0
is_member_pointer       0
is_object       1
is_reference    0
is_scalar       0
is_abstract     0
is_const        0
is_empty        0
is_pod  0
is_polymorphic  1
is_literal_type 0
is_signed       0
is_standard_layout      0
is_trivial      0
is_trivially_copyable   0
is_unsigned     0
is_volatile     0
has_virtual_destructor  1
is_constructible        1
is_copy_assignable      1
is_copy_constructible   1
is_destructible 1
is_default_constructible        1
is_move_assignable      1
is_move_constructible   1
is_trivially_constructible      0
is_trivially_copy_assignable    0
is_trivially_copy_constructible 0
is_trivially_destructible       0
is_trivially_default_constructible      0
is_trivially_move_assignable    0
is_trivially_move_constructible 0
is_nothrow_constructible        1
is_nothrow_copy_assignable      1
is_nothrow_copy_constructible   1
is_nothrow_destructible 1
is_nothrow_default_constructible        1
is_nothrow_move_assignable      1
is_nothrow_move_constructible   1

Custom class test

class Zoo
{
public:
    Zoo(int it1, int it2) : d1(it1), d2(it2)
    { }
    Zoo(const Zoo&) = delete;
    Zoo(Zoo&&) = default;
    Zoo& operator=(const Zoo&) = default;
    Zoo& operator=(const Zoo&&) = delete;
    virtual ~Zoo()
    { }

private:
    int d1;
    int d2;
};

int main()
{
    type_traits_output(Zoo(1, 2));

    return 0;
}

Output:

tyoe traitd for type : 3Zoo
is_array        0
is_class        1
is_enum 0
is_floating_point       0
is_function     0
is_integral     0
is_lvalue_reference     0
is_member_function_pointer      0
is_member_object_pointer        0
is_pointer      0
is_rvalue_reference     0
is_union        0
is_void 0
is_arithmetic   0
is_compound     1
is_fundamental  0
is_member_pointer       0
is_object       1
is_reference    0
is_scalar       0
is_abstract     0
is_const        0
is_empty        0
is_pod  0
is_polymorphic  1
is_literal_type 0
is_signed       0
is_standard_layout      0
is_trivial      0
is_trivially_copyable   0
is_unsigned     0
is_volatile     0
has_virtual_destructor  1
is_constructible        0
is_copy_assignable      1
is_copy_constructible   0
is_destructible 1
is_default_constructible        0
is_move_assignable      0
is_move_constructible   1
is_trivially_constructible      0
is_trivially_copy_assignable    0
is_trivially_copy_constructible 0
is_trivially_destructible       0
is_trivially_default_constructible      0
is_trivially_move_assignable    0
is_trivially_move_constructible 0
is_nothrow_constructible        0
is_nothrow_copy_assignable      1
is_nothrow_copy_constructible   0
is_nothrow_destructible 1
is_nothrow_default_constructible        0
is_nothrow_move_assignable      0
is_nothrow_move_constructible   1

Type traits implementation

is_ Void (specialization and partial specialization)

/// remove_const
template<typename _Tp>
struct remove_const
{ typedef _Tp     type; };

template<typename _Tp>
struct remove_const<_Tp const>
{ typedef _Tp     type; };

/// remove_volatile
template<typename _Tp>
struct remove_volatile
{ typedef _Tp     type; };

template<typename _Tp>
struct remove_volatile<_Tp volatile>
{ typedef _Tp     type; };

/// remove_cv
template<typename _Tp>
struct remove_cv
{
  typedef typename
  remove_const<typename remove_volatile<_Tp>::type>::type     type;
};

//...

template<typename>
struct __is_void_helper
: public false_type { };

template<>
struct __is_void_helper<void>
: public true_type { };

/// is_void
template<typename _Tp>
struct is_void
: public __is_void_helper<typename remove_cv<_Tp>::type>::type
{ };

is_ Integral (specialization and partial specialization)

template<typename>
struct __is_integral_helper
: public false_type { };

template<>
struct __is_integral_helper<bool>
: public true_type { };

template<>
struct __is_integral_helper<char>
: public true_type { };

template<>
struct __is_integral_helper<signed char>
: public true_type { };

template<>
struct __is_integral_helper<unsigned char>
: public true_type { };

#ifdef _GLIBCXX_USE_WCHAR_T
template<>
struct __is_integral_helper<wchar_t>
: public true_type { };
#endif

template<>
struct __is_integral_helper<char16_t>
: public true_type { };

template<>
struct __is_integral_helper<char32_t>
: public true_type { };

template<>
struct __is_integral_helper<short>
: public true_type { };

template<>
struct __is_integral_helper<unsigned short>
: public true_type { };

template<>
struct __is_integral_helper<int>
: public true_type { };

template<>
struct __is_integral_helper<unsigned int>
: public true_type { };

template<>
struct __is_integral_helper<long>
: public true_type { };

template<>
struct __is_integral_helper<unsigned long>
: public true_type { };

template<>
struct __is_integral_helper<long long>
: public true_type { };

template<>
struct __is_integral_helper<unsigned long long>
: public true_type { };

// ...

/// is_integral
template<typename _Tp>
struct is_integral
: public __is_integral_helper<typename remove_cv<_Tp>::type>::type
{ };

is_class, is_union, is_enum, is_pod

/// integral_constant
template<typename _Tp, _Tp __v>
struct integral_constant
{
  static constexpr _Tp                  value = __v;
  typedef _Tp                           value_type;
  typedef integral_constant<_Tp, __v>   type;
  constexpr operator value_type() const noexcept { return value; }
}

// ...

/// is_class
template<typename _Tp>
struct is_class
: public integral_constant<bool, __is_class(_Tp)>
{ };

/// is_union
template<typename _Tp>
struct is_union
: public integral_constant<bool, __is_union(_Tp)>
{ };

/// is_enum
template<typename _Tp>
struct is_enum
: public integral_constant<bool, __is_enum(_Tp)>
{ };

/// is_pod
// Could use is_standard_layout && is_trivial instead of the builtin.
template<typename _Tp>
struct is_pod
: public integral_constant<bool, __is_pod(_Tp)>
{ };

Note:__ is_ XXX does not appear in the C + + standard library source code (may provide support for the standard library)

Recommended Today

Java Engineer Interview Questions

The content covers: Java, mybatis, zookeeper, Dubbo, elasticsearch, memcached, redis, mysql, spring, spring boot, springcloud, rabbitmq, Kafka, Linux, etcMybatis interview questions1. What is mybatis?1. Mybatis is a semi ORM (object relational mapping) framework. It encapsulates JDBC internally. During development, you only need to pay attention to the SQL statement itself, and you don’t need to […]