1
template<typename _Tp>
2
struct my_is_const{
3
    void func(){
4
        cout <<"not const" << endl;
5
    }
6
};
7

8
template<typename _Tp>
9
struct my_is_const<_Tp const>{
10
    void func(){
11
        cout <<"const" << endl;
12
    }
13
};
14
my_is_const<int> a;
15
my_is_const<const int>b;
16
a.func(); //not const
17
b.func(); // const

1
template<typename _Tp>
2
inline reference_wrapper<_Tp> ref(_Tp& __t) noexcept
3
{ return reference_wrapper<_Tp>(__t); }
4

5
template<typename _Tp>
6
void ref(const _Tp&&) = delete; //禁止接受右值
7

8
template<typename _Tp>
9
inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept
10
{ return ref(__t.get()); }

1
std::ref(5);//不可以

1
template<typename _Tp>
2
class reference_wrapper : public _Reference_wrapper_base<typename remove_cv<_Tp>::type> //这里去掉了CV。
3
{
4
    _Tp* _M_data; //内部就是包含一个指向原始对象的指针。
5

6
public:
7
    typedef _Tp type;
8

9
    reference_wrapper(_Tp& __indata) noexcept
10
        :_M_data(std::__addressof(__indata))
11
    {
12
    }
13

14
    reference_wrapper(_Tp&&) = delete;
15

16
    reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
17
        :_M_data(__inref._M_data)
18
    {
19
    }
20

21
    reference_wrapper& operator=(const reference_wrapper<_Tp>& __inref) noexcept
22
    {
23
        _M_data = __inref._M_data;
24
        return *this;
25
    }
26

27
    operator _Tp&() const noexcept //用户定义转换函数。使用了get
28
    { return this->get(); }
29

30
    _Tp& get() const noexcept //get用于返回原始对象的引用。起到引用的效果。
31
    { return *_M_data; }
32

33
    template<typename... _Args>
34
    typename result_of<_Tp&(_Args&&...)>::type
35
    operator()(_Args&&... __args) const
36
    {
37
        return __invoke(get(), std::forward<_Args>(__args)...);
38
    }
39
};

1
template <typename T>
2
void another_func(T a){
3
    a.get() = 2000;
4
}
5
int main() {
6
    int a = 1;
7
    another_func(ref(a));
8
    cout << a << endl; //修改为2000。
9
}
10

11
//或者是
12
void changeval(int& a){
13
    a = 20000;
14
}
15

16
template <typename T>
17
void func(T a){
18
    changeval(a); //因为有用户定义转换函数。这里的T本来是reference_wrapper类型的，但是可以隐式转换为原始类型。比如这里就是int&
19
}
20
int main() {
21
    int a = 1;
22
    func(ref(a));
23
    cout << a << endl; //修改为20000
24

25
}

1
template< class T > struct remove_cv                   { typedef T type; };
2
template< class T > struct remove_cv<const T>          { typedef T type; };
3
template< class T > struct remove_cv<volatile T>       { typedef T type; };
4
template< class T > struct remove_cv<const volatile T> { typedef T type; };
5

6
template< class T > struct remove_const                { typedef T type; };
7
template< class T > struct remove_const<const T>       { typedef T type; };
8

9
template< class T > struct remove_volatile             { typedef T type; };
10
template< class T > struct remove_volatile<volatile T> { typedef T type; };

1
template<class T>
2
typename std::enable_if<std::is_object<T>::value, T*>::type  addressof(T& arg) noexcept{
3
    return reinterpret_cast<T*>(//第四步
4
               &const_cast<char&>(//第二步和第三步。第三步单独指的取址&
5
                   reinterpret_cast<const volatile char&>(arg))); //第一步
6
}
7

8
template<class T>
9
typename std::enable_if<!std::is_object<T>::value, T*>::type addressof(T& arg) noexcept{
10
    return &arg;
11
}

1
template< class F, class... Args >
2
std::invoke_result_t<F, Args...>
3
  invoke( F&& f, Args&&... args ) noexcept;

1
//函数对象
2
template<typename _funcObj, typename... Args>
3
void test_func(_funcObj ptr, Args&&... args){
4
    // ptr(args...);
5
    std::invoke(ptr, forward<Args>(args)...); //注意加了forward
6
}
7

8
//成员函数指针，对象调用。
9
template<typename _Obj, typename _Ptr, typename... Args>
10
void test_memberfunc( _Ptr ptr, _Obj& obj, Args&&... args){
11
    //(obj.*ptr)(args...);
12
    std::invoke(ptr, obj, forward<Args>(args)...); //注意加了forward
13
}
14

15
//成员函数指针，指针调用。
16
template<typename _Obj, typename _Ptr, typename... Args>
17
void test_memberfunc_ptr(_Ptr ptr, _Obj* obj, Args&&... args){
18
    //((*obj).*ptr)(args...);
19
    std::invoke(ptr, obj, forward<Args>(args)...); //注意加了forward
20
}

1
myobj obj1(1);
2
function<void(int)> task = bind(&myobj::add, &obj1, placeholders::_1);
3
std::invoke(task, 5); //调用function包装的成员函数
4

5
test_memberfunc(&myobj::getval, obj1); //使用成员函数指针，对象调用
6
test_memberfunc(&myobj::add, obj1, 8);
7

8
test_memberfunc_ptr(&myobj::add, &obj1, 8); //使用成员函数指针，指针调用
9

10
test_func(&myobj::add, &obj1, 8); //使用提到的特殊例子，使用成员函数指针。会被特殊处理。

1
template<typename T>
2
T func(T obj){
3
    cout << "called" << endl;
4
    return obj;
5
}
6

7

8
int main() {
9
    auto f = std::invoke(func<int>, 100); //必须显式指明<int>
10
    return 0;
11
}

1
void p_2(unique_ptr<int> myptr){
2
    cout <<"p_2 called"<< endl;
3
    cout << *myptr << endl;
4
}
5
unique_ptr<int> ptrs(new int(10));
6
test_func(p_2, move(ptrs)); //外面记得也要移动

1
void p_3(myobj x){
2
    cout <<"p_3 called"<< endl;
3
    cout << *x.val << endl;
4
}
5

6
test_func(p_3, myobj(234));
7
template<typename _funcObj, typename Args> //为了方便测试，这里不用变参列表了。
8
void test_func(_funcObj ptr, Args&& args){
9
    // ptr(args...);
10
    std::invoke(ptr, forward<Args>(args)); //如果这里使用了完美转发
11
    cout << *args.val << endl; //args的右值特性被forward保留，触发移动构造。这里会段错误。
12
}

1
template<typename T>
2
T func(T obj){
3
    cout << "called" << endl;
4
    return obj;
5
}
6

7

8
int main() {
9
    decltype(auto) f = std::invoke(func<int>, 100); //f 类型是 int。刚才说过此处必须显示指明这个函数的模板参数。
10
    cout << f << endl; //输出100
11
    return 0;
12
}

1
template< class F, class... Args >
2
std::invoke_result_t<F, Args...>

1
cout << is_same_v<std::result_of_t<f_1&(int)>, int><< endl; //可以
2
//其实就相当于变为函数引用
3
cout << is_same_v<f_1&,int(&)(int)><< endl; //相当于函数引用类型
4
cout << is_same_v<f_1,int(int)><< endl; //相当于函数类型

1
template< class F, class... ArgTypes>
2
class invoke_result;

1
is_same<std::result_of_t<f_2(int)>, int>;// result_of_t
2
is_same<std::invoke_result_t<f_2, int>, int>; // invoke_result_t

1
template<typename T, typename Callable>
2
auto transform_sort(const vector<T>& vec, Callable c){
3
    vector<decay_t<result_of_t<Callable&(const T&)>>> ret; //查看对元素施加callable对象后，返回的值类型。然后创建这个类型的容器
4
    for(const T& item: vec){ //对每一个元素
5
        ret.push_back(invoke(c, item));//使用invoke施加callable，然后存入ret
6
    }
7
    sort(ret.begin(), ret.end());
8
    return ret;
9
}
10

11
int my_callable(const string& s){
12
    return s.size();
13
}
14
int main(){
15
    vector<string> my_vec{"a","abcd","abc","ab"};
16
    for(const auto& item: transform_sort(my_vec, my_callable)){
17
        cout << item << endl;
18
    }
19
    /*
20
    输出
21
    1
22
    2
23
    3
24
    4
25
    */
26
    return 0;
27
}

1
struct A {
2
    using mytype = int; //类A含有mytype类型
3
};
4

5
struct B{
6
    using mytype = void; //类B也含有mytype类型
7
};
8

9

10
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
11
struct has_type_member : std::false_type { //主模板继承false_type
12

13
 };
14

15
template<typename T1> //针对第二个参数进行偏特化
16
struct has_type_member<T1, std::void_t<typename T1::mytype>>: std::true_type { //偏特化继承true_type，并且使用void_t进行类型判断。
17
};
18

19
int main(){
20
    auto f = has_type_member<float>::value;
21
    auto a = has_type_member<A>::value;
22
    auto b = has_type_member<B>::value;
23
    cout << f << endl;
24
    cout << a << endl;
25
    cout << b << endl;
26
    /*
27
    输出
28
    0
29
    1
30
    1
31
    */
32
}

1
auto f = has_type_member<float>::value;  //扩展为has_type_member<float, void>::value;
2
auto a = has_type_member<A>::value;    //扩展为has_type_member<A, void>::value;
3
auto b = has_type_member<B>::value;    //扩展为has_type_member<B, void>::value;

1
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
2
struct has_type_member : std::false_type { //主模板继承false_type
3

4
 };
5

6
template<typename T1> //针对第二个参数进行偏特化
7
struct has_type_member<T1, typename T1::mytype>: std::true_type { //偏特化继承true_type，注意这里不用void_t,直接判断其type
8
};
9

10
int main(){
11
    auto f = has_type_member<float>::value;
12
    auto a = has_type_member<A>::value;
13
    auto b = has_type_member<B>::value;
14
    cout << f << endl;
15
    cout << a << endl;
16
    cout << b << endl;
17
    /*
18
    输出
19
    0
20
    0 //这个变了！！
21
    1
22
    */
23
}

1
template<typename T1 , typename T2 = int > //主模板，此时第二个参数默认值是int
2
struct has_type_member : std::false_type { //主模板继承false_type
3

4
 };
5

6
template<typename T1> //针对第二个参数进行偏特化
7
struct has_type_member<T1, std::void_t<typename T1::mytype>>: std::true_type { //偏特化继承true_type，并且使用void_t进行类型判断。
8
};
9
int main(){
10
    auto f = has_type_member<float>::value;
11
    auto a = has_type_member<A>::value;
12
    auto b = has_type_member<B>::value;
13
    cout << f << endl;
14
    cout << a << endl;
15
    cout << b << endl;
16
    /*
17
    输出
18
    0
19
    0 //这个变了
20
    0 //这个也变了
21
    */
22
}

1
struct A {
2
    int val = 234;      //类A含有val变量
3
};
4

5
struct B{
6
    float val2 = 345;  //类B不含有val变量，但是含有val2变量
7
};
8

9

10
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
11
struct has_type_member : std::false_type { //主模板继承false_type
12

13
 };
14

15
template<typename T1> //针对第二个参数进行偏特化
16
struct has_type_member<T1, std::void_t<decltype(T1::val)>>: std::true_type { //偏特化继承true_type，并且使用void_t且搭配decltype进行类型判断。
17
};
18
int main(){
19
    auto f = has_type_member<float>::value;
20
    auto a = has_type_member<A>::value;
21
    auto b = has_type_member<B>::value;
22
    cout << f << endl;
23
    cout << a << endl;
24
    cout << b << endl;
25
    /*
26
    输出
27
    0
28
    1
29
    0
30
    */
31
}

1
template<> //针对第二个参数进行偏特化
2
struct has_type_member<A, std::void_t<decltype(A::val)>>: std::true_type {
3
};

1
has_type_member <A,void>

1
struct A {
2
    void funcA();
3
};
4

5
struct B{
6
    void funcB();
7
};
8

9

10
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
11
struct has_type_member:std::false_type { //主模板继承false_type
12

13
 };
14

15
template<typename T1> //针对第二个参数进行偏特化
16
struct has_type_member<T1, std::void_t<decltype(std::declval<T1>().funcA())>>: std::true_type { //使用decltype和declval进行成员函数判断。
17
};
18
int main(){
19
    auto f = has_type_member<float>::value;
20
    auto a = has_type_member<A>::value;
21
    auto b = has_type_member<B>::value;
22
    cout << f << endl;
23
    cout << a << endl;
24
    cout << b << endl;
25
    /*
26
    输出
27
    0
28
    1
29
    0
30
    */
31
}

1
struct A {
2
    A() = delete;
3
    void myfunc(int s){
4
        //类A含有myfunc
5
    }
6
};
7

8
struct B{
9
    void myfuncB(){
10
        //类B不含有myfunc，但是含有myfuncB
11
    }
12
};
13

14

15
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
16
struct has_type_member:std::false_type { //主模板继承false_type
17

18
 };
19

20
template<typename T1>
21
struct has_type_member<T1, std::void_t<decltype(&T1::myfunc)>>: std::true_type { //通过成员函数地址判断。OK
22
};
23
int main(){
24
    auto f = has_type_member<float>::value;
25
    auto a = has_type_member<A>::value;
26
    auto b = has_type_member<B>::value;
27
    cout << f << endl;
28
    cout << a << endl;
29
    cout << b << endl;
30
    /*
31
    输出
32
    0
33
    1
34
    0
35
    */
36
}

1
template<class T>
2
T declval() noexcept;

1
template<class T, class>  //主模板
2
struct IP_impl : false_type {
3
};
4
template<class T> //偏特化
5
struct IP_impl<T, decltype(dynamic_cast<void*>(declval<remove_cv_t<T>*>()))> : true_type {
6
};
7
template<class T>
8
struct is_polymorphic : IP_impl<T, void*> { //外层。注意这里第二个参数必须是void*
9
    //原因是因为如果是void，就算是多态也会匹配到主模板。
10
    //因为我们提供的第二个参数是void，但是如果满足多态，第二个参数会被偏特化模板推导为void*，这时候就不满足了
11
    //然后就会fallback到主模板。
12
};

1
template<typename T>
2
T fuckval() noexcept; //随便写一个
3

4
template<typename T, typename>
5
struct ip_jmpl:false_type{
6
};
7
template<typename T>
8
struct ip_jmpl<T, decltype(dynamic_cast<void*>(fuckval<T*>()))>:true_type{ //换成fuckval完全没问题。
9
    void f(){
10
        std::puts(__PRETTY_FUNCTION__);
11
    }
12
};
13
template<typename T>
14
struct ip_po : ip_jmpl<T, void*> {
15
};

1
else if constexpr (_Reversed_subrange<_Ty> == 1) {
2
    using _It = decltype(_STD declval<_Rng&>().begin().base());
3
    return {_St::_Subrange_sized,
4
            noexcept(subrange<_It, _It, subrange_kind::sized>{
5
                _STD declval<_Rng&>().end().base(), _STD declval<_Rng&>().begin().base(),
6
                _STD declval<_Rng&>().size()})};
7
} else if constexpr (_Can_reverse<_Rng>) {
8
    return {_St::_Reverse, noexcept(reverse_view{_STD declval<_Rng>()})};
9
}