1
//uaddr指向一个地址，val代表这个地址期待的值，当*uaddr==val时，才会进行wait
2
int futex_wait(int *uaddr, int val);
3

4
//唤醒n个在uaddr指向的锁变量上挂起等待的进程
5
int futex_wake(int *uaddr, int n);

1
long syscall(SYS_futex, uint32_t *uaddr, int futex_op, uint32_t val,
2
                    const struct timespec *timeout,   /* or: uint32_t val2 */
3
                    uint32_t *uaddr2, uint32_t val3);

1
struct futex_q {
2
    struct plist_node list;        //链表节点
3
    struct task_struct *task;      //挂起在该futex变量关联的进程（线程）
4
    spinlock_t *lock_ptr;          //自旋锁，控制链表访问
5
    union futex_key key;           //futex变量地址标识
6

7
    //下面三个与优先级继承相关，在此不多介绍
8
    struct futex_pi_state *pi_state;
9
    struct rt_mutex_waiter *rt_waiter;
10
    union futex_key *requeue_pi_key;
11

12
    u32 bitset;                    //类似掩码匹配
13
};

1
//bucket
2
struct futex_hash_bucket {
3
    //当前自旋等待哈希桶的waiter数目
4
  atomic_t waiters;
5

6
    //自旋锁，用于控制chain的访问，
7
    //struct futex_q中lock_ptr，就是引用其所在的bucket的自旋锁
8
  spinlock_t lock;
9

10
  //优先级链，与传统等待队列不同，futex使用优先级链表来实现等待队列，
11
    //是为了实现优先级继承，从而解决优先级翻转问题
12
  struct plist_head chain;
13
} ____cacheline_aligned_in_smp;
14

15
//全局哈希表
16
static struct {
17
  struct futex_hash_bucket *queues;
18
  unsigned long            hashsize;
19
} __futex_data __read_mostly __aligned(2*sizeof(long));
20
#define futex_queues   (__futex_data.queues)
21
#define futex_hashsize (__futex_data.hashsize)

1
template<typename 模板参数表>
2
class 类名{
3
    // 类定义．．．．．．
4
};

1
template<typename T1, typename T2>
2
class test{
3
    T1 data1;
4
    T2 data2;
5
};
6
//全特化
7
template<>
8
class test<int, float>{
9
    int data1;
10
};
11
//偏特化
12
template<typename T2>
13
class test<int, T2>{
14
    int data1;
15
};

1
void test(int a, int b){
2
    cout << "普通函数" << endl;
3
}
4

5
template <typename T>
6
void test(T a, T b){
7
    cout << "模板函数" << endl;
8
}
9

10
template <typename T>
11
void test(T a, T b, T c){
12
    cout << "重载的模板函数" << endl;
13
}
14

15
int main(){
16
    test(1,2); //输出普通函数
17
    test<>(1,2); //使用空模板参数列表 输出模板函数
18
    test(1,2,3); //输出重载的模板函数
19
}

1
template<template<typename> class container, typename T1, typename T2> // 最基本的举例
2
class test{
3
    container<T1> a1;
4
    container<T2> a2;
5
};

1
template <typename T, template <typename> class Container>
2
template <typename T, template <class> class Container>
3
template <typename T, template <typename> typename Container>

1
template <typename T, template <typename T1> typename Container>

1
template<typename T>
2
void func(T obj){
3
    //...
4
}
5

6
int main(){
7
    func<int>(5);
8
    return 0;
9
}

1
template<typename T, int MAXSIZE>
2
void func1(T obj){
3
    vector<T>a;
4
    a.reserve(MAXSIZE);
5
    cout << a.capacity() << endl;
6
    a.push_back(obj);
7
    cout << a[0] << endl;       //干啥了不解释了 忽略即可
8
}

1
const int s = 8;  //必须是const
2
func1<int, s>(5);
3
func2<int, 4>(5); //或者直接传入字面值。

1
template <bool, typename T=void>
2
struct enable_if {
3
};
4
template <typename T>
5
struct enable_if<true, T> { ///< 第一个模板参数为 true
6
  using type = T;           ///< type 才有定义
7
};

1
template<int stat> //这里是非模板类型参数。上面提到了。注意一下
2
typename enable_if<stat == 1, bool>::type checkstate(){
3
    cout <<"type is bool" << endl;
4
    return true;
5
}
6
template<int stat>
7
typename enable_if<stat == 0, int>::type checkstate(){
8
    cout <<"type is int" << endl;
9
    return 5;
10
}
11

12
template<bool stat>      //bool也可以。隐式转换为整型了，但是必须要常量。
13
typename enable_if<stat == true, int>::type checkstate1(){
14
    cout <<"type is int" << endl;
15
    return 5;
16
}
17

18
int main(){
19
    const int myobj = 1;   //必须是const
20
    checkstate<myobj>();  //输出"type is bool"
21
    checkstate<0>();    //输出"type is int"
22
    return 0;
23
}

1
template <typename T, typename... Args>
2
// 如果函数参数列表中一个参数的类型是一个模板参数包,
3
// 则此参数也是一个函数参数包
4
void func(const T& t, const Args&... rest);

1
void print (){
2
//必须要有无参重载，否则会无限递归。也就是最后一次无参无法被调用。
3
//最后一次被解包后，参数包会为空。所以会调用无参函数。
4
}
5
template<typename T, typename... Args>
6
void print (T firstArg, Args... args)
7
{
8
    cout << firstArg << endl; //print first argument
9
    print(args...); // call print() for remaining arguments
10
}
11
int main()
12
{
13
    print(1, 1000, "b23", 1.123, "HahaahaH", 42);
14
    return 0;
15
}

1
template<typename T> //要有单参打印的重载。不然会无限调用。
2
void print(T t){
3
    cout << t << endl;
4
}
5

6

7
template<typename... Args>
8
void print(Args... args){
9
    (print(args),...); //这里外部一定要加括号。注意语法
10
}
11

12

13
int main()
14
{
15
    print(1, 1000, "b23", 1.123, "HahaahaH", 42);
16
    return 0;
17
}

1
template<typename... Ts> class Variadic;

1
template<typename T1, typename T2>
2
class test{
3
public:
4
    T1 _a;
5
    T2 _b;
6
    test(T1 a, T2 b) : _a(a), _b(b) {}
7
};
8

9
void testprint1(test<int,int>& obj){ //方法1 显式指定传入类型
10
    cout << obj._a << obj._b << endl;
11
}
12

13
template<typename T1, typename T2>
14
void testprint2(test<T1, T2>& obj){ //方法2 使用参数模板
15
    cout << obj._a << obj._b << endl;
16
}
17

18

19
template<typename T>
20
void testprint3(T& obj){ //方法3 利用函数模板的自动推导特性
21
    cout << obj._a << obj._b << endl;
22
}
23

24
int main(){
25
    test<int,int> b(5,5);
26
    testprint1(b);
27
    testprint2(b);
28
    testprint3(b);
29
}

1
template<typename T1, typename T2>
2
class test{
3
public:
4
    T1 _a;
5
    T2 _b;
6

7
    test(T1 a, T2 b) : _a(a), _b(b) {}
8

9
    void showitem(){
10
        cout << this->_a << "," << this->_b << endl;
11
    }
12

13

14
};
15

16
template<typename T1, typename T2, typename T3, typename T4>
17
class test1 : public test<T1, T2>{ //!继承模板父类，子类父类都要是模板类。而且要显式指定父类模板类型。
18
public:
19
    // T1 _a;   //!如果子类也有自己的_a 和_b变量的话 那就不能调用父类构造函数赋值。
20
                //!想一下，子类自己的东西怎么可能让父类构造函数赋值？
21
                //@所以调用父类构造函数赋值其实相当于给子类的父类成分赋值。
22
    // T2 _b;
23
    T3 _c;
24
    T4 _d;
25
    //test1(T3 a, T4 b) : _a(a), _b(b) {}
26
    test1(T1 a, T2 b, T3 c, T4 d) : test<T1, T2>(a,b),_c(c),_d(d) //调用父类构造函数赋值 //!记得调用模板类父类构造函数的时候要显式指定数据类型
27
    {
28
        //!可以用构造列表也可以普通构造函数
29
        // _c = c;
30
        // _d = d;
31
    }
32
    void showitem(){
33
        cout << this->_a << "," << this->_b << "," << this->_c << "," << this->_d<< endl;
34
    }
35

36
};
37

38

39

40
int main(){
41
    test<int,int>* b = new test<int, int>(5,5);
42
    b->showitem();
43
    test1<int, int, char, char>* c = new test1<int, int, char, char>(1,2,'a','b');
44
    c->showitem();
45

46
    //指针和对象都可以
47
    test<int,int> bb(5,5);
48
    bb.showitem();
49
    test1<int, int, char, char> cc (1,2,'a','b');
50
    cc.showitem();
51
}

1
class A {
2
    public:
3
        A(){}
4
        A(int a) :m_a(a) {}
5
        virtual~A(){}
6
    int m_a;
7
};
8

9
class B : public A{
10
    public:
11
        B(){}
12
        B(int x):m_b(x){}
13
        B(int no, int x):A(no),m_b(x){} //子类调用父类构造。必须用初始化列表。
14
        ~B(){}
15
        int m_b;
16
};
17

18
int main(){
19
    B b(5,8);
20
    cout << b.m_a << endl;
21

22
    return 0;
23
}

1
template<typename T1, typename T2>
2
class test{
3
    T1 _a;
4
    T2 _b;
5
    test(T1 a){} //构造1
6
    test(T1 a, T2 b){} //构造2
7
    void func1(); //无参函数1
8
    void func2(T1 a); //有参函数2
9
};
10

11
/*
12
类模板 成员函数 类外实现
13
头部要加模板
14
作用域部分要显式指明数据类型
15
*/
16
template<typename T1, typename T2>
17
test<T1, T2>::test(T1 a) : _a(a){} //构造1 使用初始化列表
18

19

20
template<typename T1, typename T2>
21
test<T1, T2>::test(T1 a, T2 b){ //构造2
22
    _a = a;
23
    _b = b;
24
}
25

26
template<typename T1, typename T2>
27
void test<T1, T2>::func1(){ //无参函数1
28
    cout <<"func1" << endl;
29
}
30

31
template<typename T1, typename T2>
32
void test<T1, T2>::func2(T1 a){ //有参函数2
33
    cout <<"func2" << endl;
34
}

1
auto&& z = {1, 2, 3};//这个不是万能引用。（初始化器列表的特殊情形）

1
std::unique_ptr<int> func(int x){
2
    std::unique_ptr<int> p = std::make_unique<int>(x);
3
    return {p};
4

5
}
6

7
std::unique_ptr<int> func2(int x){
8
    std::unique_ptr<int> p = std::make_unique<int>(x);
9
    return p;
10

11
}

1
myobj func2(bool s){
2
    myobj d {2};
3
    if(s){
4
        return d;
5
    }
6
    d.val = new int(3);
7
    return d;
8
}

1
myobj func(bool s){
2
    myobj d {2};
3
    if(s){
4
        return d;
5
    } else {
6
        return myobj{3};
7
    }
8
}

1
myobj func2(bool s){
2
    if(s){
3
        return myobj{3};
4
    }
5
    myobj d {2};
6
    return d;
7
}

1
vector<int> process(vector<string>& input){
2
    vector<int> ret;
3
    stringstream ss; //stringstream对象
4
    for(int i = 0; i < input.size(); i++){
5
        ss << input[i]; //要转换的东西插入对象
6
        int a;
7
        ss >> a; //提取至我们想要的对象
8
        ss.clear(); //清空stringstream对象
9
        ret.push_back(a);
10
    }
11
    return ret;
12
}
13
int main(){
14
    vector<string> s{"1","2","200","-20","-10000"};
15
    vector<int> ret = process(s);
16
    for(int i = 0; i < ret.size(); i++){
17
        cout << ret[i] << endl;
18
    }
19
    return 0;
20
}

1
void split(const string& str){
2
    vector<string> item;
3
    stringstream ss(str); //字符串放入stringstream对象
4
    string temp; //储存临时分割对象
5
    while(ss >> temp){ //直到字符耗尽
6
        item.emplace_back(temp); //放入结果数组。
7
    }
8

9
    for(auto& i:item){
10
        cout << i << endl;
11
    }
12

13
}

1
void split(const string& str, const char& splitter){
2
    vector<string> item;
3
    stringstream ss(str);
4
    string temp;
5
    while(getline(ss, temp, splitter)){
6
        item.emplace_back(temp);
7
    }
8
    for(auto& i:item){
9
        cout << i << endl;
10
    }
11

12
}

1
std::initializer_list<int> func(void){
2
  int a = 1, b = 2;
3
  return {a, b};      //a与b是局部变量在func返回后会被释放，但是复制的返回值initializer_list不会创建元素副本。而是和临时对象共享空间。所以
4
                      //func返回后会被释放，initializer_list内部会存在空悬引用！危险！
5
                      //正确的做法可以将返回值改为保存副本的容器，如vector<int>
6
}
7

8
//注意下面s1、s2、s3和s4均共享元素空间
9
initializer_list<string> s1 = { "aa", "bb", "cc", "dd" };
10
initializer_list<string> s2 = s1;
11
initializer_list<string> s3(s1);
12
initializer_list<string> s4;
13
s4 = s1;
14

15
//注意元素会被复制初始化
16
int a = 200;
17
int b = 300;
18
int c = 400;
19
initializer_list<int> mylist{ a,b,c };
20
a = 800;
21
cout << *mylist.begin() << endl; //200
22
cout << a << endl; //800