2. __atomic_compare_exchange_n系列是新版gcc内置的，支持6种memory order；

3. std::atomic之类的是stl的封装；

4. 6种mem order，https://www.zhihu.com/question/24301047里讲得不错，概括下：

memory_order_seq_cst最严，memory_order_relaxed最松，通常是用acquire（load时）/release（store时）模式，在该大模式下：

a. 通常是读用memory_order_acquire，写用memory_order_release；

b. 如果只是针对单个变量且该变量没有依赖的变量，acquire可以弱化为consume；

c. 如果不想区分什么单变量多变量或读写状态，简单点统一用memory_order_acq_rel。

so true 2020-06-28 17:19 发表评论

so true 2019-05-09 18:53 发表评论

上面这些概念的引入完全是为了解决一个问题：尽可能用浅拷贝代替深拷贝；具体该如何实施呢：

1. 定义move constructor或move operator=，如果你新定义的类没有move constructor或move operator=，那根本就用不上上面那些高级的概念；

2. 告诉编译器什么时候用move constructor（而不是用copy constructor），这就需要借助std::move来把左值转成右值；

下面是一些零散的箴言：

左值：能用&来取地址的东西（有名字的都是左值，不管其是否是const的，而且引用都是左值，因为引用肯定得起个名字去引用另外一个东西）；

右值：不能用&来取地址的东西（说白了就是没名字的东西，例如函数的返回值）；

const T&是万能引用，即 const T& t = XXX; //XXX是左值、右值都可以；

T& t = XXX; //XXX必须是左值；

T&& t = XXX; //XXX必须是右值；
const T&& t = XXX; //XXX必须是右值；

不要把T&&和const T&划等号，两个都能hold住临时变量，给临时变量续命，但：

T&& t1 = get_val();

const T& t2 = get_val();

t1和t2都是左值，因为都可以用&来取地址，但t1是非const的，因此可以t1.xxx = yyy;去修改t1里的内容（当然如果你定义const T&& t1 = get_val()，那就不能更改了），这样一来，下面这种代码受益了：

    string name = get_name(); //因为后面要修改name，所以不能用const string& name

    trim(name);

    可以修改为：

    string&& name = get_name();

    trim(name);

    

关于右值引用的生命周期（续命能续多久，下面讨论的也适用于const T&）：

1. 函数不能返回对局部变量的引用（右值引用也不行），这是铁的原则；

2. 引用一旦建立（用一个名字hold住了临时变量），例如T&& t = get_val();那么这个临时变量的析构时机就是变量t退出其作用域的时候，因此下面的代码是错误的：

    struct A {

        A(T&& t): _t(t) {};

        T&& _t;

    };

    A* pa = NULL;

    {

        T&& t = get_val();

        pa = new A(t);

    }

    pa->_t; //runtime crash, _t已经析构了

    

std::move只做一件事：把左值转成右值，因此T t(std::move(get_val()));不管什么情况下都能保证调用move constructor来构造t；

c++0x里stl的各种容器都已经新增了move constructor，因此当你希望使用浅拷贝的时候可以借助std::move来达成所愿了，至于什么时候可以用浅拷贝，分两种情况，有些情况编译器会默认帮你去调用move constructor，但在你自己新定义的函数或者类成员方法里就需要你自己来判断了，大的原则就是：这个变量只是传递过去就好，中间可以转好几道手，但在传递过程中不需要做修改；

完美转发（std::forward），谈到这个就必须得谈到通用引用（universal reference）、引用折叠（reference collapsing），其实这几个概念是捆绑在一起的，而且只用在模板范畴内，而且只是为了解决下面这一种模式：

template <typename T>

void func2(T t) {

}

template <typename T>

void func(T&& t) {

    func2(std::forward<T>(t));

}

上面这个到底完美在哪里？

func(get_val()); //这个会导致最后是通过move constructor来构造func2函数里的参数t

T t0 = get_val();

T& t1 = t0;

const T& t2 = get_val();

T&& t3 = get_val();

const T&& t4 = get_val();

func(t0); func(t1); func(t2); func(t3); func(t4); //这5个都会导致最后是通过copy constructor来构造func2函数里的参数t，因为这个5个t*都是左值（有名字的就是左值）；

    插播两个你有可能费解的地方：

    1. func函数的参数是T&&, t0、t1都是左值，不是说不能用左值赋值给右值吗？这就要提到引用折叠了（详情可参见最后我推荐的文章），说白了因为func是个模板函数才能这么干；

    2. t3类型是T&&，func的参数也是T&&，把t3传递过去，居然还是调用copy contructor，因为t3是右值引用，它引用了一个右值，但它本身却是左值，到了func函数内部，func函数只能知道它是个左值，了解不到它原本的面貌居然是个右值引用；如果还不理解，再看下下面：

    template <typename T>

    void print(T t) {

    }

    int x1 = 1; int& x2 = x1; const int& x3 = x1; int* x4 = &x1;

    分别用x{1..4}来调用print方法，你肯定知道x1、x2、x3到了print函数里，T就是int，只有x4会被print函数认为T是int*，引用这个概念在模板类型推导时是无法让模板参数感知到的；此外print(T)和print(T&)是不能同定义的，编译器会抱怨ambiguous，这个事实也能帮你多一些理解。

如果想让上面的这5个最终能通过move constructor来构造func2函数里的参数t，那么只要给每个都用func(std::move(t*))包装下就可以了；

再澄清下，func2函数的参数是类型T，并不是引用，因此无论如何都需要生成T的一个新实例，区别就是到底是通过copy constructor还是move constructor来生成了；

所以，所谓的完美就是体现在了forward能把本来是左值的按左值来传递，本来是右值的按照右值来传递，具体来说就是作为中间环节的func函数内部实现过程中使用了func2(std::forward<T>(t));这句话，使得可以按照调用方实际的真实情况告知给func2函数如何构造参数t，这有什么好处呢，还是那句话：在适当的时机做合适的引导，让编译器帮你调用浅拷贝。

除此之外，你完全可以忘掉这些玄乎其神的概念，所以只要会套用就可以了。

以上是一些梗概性或结论性的东西，再结合下面这篇文章，把骨头之外的血肉补上吧：

https://codinfox.github.io/dev/2014/06/03/move-semantic-perfect-forward/

so true 2018-12-06 11:38 发表评论

  1 #include <iostream>
  2 #include <typeinfo>
  3 #include <string>
  4 #include <fstream>
  5 #include <sstream>
  6 #include <stdint.h>
  7 #include <pthread.h>
  8 #include <unistd.h>
  9 #include <string.h>
 10 #include <vector>
 11 #include <map>
 12 #include <set>
 13 
 14 using namespace std;
 15 
 16 template<typename T>
 17 struct type_to_pointer { typedef T* type; };
 18 template <typename T>
 19 struct type_to_pointer<T*> { typedef T* type; };
 20 template <typename T>
 21 struct type_to_pointer<const T*> { typedef T* type; };
 22 template <typename T>
 23 struct type_to_pointer<T*const> { typedef T* type; };
 24 template <typename T>
 25 struct type_to_pointer<const T *const> { typedef T* type; };
 26 template <typename T>
 27 struct type_to_pointer<T**> { typedef T* type; };
 28 template <typename T>
 29 struct type_to_pointer<const T**> { typedef T* type; };
 30 template <typename T>
 31 struct type_to_pointer<T**const> { typedef T* type; };
 32 template <typename T>
 33 struct type_to_pointer<T&> { typedef T* type; };
 34 template <typename T>
 35 struct type_to_pointer<T&&> { typedef T* type; };
 36 template <typename T>
 37 struct type_to_pointer<const T&> { typedef T* type; };
 38 template <typename T, int N>
 39 struct type_to_pointer<T[N]> { typedef T* type; };
 40 template <typename T, int N>
 41 struct type_to_pointer<const T[N]> { typedef T* type; };
 42 template <typename T, int N>
 43 struct type_to_pointer<T*[N]> { typedef T* type; };
 44 template <typename T, int N>
 45 struct type_to_pointer<const T*[N]> { typedef T* type; };
 46 template <typename T, int N>
 47 struct type_to_pointer<const T *const[N]> { typedef T* type; };
 48 
 49 template <typename FromType, typename ToType = void>
 50 void type_printer() {
 51     cout << __PRETTY_FUNCTION__ << endl;
 52 }
 53 
 54 #define TYPE_PRINT(var) type_printer<decltype(var), type_to_pointer<decltype(var)>::type>()
 55 #define CONST_CAST_TO_POINTER(var) const_cast<typename type_to_pointer<decltype(var)>::type>(var)
 56 
 57 int main(int argc, char* argv[]) {
 58     int x1 = 0;
 59     TYPE_PRINT(x1);
 60 
 61     const int& x2 = x1;
 62     TYPE_PRINT(x2);
 63 
 64     const int* x3 = &x1;
 65     TYPE_PRINT(x3);
 66     TYPE_PRINT(CONST_CAST_TO_POINTER(x3));
 67 
 68     const int *const x4 = &x1;
 69     TYPE_PRINT(x4);
 70     TYPE_PRINT(CONST_CAST_TO_POINTER(x4));
 71 
 72     int& x5 = x1;
 73     TYPE_PRINT(x5);
 74 
 75     int *const x6 = &x1;
 76     TYPE_PRINT(x6);
 77     TYPE_PRINT(CONST_CAST_TO_POINTER(x6));
 78 
 79     int* x7 = &x1;
 80     TYPE_PRINT(x7);
 81 
 82     int&& x8 = 0;
 83     TYPE_PRINT(x8);
 84 
 85     int x9[2] = {1, 2};
 86     TYPE_PRINT(x9);
 87 
 88     const int x10[2] = {1, 2};
 89     TYPE_PRINT(x10);
 90 
 91     int* x11[2] = {NULL, NULL};
 92     TYPE_PRINT(x11);
 93 
 94     const int* x12[2] = {NULL, NULL};
 95     TYPE_PRINT(x12);
 96 
 97     const int *const x13[2] = {NULL, NULL};
 98     TYPE_PRINT(x13);
 99 
100     TYPE_PRINT(argc);
101     TYPE_PRINT(argv);
102     return 0;
103 }

so true 2018-11-08 19:03 发表评论

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

long g_idx = 0;

class ThreadRwLock {

private:

    pthread_rwlock_t m_rw_mutex;

public:

    ThreadRwLock() {

        pthread_rwlockattr_t attr;

        // 设置写优先

        pthread_rwlockattr_init(&attr);

        //pthread_rwlockattr_setkind_np(&attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP);

        pthread_rwlock_init(&m_rw_mutex, &attr);

    }

    ~ThreadRwLock() {

        pthread_rwlock_destroy(&m_rw_mutex);

    }

    void rdlock() {

        pthread_rwlock_rdlock(&m_rw_mutex);

    }

    void wrlock() {

        pthread_rwlock_wrlock(&m_rw_mutex);

    }

    int tryrdlock() {

        return pthread_rwlock_tryrdlock(&m_rw_mutex);

    }

    int trywrlock() {

        return pthread_rwlock_trywrlock(&m_rw_mutex);

    }

    void unlock() {

        pthread_rwlock_unlock(&m_rw_mutex);

    }

};

ThreadRwLock g_lock;

void* thread_routine(void* arg) {

    long is_write = (long)arg;

    if (is_write) {

        printf("%lu wait write lock\n", pthread_self()); fflush(stdout);

        g_lock.wrlock();

        long idx = __sync_add_and_fetch(&g_idx, 1);

        printf("%lu get write lock, %ld\n", pthread_self(), idx); fflush(stdout);

        sleep(5);

        g_lock.unlock();

    } else {

        printf("%lu wait read lock\n", pthread_self()); fflush(stdout);

        g_lock.rdlock();

        long idx = __sync_add_and_fetch(&g_idx, 1);

        printf("%lu get read lock, %ld\n", pthread_self(), idx); fflush(stdout);

        sleep(5);

        g_lock.unlock();

    }

    return NULL;

}

int main(int argc, char* argv[]) {

    pthread_t tid = 0;

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    getchar(); //让程序暂停，等待键盘敲入一个字节后，接着走

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    sleep(2); //确保写锁被优先拿到

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)1);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    pthread_create(&tid, NULL, thread_routine, (void*)0);

    getchar();

    return 0;

}

so true 2018-05-14 12:07 发表评论

        int pivot = i++;

        while (true) {

            while (i <= j && nums[i] <= nums[pivot]) ++i; //a

            while (j >= i && nums[j] >= nums[pivot]) --j; //b

            if (i > j) {

                break;

            }

            int t = nums[i]; nums[i++] = nums[j]; nums[j--] = t; //c

        }

        int t = nums[j]; nums[j] = nums[pivot]; nums[pivot] = t;

        return j;

    }
上面这段代码里，细节太多太多，居然搞了一晚上才搞出来，总的来说大方向上：
1. 要确保最后能i > j才能终止（其实终止的时候，是一定满足j + 1 == i的）；
2. 因为保留的是最左侧的数为基准，排序目标是从左到右按照从小到大排，因此最后要把pivot和j交换；
3. //a和//b里，其实只要有一个nums[i]/nums[j]和nums[pivot]的等于判断就可以了，这里为了一致性，都保留了对等于的判断；
4. //c里增加了i和j各自挪一步的操作，因此如下写法更好：

so true 2017-11-26 00:03 发表评论

  1 #include <sys/time.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <iostream>
  5 #include <vector>
  6 #include <string>
  7 #include <set>
  8 
  9 class Sudoku {
 10 public:
 11     Sudoku(const std::string& question, bool does_try_all_answers = false): m_does_try_all_answers(does_try_all_answers), m_data(9) {
 12         for (int i = 0; i < 9; ++i) {
 13             m_data[i].resize(9);
 14             for (int j = 0; j < 9; ++j) {
 15                 m_data[i][j] = question[i * 9 + j];
 16             }
 17         }
 18     }
 19 
 20     bool Solve() {
 21         return Fill(0, 0);
 22     }
 23 
 24     const std::string GiveOneAnswer() const {
 25         return m_all_answers.empty() ? "" : *m_all_answers.begin();
 26     }
 27 
 28     const std::set<std::string> GiveAllAnswers() const {
 29         return m_all_answers;
 30     }
 31 
 32     static const std::string ProvideOneQuestionRandomly(int min_filled_num = 30) {
 33         std::vector<std::vector<char> > ques(9, std::vector<char>(9, '.'));
 34 
 35         struct timeval cur_tv;
 36         gettimeofday(&cur_tv, NULL);
 37         srand(cur_tv.tv_usec);
 38 
 39         int valid_digit_num = 0;
 40         for (int i = 0; i < 9; ++i) {
 41             for (int j = 0; j < 9; ++j) {
 42                 if (rand() % 81 <= min_filled_num + valid_digit_num / 6) {
 43                     char c = rand() % 9 + '1';
 44 
 45                     if (DoesConflict(ques, i, j, c)) {
 46                         int k = 0;
 47                         for (; k < 8; ++k) {
 48                             if (c == '9') {
 49                                 c = '1';
 50                             }
 51                             if (!DoesConflict(ques, i, j, ++c)) {
 52                                 break;
 53                             }
 54                         }
 55                         if (8 == k) {
 56                             c = '.';
 57                         }
 58                     }
 59 
 60                     valid_digit_num += ('.' != c);
 61                     ques[i][j] = c;
 62                 } else {
 63                     ques[i][j] = '.';
 64                 }
 65             }
 66         }
 67 
 68         char buf[82];
 69         buf[81] = '\0';
 70         for (int i = 0; i < 9; ++i) {
 71             for (int j = 0; j < 9; ++j) {
 72                 buf[i * 9 + j] = ques[i][j];
 73             }
 74         }
 75 
 76         Sudoku sudoku(buf);
 77         sudoku.Solve();
 78         if (81 == sudoku.GiveOneAnswer().size()) {
 79             return buf;
 80         } else {
 81             return ProvideOneQuestionRandomly(min_filled_num);
 82         }
 83 
 84         return buf;
 85     }
 86 
 87     static void PrintSudoku(const std::string& sudoku) {
 88         if (sudoku.size() < 81) {
 89             return;
 90         }
 91 
 92         for (int i = 0; i < 9; ++i) {
 93             for (int j = 0; j < 9; ++j) {
 94                 if (0 != j) {
 95                     std::cout << " ";
 96                 }
 97                 std::cout << sudoku[i * 9 + j];
 98             }
 99             std::cout << std::endl;
100         }
101     }
102 
103     static bool ValidateOneAnswer(const std::string& answer) {
104         if (answer.size() != 81) {
105             return false;
106         }
107 
108         for (int i = 0; i < 9; ++i) {
109             char hit_h[9] = { '\0' };
110             char hit_v[9] = { '\0' };
111             for (int j = 0; j < 9; ++j) {
112                 if ('.' == answer[i * 9 + j] || ++hit_h[answer[i * 9 + j] - '1'] != 1) { //row check
113                     return false;
114                 } else if ('.' == answer[j * 9 + i] || ++hit_v[answer[j * 9 + i] - '1'] != 1) { //column check
115                     return false;
116                 }
117                 if (0 == i % 3 && 0 == j % 3) { //3x3 square check
118                     char hit_m[9] = { '\0' };
119                     for (int i2 = i; i2 < i + 3; ++i2) {
120                         for (int j2 = j; j2 < j + 3; ++j2) {
121                             if ('.' == answer[i2 * 9 + j2] || ++hit_m[answer[i2 * 9 + j2] - '1'] != 1) {
122                                 return false;
123                             }
124                         }
125                     }
126                 }
127             }
128         }
129         return true;
130     }
131 
132 private:
133     void AddOneAnswer() {
134         char buf[82];
135         buf[81] = '\0';
136 
137         for (int i = 0; i < 9; ++i) {
138             for (int j = 0; j < 9; ++j) {
139                 buf[i * 9 + j] = m_data[i][j];
140             }
141         }
142 
143         m_all_answers.insert(buf);
144     }
145 
146     static bool DoesConflict(const std::vector<std::vector<char> >& data, int i, int j, char digit) {
147         for (int k = 0; k < 9; ++k) {
148             if (digit == data[i][k]) {
149                 return true;
150             }
151             if (digit == data[k][j]) {
152                 return true;
153             }
154         }
155 
156         int i0 = i - i % 3;
157         int j0 = j - j % 3;
158         for (int i2 = i0; i2 < i0 + 3; ++i2) {
159             for (int j2 = j0; j2 < j0 + 3; ++j2) {
160                 if (digit == data[i2][j2]) {
161                     return true;
162                 }
163             }
164         }
165 
166         return false;
167     }
168 
169     bool Fill(int i, int j) {
170         for (; i < 9; ++i, j = 0) {
171             for (; j < 9; ++j) {
172                 if ('.' == m_data[i][j]) {
173                     for (int k = '1'; k <= '9'; ++k) {
174                         if (DoesConflict(m_data, i, j, k)) {
175                             continue;
176                         }
177 
178                         m_data[i][j] = k;
179                         if (8 == j) {
180                             if (Fill(i + 1, 0)) {
181                                 AddOneAnswer();
182                                 if (!m_does_try_all_answers) {
183                                     return true;
184                                 }
185                             }
186                         } else {
187                             if (Fill(i, j + 1)) {
188                                 AddOneAnswer();
189                                 if (!m_does_try_all_answers) {
190                                     return true;
191                                 }
192                             }
193                         }
194                     }
195                     m_data[i][j] = '.';
196                     return false;
197                 }
198             }
199         }
200 
201         AddOneAnswer();
202         return true;
203     }
204 
205 private:
206     bool m_does_try_all_answers;
207     std::vector<std::vector<char> > m_data;
208     std::set<std::string> m_all_answers;
209 };
210 
211 int main(int argc, char* argv[]) {
212     std::string question;
213     //with many answers
214     question = ".2..4836..5163887..63195..45.4.7.2.98..";
215 
216     //with just one answer: https://baike.baidu.com/item/%E4%B8%96%E7%95%8C%E6%9C%80%E9%9A%BE%E6%95%B0%E7%8B%AC/13848819
217     question = "..53..82..7..1.5..4.531..76..328..6.5.9..4.397..";
218 
219     bool find_all_answers = false;
220     if (argc > 1 && 81 == strlen(argv[1])) {
221         question = argv[1];
222     } else {
223         if (argc > 1) {
224             find_all_answers = true;
225         }
226         question = Sudoku::ProvideOneQuestionRandomly();
227     }
228 
229     Sudoku::PrintSudoku(question);
230 
231     Sudoku sudoku(question, find_all_answers);
232     sudoku.Solve();
233 
234     const std::set<std::string>& all_answers = sudoku.GiveAllAnswers();
235     int idx = 0;
236     for (typeof(all_answers.begin()) iter = all_answers.begin(); all_answers.end() != iter; ++iter) {
237         std::cout << "answer " << ++idx << " for this sudoku is:" << std::endl;
238         Sudoku::PrintSudoku(*iter);
239         if (!Sudoku::ValidateOneAnswer(*iter)) {
240             std::cout << "answer is not correct: " << *iter << std::endl;
241         }
242         std::cout << "[" << *iter << "]" << std::endl;
243     }
244     return 0;
245 }
246 

so true 2017-11-03 17:19 发表评论

#include <string>

#include <vector>

#include <map>

#include <set>

using namespace std;

//part 1

class A {

private:

    A() {};

public:

    static A* GetInstance() {

        return new A();

    }

};

//part 2

class A {

    friend class B;

private:

    A() {};

};

class B: public A {

};

//part 3

class A {

    friend class B;

private:

    A() {};

};

class B: virtual public A {

};

//part 4: 奇异递归模板模式（curiously recurring template pattern，CRTP）

template <typename T>

class A {

    friend T;

private:

    A() {};

};

class B: virtual public A<B> {

};

//part 4.2:

//这种技术获得了类似于虚函数的效果，并避免了动态多态的代价。也有人把CRTP称为“模拟的动态绑定”

template <typename T>

struct counter

{

    static int objects_created;

    static int objects_alive;

    counter()

    {

        ++objects_created;

        ++objects_alive;

    }

    

    counter(const counter&)

    {

        ++objects_created;

        ++objects_alive;

    }

protected:

    ~counter() // objects should never be removed through pointers of this type

    {

        --objects_alive;

    }

};

template <typename T> int counter<T>::objects_created( 0 );

template <typename T> int counter<T>::objects_alive( 0 );

class X : counter<X>

{

    ...

};

    

class Y : counter<Y>

{

     ...

};

//part 5

class A {

protected:

    A() {};

};

class B: virtual A {

};

//part 6

class B final {

};

//validate

class C: public B {

};

int main(int argc, char* argv[]) {

    B b;

    C c;

    return 0;

}

so true 2017-07-17 19:31 发表评论

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/epoll.h>

#include <errno.h>

#define MAXEVENTS 64

static int make_socket_non_blocking(int sfd) {

    int flags, s;

    flags = fcntl(sfd, F_GETFL, 0);

    if (flags == -1) {

        perror("fcntl");

        return -1;

    }

    flags |= O_NONBLOCK;

    s = fcntl(sfd, F_SETFL, flags);

    if (s == -1) {

        perror("fcntl");

        return -1;

    }

    return 0;

}

static int create_and_bind(char *port) {

    struct addrinfo hints;

    struct addrinfo *result, *rp;

    int s, sfd;

    memset(&hints, 0, sizeof(struct addrinfo));

    hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */

    hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */

    hints.ai_flags = AI_PASSIVE; /* All interfaces */

    s = getaddrinfo(NULL, port, &hints, &result);

    if (s != 0) {

        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));

        return -1;

    }

    for (rp = result; rp != NULL; rp = rp->ai_next) {

        sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

        if (sfd == -1)

            continue;

        s = bind(sfd, rp->ai_addr, rp->ai_addrlen);

        if (s == 0) {

            /* We managed to bind successfully! */

            break;

        }

        close(sfd);

    }

    if (rp == NULL) {

        fprintf(stderr, "Could not bind\n");

        return -1;

    }

    freeaddrinfo(result);

    return sfd;

}

int main(int argc, char *argv[]) {

    int sfd, s;

    int efd;

    struct epoll_event event;

    struct epoll_event *events;

    if (argc != 2) {

        fprintf(stderr, "Usage: %s [port]\n", argv[0]);

        exit(EXIT_FAILURE);

    }

    sfd = create_and_bind(argv[1]);

    if (sfd == -1)

        abort();

    s = make_socket_non_blocking(sfd);

    if (s == -1)

        abort();

    s = listen(sfd, SOMAXCONN);

    if (s == -1) {

        perror("listen");

        abort();

    }

    efd = epoll_create1(0);

    if (efd == -1) {

        perror("epoll_create");

        abort();

    }

    event.data.fd = sfd;

    event.events = EPOLLIN | EPOLLET;

    s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event);

    if (s == -1) {

        perror("epoll_ctl");

        abort();

    }

    /* Buffer where events are returned */

    events = calloc(MAXEVENTS, sizeof event);

    /* The event loop */

    while (1) {

        int n, i;

        n = epoll_wait(efd, events, MAXEVENTS, -1);

        for (i = 0; i < n; i++) {

            if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) {

                /* An error has occured on this fd, or the socket is not

                 ready for reading (why were we notified then?) */

                fprintf(stderr, "epoll error\n");

                close(events[i].data.fd);

                continue;

            }

            else if (sfd == events[i].data.fd) {

                /* We have a notification on the listening socket, which

                 means one or more incoming connections. */

                while (1) {

                    struct sockaddr in_addr;

                    socklen_t in_len;

                    int infd;

                    char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                    in_len = sizeof in_addr;

                    infd = accept(sfd, &in_addr, &in_len);

                    if (infd == -1) {

                        if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {

                            /* We have processed all incoming

                             connections. */

                            break;

                        } else {

                            perror("accept");

                            break;

                        }

                    }

                    s = getnameinfo(&in_addr, in_len, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICHOST | NI_NUMERICSERV);

                    if (s == 0) {

                        printf("Accepted connection on descriptor %d "

                            "(host=%s, port=%s)\n", infd, hbuf, sbuf);

                    }

                    /* Make the incoming socket non-blocking and add it to the

                     list of fds to monitor. */

                    s = make_socket_non_blocking(infd);

                    if (s == -1)

                        abort();

                    event.data.fd = infd;

                    event.events = EPOLLIN | EPOLLET;

                    s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event);

                    if (s == -1) {

                        perror("epoll_ctl");

                        abort();

                    }

                }

                continue;

            } else {

                /* We have data on the fd waiting to be read. Read and

                 display it. We must read whatever data is available

                 completely, as we are running in edge-triggered mode

                 and won't get a notification again for the same

                 data. */

                int done = 0;

                while (1) {

                    ssize_t count;

                    char buf[512];

                    count = read(events[i].data.fd, buf, sizeof buf);

                    if (count == -1) {

                        /* If errno == EAGAIN, that means we have read all

                         data. So go back to the main loop. */

                        if (errno != EAGAIN) {

                            perror("read");

                            done = 1;

                        }

                        break;

                    } else if (count == 0) {

                        /* End of file. The remote has closed the

                         connection. */

                        done = 1;

                        break;

                    }

                    /* Write the buffer to standard output */

                    s = write(1, buf, count);

                    if (s == -1) {

                        perror("write");

                        abort();

                    }

                }

                if (done) {

                    printf("Closed connection on descriptor %d\n", events[i].data.fd);

                    /* Closing the descriptor will make epoll remove it

                     from the set of descriptors which are monitored. */

                    close(events[i].data.fd);

                }

            }

        }

    }

    free(events);

    close(sfd);

    return EXIT_SUCCESS;

}

so true 2016-06-22 17:23 发表评论

1。简单点用signal（主要就1个api，signal(SIGINT, SignalHandler)和signal(SIGINT, SIG_IGN)就是全部了）；

2。复杂点用sigaction（可以设置在handling期间，允许/不允许哪些信号打断自己）；

3。当前线程handling过程中，当前线程不会因为相同signal再次进入handler，但当前线程可以被别的signal打断重新进入handler，别的线程可以进入handler；

例如下面这个例子，只有一个主线程，先被SIGINT打断进入handler，虽然又被SIGTERM打断再次进入handler：

#0  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#1  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#2  0x0000000000468300 in SignalHandler (sig=15) at src/dispatcher2_server.cpp:78

#3  <signal handler called>

#4  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#5  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#6  0x0000000000468300 in SignalHandler (sig=2) at src/dispatcher2_server.cpp:78

#7  <signal handler called>

#8  0x00007f7cc55dc200 in __nanosleep_nocancel () at ../sysdeps/unix/syscall-template.S:82

#9  0x00007f7cc55dc090 in __sleep (seconds=<value optimized out>) at ../sysdeps/unix/sysv/linux/sleep.c:138

#10 0x000000000046844a in main (argc=1, argv=0x7fff048454a8) at src/dispatcher2_server.cpp:102

demo：

static void SignalHandler(int sig) {

    if (SIGTERM == sig || SIGINT == sig) {

        struct sigaction sa;

        memset(&sa, 0, sizeof(sa));

        sa.sa_handler = SIG_IGN;

        sigaction(SIGINT, &sa, NULL); // keep other threads from entering this handler

        sigaction(SIGTERM, &sa, NULL); // keep other threads from entering this handler

        

        //...

    }

}

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = SignalHandler;

sigfillset(&sa.sa_mask); // block every signal during handling

sigaction(SIGINT, &sa, NULL);

sigaction(SIGTERM, &sa, NULL);

介绍：http://www.alexonlinux.com/signal-handling-in-linux
demo：http://aspyct.org/blog/2012/08/25/unix-signal-handling-example/

so true 2016-02-17 11:30 发表评论

so true 2015-12-10 21:15 发表评论

so true 2015-08-08 07:30 发表评论

so true 2015-07-03 11:57 发表评论

so true 2015-03-12 20:50 发表评论

so true 2015-03-10 10:52 发表评论

#include <iostream>
#include <typeinfo>
#include <stdio.h>

using namespace std;

enum EM {ONE, TWO};

void func(int i) {
    cout << __PRETTY_FUNCTION__ << endl;
}

void func(EM i) {
    cout << __PRETTY_FUNCTION__ << endl;
}

////////////////////////////////////////////////////

template <typename T>
void trait(T t) {
    cout << __PRETTY_FUNCTION__ << endl;
}

template <typename R, typename C, typename Arg1>
void trait_detail(R (C::*class_member_pointer)(Arg1)) {
    cout << __PRETTY_FUNCTION__ << endl;
}

////////////////////////////////////////////////////

class A {
public:
    virtual void func() {
        cout << __PRETTY_FUNCTION__ << endl;
    }

    virtual A& reflect() {
        cout << __PRETTY_FUNCTION__ << endl;
        return *this;
    }
};

A* func_provide_local_class(int x = 0) {
    class LocalA: public A {
    public:
        LocalA(int x): m_x(x) {};
        virtual void func() {
            cout << __PRETTY_FUNCTION__ << endl;
        }

        virtual A& reflect() {
            return *this;
        }

    private:
        int m_x;
    };

    A* pa = new LocalA(x);
    cout << typeid(pa).name() << endl;
    return pa;
}

////////////////////////////////////////////////////

class B {
public:
    virtual int func(double& d) = 0;
};


////////////////////////////////////////////////////

int main(int argc, char* argv[]) {
    //enum is also a specific type
    EM em = ONE;
    func(argc);
    func(em);
    trait(em);
    printf("--------------------------------------------\n");

    //trait in two ways
    trait(&B::func);
    trait_detail(&B::func);
    printf("--------------------------------------------\n");

    //trial for local class, for more information see as http://www.geeksforgeeks.org/local-class-in-c/ and http://www.cppblog.com/mzty/archive/2007/05/24/24766.html
    A* pa = func_provide_local_class();
    pa->func();
    printf("--------------------------------------------\n");

    //there's no way to use local class externally
    trait(pa);
    trait(pa->reflect());
    printf("--------------------------------------------\n");

    return 0;
}

void func(int)

void func(EM)

void trait(T) [with T = EM]

--------------------------------------------

void trait(T) [with T = int (B::*)(double&)]

void trait_detail(R (C::*)(Arg1)) [with R = int, C = B, Arg1 = double&]

--------------------------------------------

P1A

virtual void func_provide_local_class(int)::LocalA::func()

--------------------------------------------

void trait(T) [with T = A*]

void trait(T) [with T = A]

--------------------------------------------

so true 2015-03-06 17:51 发表评论

#include <stdlib.h>

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

#define INIT(x) x = (typeof(x))(long)(&x)

class Data {

public:

    virtual ~Data() {};

    Data() {

        INIT(b);

        INIT(d);

        INIT(p);

        INIT(c);

        INIT(l);

    }

    bool b;

    double d;

    int* p;

    char c;

    long l;

    bool operator==(const Data& another) const {

        return another.b == b &&

               another.d == d &&

               another.p == p &&

               another.c == c &&

               another.l == l;

    }

    bool operator!=(const Data& another) const {

        return !(*this == another);

    }

    void Print() const {

        printf("Data::b:%d\n", b);

        printf("Data::d:%f\n", d);

        printf("Data::p:%p\n", p);

        printf("Data::c:%c(%d)\n", c, (unsigned char)c);

        printf("Data::l:%ld\n", l);

    }

};

class Base {

public:

    Base() {

        INIT(p);

        INIT(c);

        i1 = c + random();

        i2 = c + random();

        INIT(d);

        u3 = c + random();

    }

    virtual ~Base() {};

    void* p;

    char c;

    int i1:1;

    int i2:2;

    double d;

    unsigned int u3:3;

    bool operator==(const Base& another) const {

        return another.p  == p  &&

               another.c  == c  &&

               another.i1 == i1 &&

               another.i2 == i2 &&

               another.d  == d  &&

               another.u3 == u3;

    }

    bool operator!=(const Base& another) const {

        return !(*this == another);

    }

    virtual void Print() const {

        printf("Base::p:%p\n", p);

        printf("Base::c:%c(%d)\n", c, (unsigned char)c);

        printf("Base::i1:%d\n", i1);

        printf("Base::i2:%d\n", i2);

        printf("Base::d:%f\n", d);

        printf("Base::u3:%u\n", u3);

    }

};

class Derive: public Base {

public:

    Derive() {

        INIT(i);

        INIT(c);

        u1 = i + random();

        u2 = i + random();

        u3 = i + random();

        u4 = i + random();

        INIT(b);

        INIT(ui);

        INIT(uf);

        INIT(d);

    }

    int i;

    char c;

    unsigned u1:10;

    unsigned u2:10;

    Data dt;

    unsigned u3:10;

    unsigned u4:2;

    bool b;

    union {

        int ui;

        float uf;

    };

    double d;

    virtual void Print() const {

        Base::Print();

        printf("Derive::i:%d\n", i);

        printf("Derive::c:%c(%d)\n", c, (unsigned char)c);

        printf("Derive::u1:%d\n", u1);

        printf("Derive::u2:%d\n", u2);

        dt.Print();

        printf("Derive::u3:%d\n", u3);

        printf("Derive::u4:%d\n", u4);

        printf("Derive::b:%d\n", b);

        printf("Derive::ui:%d\n", ui);

        printf("Derive::uf:%f\n", uf);

        printf("Derive::d:%f\n", d);

        printf("\n");

    }

    bool operator==(const Derive& another) const {

        return Base::operator ==(another) &&

               another.i  == i  &&

               another.c  == c  &&

               another.u1 == u1 &&

               another.u2 == u2 &&

               another.dt == dt &&

               another.u3 == u3 &&

               another.u4 == u4 &&

               another.b  == b  &&

               another.ui == ui &&

               another.uf == uf &&

               another.d  == d;

    }

    bool operator!=(const Derive& another) const {

        return !(*this == another);

    }

};

int main(int argc, char* argv[]) {

    printf("sizeof(Data):%lu\n", sizeof(Data));

    printf("sizeof(Base):%lu\n", sizeof(Base));

    printf("sizeof(Derive):%lu\n", sizeof(Derive));

    printf("\n");

    Derive drv;

    {

        string s((const char*)&drv, sizeof(Derive));

        const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

        if (*p == drv) {

            cout << "*EQUAL*" << endl;

            p->Print();

        }

    }

    drv.i = 1;

    drv.c = 'a';

    drv.u1 = 10;

    drv.u2 = 20;

    drv.u3 = 30;

    drv.u4 = 2;

    drv.b = true;

    drv.ui = 3;

    drv.uf = 3.5;

    drv.d = 8.8;

    {

        string s((const char*)&drv, sizeof(Derive));

        const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

        if (*p == drv) {

            cout << "*EQUAL*" << endl;

            p->Print();

        }

    }

    for (int i = 0; i < 10 * 1024; ++i) {

        Derive* pdrv = new Derive();

        {

            string s((const char*)pdrv, sizeof(Derive));

            const Derive* p = reinterpret_cast<const Derive*>(s.c_str());

            if (*p != *pdrv) {

                cout << "*NOT EQUAL*" << endl;

                pdrv->Print();

                p->Print();

                break;

            }

        }

        delete pdrv;

    }

    return 0;

}

==================     run result     ===================

so true 2015-03-04 15:34 发表评论

#include <iostream>

#include <string>

#include <fstream>

#include <sstream>

#include <stdint.h>

#include <pthread.h>

#include <vector>

#include <map>

#include <set>

using namespace std;

void fun() {

    cout << __PRETTY_FUNCTION__ << endl;

}

namespace {

    void fun(int i) {

        cout << __PRETTY_FUNCTION__ << endl;

        ::fun(); //use fun() will compile error

    }

}

class A {

public:

    void fun() {

        cout << __PRETTY_FUNCTION__ << endl;

    }

    void fun(int x) {

        cout << __PRETTY_FUNCTION__ << endl;

    }

};

class B: public A {

public:

    //using A::fun; //solution 3

    void fun(int x) {

        cout << __PRETTY_FUNCTION__ << endl;

    }

};

int main(int argc, char* argv[]) {

    B b;

    //b.fun();//compile error, name hiding occurs

    b.A::fun(); //solution 1

    A* pa = &b;

    pa->fun();  //solution 2

    fun(3);

    return 0;

}

===================   run result   ===================

so true 2015-03-03 14:34 发表评论

#include <iostream>

#include <stdlib.h>

#include <string>

#include <vector>

#include <map>

#include <math.h>

#include <set>

using namespace std;

class MatchPointFinder {

public:

    double GetDistanceBetweenTwoPoints(int x1, int y1, int x2, int y2, double alpha) const {

        return (abs(x1 - x2) + abs(y1 - y2)) * alpha;

        //return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);

        //two methods will *not* be equivalent under the following way of calculating distance, for the case in "main"

        //return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

    }

    double CalcSumDistance(int x, int y) {

        double dist = 0.0f;

        for (typeof(m_node_pos.begin()) it = m_node_pos.begin(), it4End = m_node_pos.end(); it4End != it; ++it) {

            dist += GetDistanceBetweenTwoPoints(it->first.first, it->first.second, x, y, it->second);

        }

        return dist;

    }

    MatchPointFinder(): m_width(0), m_height(0), m_match_point_x(0), m_match_point_y(0), m_total_weight(0), m_nodes(NULL) {

    }

    void ValidateEquivalenceOfTwoMethods(int trial_num = 1000) {

        for (int i = 0; i < trial_num; ++i) {

            int width = 5 + rand() % 100;

            int height = 5 + rand() % 100;

            Reset();

            RandomInit(width, height);

            if (!CompareTwoMethod()) {

                Try();

                break;

            } else {

                printf("two methods are equivalent under %d x %d array scale\n", height, width);

            }

        }

    }

    void Try() {

        FindMatchPointByEnumerating(m_match_point_x, m_match_point_y);

        printf("total weight is %f\n", m_total_weight);

        PrintMap(false);

        PrintMap();

        int old_mp_x = m_match_point_x;

        int old_mp_y = m_match_point_y;

        FindMatchPointByMedianMethod(m_match_point_x, m_match_point_y);

        PrintMap(false);

        if (old_mp_x == m_match_point_x && old_mp_y == m_match_point_y) {

            printf("two methods are equivalent under %d x %d array scale\n", m_height, m_width);

        } else {

            printf("two methods are *not* equivalent under %d x %d array scale\n", m_height, m_width);

        }

    }

    template <typename T>

    T abs(const T& t) const {

        return t > 0 ? t : -1 * t;

    }

    bool CompareTwoMethod() {

        FindMatchPointByEnumerating(m_match_point_x, m_match_point_y);

        int old_mp_x = m_match_point_x;

        int old_mp_y = m_match_point_y;

        FindMatchPointByMedianMethod(m_match_point_x, m_match_point_y);

        if (old_mp_x == m_match_point_x && old_mp_y == m_match_point_y) {

            return true;

        } else if (abs(m_node_dist[std::make_pair(old_mp_x, old_mp_y)] - m_node_dist[std::make_pair(m_match_point_x, m_match_point_y)]) < 0.000001) {

            return true;

        }

        return false;

    }

    ~MatchPointFinder() {

        Reset();

    }

    void RandomInit(int width = -1, int height = -1, bool init_random = true) {

        if (-1 != width) {

            m_width = width;

        }

        if (-1 != height) {

            m_height = height;

        }

        srand(time(NULL));

        m_nodes = new double*[m_height];

        memset(m_nodes, 0, sizeof(double*) * m_height);

        for (int i = 0; i < m_height; ++i) {

            if (!init_random) {

                m_nodes[i] = new double[m_width];

                memset(m_nodes[i], 0, sizeof(int) * m_width);

            } else {

                for (int j = 0; j < m_width; ++j) {

                    if (0 == j) {

                        m_nodes[i] = new double[m_width];

                        memset(m_nodes[i], 0, sizeof(int) * m_width);

                    }

                    m_nodes[i][j] = ((rand() % 10) >= 5 ? (double)(1 + rand() % 3) / 5 : 0);

                    if (m_nodes[i][j]) {

                        m_node_pos[std::make_pair(i, j)] = m_nodes[i][j];

                        m_total_weight += m_nodes[i][j];

                    }

                }

            }

        }

    }

    void AddNode(int x, int y) {

        m_nodes[x][y] = 1;

        m_node_pos[std::make_pair(x, y)] = 1;

        m_total_weight += 1;

    }

    void FindMatchPointByMedianMethod(int& mp_x, int& mp_y) {

        double collected_weight = 0;

        mp_x = -1;

        for (int i = 0; i < m_height; ++i) {

            for (int j = 0; j < m_width; ++j) {

                if (m_nodes[i][j] <= 0) {

                    continue;

                }

                collected_weight += m_nodes[i][j];

                if (collected_weight >= m_total_weight / 2) {

                    mp_x = i;

                    break;

                }

            }

            if (-1 != mp_x) {

                break;

            }

        }

        collected_weight = 0;

        mp_y = -1;

        for (int j = 0; j < m_width; ++j) {

            for (int i = 0; i < m_height; ++i) {

                if (m_nodes[i][j] <= 0) {

                    continue;

                }

                collected_weight += m_nodes[i][j];

                if (collected_weight >= m_total_weight / 2) {

                    mp_y = j;

                    break;

                }

            }

            if (-1 != mp_y) {

                break;

            }

        }

    }

    void FindMatchPointByEnumerating(int& mp_x, int& mp_y) {

        double shortest_sum_dist = std::numeric_limits<double>::max();

        for (int i = 0; i < m_height; ++i) {

            for (int j = 0; j < m_width; ++j) {

                double dist = CalcSumDistance(i, j);

                m_node_dist[std::make_pair(i, j)] = dist;

                if (dist < shortest_sum_dist) {

                    shortest_sum_dist = dist;

                    mp_x = i;

                    mp_y = j;

                }

            }

        }

    }

    void PrintMap(bool print_dist = true) {

        printf("%4s ", " ");

        for (int i = 0; i < m_width; ++i) {

            printf("      (%2d) ", i);

        }

        printf("\n");

        for (int i = 0; i < m_height; ++i) {

            printf("(%2d) ", i);

            for (int j = 0; j < m_width; ++j) {

                if (i == m_match_point_x && j == m_match_point_y) {

                    if (print_dist) {

                        printf("*%.1f[%2.1f] ", m_nodes[i][j], m_node_dist[std::make_pair(i, j)]);

                    } else {

                        printf("      *%.1f ", m_nodes[i][j]);

                    }

                } else {

                    if (print_dist) {

                        printf("%.1f[%2.1f] ", m_nodes[i][j], m_node_dist[std::make_pair(i, j)]);

                    } else {

                        printf("      %.1f ", m_nodes[i][j]);

                    }

                }

            }

            printf("\n");

        }

        printf("\n");

    }

    void Reset() {

        if (m_nodes) {

            for (int i = 0; i < m_height; ++i) {

                delete [] m_nodes[i];

            }

            delete [] m_nodes;

        }

        m_nodes = NULL;

        m_width = 0;

        m_height = 0;

        m_match_point_x = 0;

        m_match_point_y = 0;

        m_total_weight = 0;

        m_node_pos.clear();

        m_node_dist.clear();

    }

private:

    int m_width;

    int m_height;

    int m_match_point_x;

    int m_match_point_y;

    double m_total_weight;

    double** m_nodes;

    std::map<std::pair<int, int>, double> m_node_pos;

    std::map<std::pair<int, int>, double> m_node_dist;

};

int main(int argc, char* argv[]) {

    int width = 5;

    int height = 5;

    if (argc > 1) {

        height = atoi(argv[1]);

    }

    if (argc > 2) {

        width = atoi(argv[2]);

    }

    MatchPointFinder mpf;

    //mpf.RandomInit(width, height);

    //mpf.Try();

    //return 0;

    mpf.ValidateEquivalenceOfTwoMethods(1000);

    return 0;

    /*

                           ( 0)       ( 1)       ( 2)       ( 3)       ( 4)

                ( 0)          1          1          0          0          1

                ( 1)          1          0          0          1          0

                ( 2)          1          1          0          1          0

                ( 3)          0          0       *  1          1          0

                ( 4)          1          1          1          1          1

    */

    mpf.Reset();

    mpf.RandomInit(5, 5, false);

    mpf.AddNode(0, 0);

    mpf.AddNode(0, 1);

    mpf.AddNode(0, 4);

    mpf.AddNode(1, 0);

    mpf.AddNode(1, 3);

    mpf.AddNode(2, 0);

    mpf.AddNode(2, 1);

    mpf.AddNode(2, 3);

    mpf.AddNode(3, 2);

    mpf.AddNode(3, 3);

    mpf.AddNode(4, 0);

    mpf.AddNode(4, 1);

    mpf.AddNode(4, 2);

    mpf.AddNode(4, 3);

    mpf.AddNode(4, 4);

    mpf.Try();

    return 0;

}

so true 2015-02-07 20:34 发表评论

so true 2015-02-01 12:44 发表评论

http://valgrind.org/docs/manual/ms-manual.html

http://manyhappy163.blog.163.com/blog/static/16447683120105174149969/

http://hi.baidu.com/algorithms/item/77e5c6bfed350d77244b097f

经过调查，结论是：

1。map不能使用swap的方式来强制释放内存；

2。map用的allocator，新版gcc用new_allocator，不存在pool的问题；

3。根本原因是free函数（libc内部实现），并没有把你内存真正的释放，这个与free的内部实现机制有关了。

下面是一个小的测试程序

$ cat test_mem_seg.cpp 

#include <vector>

#include <malloc.h>

#include <stdio.h>

#include <iostream>

#include <stdlib.h>

int main(int argc, char* argv[]) {

    std::vector<void*> v;

    int block_len = 120;

    if (argc > 1) {

        block_len = atoi(argv[1]);

    }

    for (int i = 0; i < 1024 * 1024; ++i) {

        char* p = (char*)malloc(block_len);

        sprintf(p, "%d", i);

        v.push_back(p);

    }

    std::cout << "\n===============malloc (block unit size:" << block_len << ") ok==============\n";

    malloc_stats();

    for (int i = 0; i < 1024 * 1024; ++i) {

        free(v[i]);

    }

    std::cout << "\n===============free  (block unit size:" << block_len << ") ok==============\n";

    malloc_stats();

}

so true 2014-09-18 14:26 发表评论

epoll使用总结                                  http://laokaddk.blog.51cto.com/368606/617497

epoll学习：思考一种高性能的服务器处理框架           http://laokaddk.blog.51cto.com/368606/607231

epoll学习笔记                                  http://laokaddk.blog.51cto.com/368606/607017

简单学习了一下epoll，之前也用过，这次又看了看，收获如下：

两种实现模式（在http://laokaddk.blog.51cto.com/368606/791945中都有提到）：同一个线程 和 不同线程；

顺便了解了一下惊群现象，如果用accept阻塞的方式就不存在惊群现象了，在不同线程中通过epoll_wait来出发accept行为的nginx的解决方法是通过进程里原子的修改寄存器a来做到进程间互斥的。

在不同线程模式下：listenfd需设置为非阻塞，注册EPOLLIN就可以了，触发时调用accept，有没有连接都会立刻返回；

在同一个线程模式下：listenfd为阻塞模式，不注册epoll，阻塞while调用accept即可；

ET触发只支持非阻塞模式，这里针对的fd是accept接收到的然后epoll_add了的那些fds，原因是：因为ET触发需要处理函数一直处理完所有in/out数据，比如read数据，如果read到的字节数小于预先准备读入的字节数，那么就可以认为读完了；如果是非阻塞模式，那么read会一直阻塞在那里。

epollfd不需要设置阻塞、非阻塞。

一般都用LT触发，不论哪种实现模式，EPOLLIN和EPOLLOUT都不同时设定，都是不断切换来做的。

客户端close掉socket时，会唤醒服务端epoll_wait;

对于epoll_wait而言，针对一个fd只存在唤醒与被唤醒，至于是EPOLLIN还是EPOLLOUT，取决于你当初epoll_add时的设定，因此如果你epoll_add时设定了EPOLLIN|EPOLLOUT，那么当EPOLLIN发生时（内核里当然是可以区分EPOLLIN和EPOLLOUT的），你收到的fd上的事件依然是EPOLLIN|EPOLLOUT。

so true 2013-07-04 17:36 发表评论

(gdb) start

(gdb) break open

(gdb) condition 2 strcmp (((char**)$esp)[1], "bar") == 0
上面((char**)$esp)[1]用于取第一个参数，gdb的strcmp或许会不好用（可以用p strcmp("hello", "hello")测试一下），如果不好用，可以自己写一个：
int mystrcmp(const char* p1, const char* p2) {
    return strcmp(p1, p2);
}
5. 通过断点来打印bt信息：
define mybt
    set logging file t3.log
    set logging on

    break $arg0
    while 1
        continue
        bt
    end
    set logging off
end

6. 经过不懈的努力，终于得到了一种可行的方法：
$ cat t3.gdb

so true 2012-12-21 17:19 发表评论

* This piece of code has been inspirated from nginx and pureftpd code, whic

* are under BSD licence.

*

* To change the process title in Linux we have to set argv[1] to NULL

* and to copy the title to the same place where the argv[0] points to.

* However, argv[0] may be too small to hold a new title.  Fortunately, Linux

* store argv[] and environ[] one after another.  So we should ensure that is

* the continuous memory and then we allocate the new memory for environ[]

* and copy it.  After this we could use the memory starting from argv[0] for

* our process title.

*/

for (i = 0; i < fpm_globals.argc; i++) {

if (first == NULL) {

first = fpm_globals.argv[i];

}

if (last == NULL || fpm_globals.argv[i] == last + 1) {

last = fpm_globals.argv[i] + strlen(fpm_globals.argv[i]);

}

}

if (environ) {

for (i = 0; environ[i]; i++) {

if (first == NULL) {

first = environ[i];

}

if (last == NULL || environ[i] == last + 1) {

last = environ[i] + strlen(environ[i]);

}

}

}

if (first == NULL || last == NULL) {

return 0;

}

fpm_env_argv_len = last - first;

fpm_env_argv = fpm_globals.argv;

if (environ != NULL) {

char **new_environ;

unsigned int env_nb = 0U;

while (environ[env_nb]) {

env_nb++;

}

if ((new_environ = malloc((1U + env_nb) * sizeof (char *))) == NULL) {

return -1;

}

new_environ[env_nb] = NULL;

while (env_nb > 0U) {

env_nb--;

new_environ[env_nb] = strdup(environ[env_nb]);

}

environ = new_environ;

}

#endif

#endif

spprintf(&title, 0, "master process (%s)", fpm_globals.config);

fpm_env_setproctitle(title); 

efree(title);

so true 2012-12-21 15:18 发表评论

#   STL GDB evaluators/views/utilities - 1.03

#

#   The new GDB commands:                                                         

#    are entirely non instrumental                                             

#    do not depend on any "inline"(s) - e.g. size(), [], etc

#       are extremely tolerant to debugger settings

#                                                                                 

#   This file should be "included" in .gdbinit as following:

#   source stl-views.gdb or just paste it into your .gdbinit file

#

#   The following STL containers are currently supported:

#

#       std::vector<T> -- via pvector command

#       std::list<T> -- via plist or plist_member command

#       std::map<T,T> -- via pmap or pmap_member command

#       std::multimap<T,T> -- via pmap or pmap_member command

#       std::set<T> -- via pset command

#       std::multiset<T> -- via pset command

#       std::deque<T> -- via pdequeue command

#       std::stack<T> -- via pstack command

#       std::queue<T> -- via pqueue command

#       std::priority_queue<T> -- via ppqueue command

#       std::bitset<n> -- via pbitset command

#       std::string -- via pstring command

#       std::widestring -- via pwstring command

#

#   The end of this file contains (optional) C++ beautifiers

#   Make sure your debugger supports $argc

#

#   Simple GDB Macros writen by Dan Marinescu (H-PhD) - License GPL

#   Inspired by intial work of Tom Malnar, 

#     Tony Novac (PhD) / Cornell / Stanford,

#     Gilad Mishne (PhD) and Many Many Others.

#   Contact: dan_c_marinescu@yahoo.com (Subject: STL)

#

#   Modified to work with g++ 4.3 by Anders Elton

#   Also added _member functions, that instead of printing the entire class in map, prints a member.

#

# std::vector<>

#

define pvector

if $argc == 0

help pvector

else

set $size = $arg0._M_impl._M_finish - $arg0._M_impl._M_start

set $capacity = $arg0._M_impl._M_end_of_storage - $arg0._M_impl._M_start

set $size_max = $size - 1

end

if $argc == 1

set $i = 0

while $i < $size

printf "elem[%u]: ", $i

p *($arg0._M_impl._M_start + $i)

set $i++

end

end

if $argc == 2

set $idx = $arg1

if $idx < 0 || $idx > $size_max

printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max

else

printf "elem[%u]: ", $idx

p *($arg0._M_impl._M_start + $idx)

end

end

if $argc == 3

 set $start_idx = $arg1

 set $stop_idx = $arg2

 if $start_idx > $stop_idx

   set $tmp_idx = $start_idx

   set $start_idx = $stop_idx

   set $stop_idx = $tmp_idx

 end

 if $start_idx < 0 || $stop_idx < 0 || $start_idx > $size_max || $stop_idx > $size_max

   printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max

 else

   set $i = $start_idx

while $i <= $stop_idx

printf "elem[%u]: ", $i

p *($arg0._M_impl._M_start + $i)

set $i++

end

 end

end

if $argc > 0

printf "Vector size = %u\n", $size

printf "Vector capacity = %u\n", $capacity

printf "Element "

whatis $arg0._M_impl._M_start

end

end

document pvector

Prints std::vector<T> information.

Syntax: pvector <vector> <idx1> <idx2>

Note: idx, idx1 and idx2 must be in acceptable range [0..<vector>.size()-1].

Examples:

pvector v - Prints vector content, size, capacity and T typedef

pvector v 0 - Prints element[idx] from vector

pvector v 1 2 - Prints elements in range [idx1..idx2] from vector

end 

#

# std::list<>

#

define plist

if $argc == 0

help plist

else

set $head = &$arg0._M_impl._M_node

set $current = $arg0._M_impl._M_node._M_next

set $size = 0

while $current != $head

if $argc == 2

printf "elem[%u]: ", $size

p *($arg1*)($current + 1)

end

if $argc == 3

if $size == $arg2

printf "elem[%u]: ", $size

p *($arg1*)($current + 1)

end

end

set $current = $current._M_next

set $size++

end

printf "List size = %u \n", $size

if $argc == 1

printf "List "

whatis $arg0

printf "Use plist <variable_name> <element_type> to see the elements in the list.\n"

end

end

end

document plist

Prints std::list<T> information.

Syntax: plist <list> <T> <idx>: Prints list size, if T defined all elements or just element at idx

Examples:

plist l - prints list size and definition

plist l int - prints all elements and list size

plist l int 2 - prints the third element in the list (if exists) and list size

end

define plist_member

if $argc == 0

help plist_member

else

set $head = &$arg0._M_impl._M_node

set $current = $arg0._M_impl._M_node._M_next

set $size = 0

while $current != $head

if $argc == 3

printf "elem[%u]: ", $size

p (*($arg1*)($current + 1)).$arg2

end

if $argc == 4

if $size == $arg3

printf "elem[%u]: ", $size

p (*($arg1*)($current + 1)).$arg2

end

end

set $current = $current._M_next

set $size++

end

printf "List size = %u \n", $size

if $argc == 1

printf "List "

whatis $arg0

printf "Use plist_member <variable_name> <element_type> <member> to see the elements in the list.\n"

end

end

end

document plist_member

Prints std::list<T> information.

Syntax: plist <list> <T> <idx>: Prints list size, if T defined all elements or just element at idx

Examples:

plist_member l int member - prints all elements and list size

plist_member l int member 2 - prints the third element in the list (if exists) and list size

end

#

# std::map and std::multimap

#

define pmap

if $argc == 0

help pmap

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Map "

whatis $tree

printf "Use pmap <variable_name> <left_element_type> <right_element_type> to see the elements in the map.\n"

end

if $argc == 3

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u].left: ", $i

p *($arg1*)$value

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p *($arg2*)$value

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

end

if $argc == 4

set $idx = $arg3

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u].left: ", $i

p *($arg1*)$value

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p *($arg2*)$value

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

if $argc == 5

set $idx1 = $arg3

set $idx2 = $arg4

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

set $valueLeft = *($arg1*)$value

set $valueRight = *($arg2*)($value + sizeof($arg1))

if $valueLeft == $idx1 && $valueRight == $idx2

printf "elem[%u].left: ", $i

p $valueLeft

printf "elem[%u].right: ", $i

p $valueRight

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Map size = %u\n", $tree_size

end

end

document pmap

Prints std::map<TLeft and TRight> or std::multimap<TLeft and TRight> information. Works for std::multimap as well.

Syntax: pmap <map> <TtypeLeft> <TypeRight> <valLeft> <valRight>: Prints map size, if T defined all elements or just element(s) with val(s)

Examples:

pmap m - prints map size and definition

pmap m int int - prints all elements and map size

pmap m int int 20 - prints the element(s) with left-value = 20 (if any) and map size

pmap m int int 20 200 - prints the element(s) with left-value = 20 and right-value = 200 (if any) and map size

end

define pmap_member

if $argc == 0

help pmap_member

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Map "

whatis $tree

printf "Use pmap <variable_name> <left_element_type> <right_element_type> to see the elements in the map.\n"

end

if $argc == 5

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u].left: ", $i

p (*($arg1*)$value).$arg2

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p (*($arg3*)$value).$arg4

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

end

if $argc == 6

set $idx = $arg5

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u].left: ", $i

p (*($arg1*)$value).$arg2

set $value = $value + sizeof($arg1)

printf "elem[%u].right: ", $i

p (*($arg3*)$value).$arg4

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Map size = %u\n", $tree_size

end

end

document pmap_member

Prints std::map<TLeft and TRight> or std::multimap<TLeft and TRight> information. Works for std::multimap as well.

Syntax: pmap <map> <TtypeLeft> <TypeRight> <valLeft> <valRight>: Prints map size, if T defined all elements or just element(s) with val(s)

Examples:

pmap_member m class1 member1 class2 member2 - prints class1.member1 : class2.member2

pmap_member m class1 member1 class2 member2 lvalue - prints class1.member1 : class2.member2 where class1 == lvalue

end

#

# std::set and std::multiset

#

define pset

if $argc == 0

help pset

else

set $tree = $arg0

set $i = 0

set $node = $tree._M_t._M_impl._M_header._M_left

set $end = $tree._M_t._M_impl._M_header

set $tree_size = $tree._M_t._M_impl._M_node_count

if $argc == 1

printf "Set "

whatis $tree

printf "Use pset <variable_name> <element_type> to see the elements in the set.\n"

end

if $argc == 2

while $i < $tree_size

set $value = (void *)($node + 1)

printf "elem[%u]: ", $i

p *($arg1*)$value

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

end

if $argc == 3

set $idx = $arg2

set $ElementsFound = 0

while $i < $tree_size

set $value = (void *)($node + 1)

if *($arg1*)$value == $idx

printf "elem[%u]: ", $i

p *($arg1*)$value

set $ElementsFound++

end

if $node._M_right != 0

set $node = $node._M_right

while $node._M_left != 0

set $node = $node._M_left

end

else

set $tmp_node = $node._M_parent

while $node == $tmp_node._M_right

set $node = $tmp_node

set $tmp_node = $tmp_node._M_parent

end

if $node._M_right != $tmp_node

set $node = $tmp_node

end

end

set $i++

end

printf "Number of elements found = %u\n", $ElementsFound

end

printf "Set size = %u\n", $tree_size

end

end

document pset

Prints std::set<T> or std::multiset<T> information. Works for std::multiset as well.

Syntax: pset <set> <T> <val>: Prints set size, if T defined all elements or just element(s) having val

Examples:

pset s - prints set size and definition

pset s int - prints all elements and the size of s

pset s int 20 - prints the element(s) with value = 20 (if any) and the size of s

end

#

# std::dequeue

#

define pdequeue

if $argc == 0

help pdequeue

else

set $size = 0

set $start_cur = $arg0._M_impl._M_start._M_cur

set $start_last = $arg0._M_impl._M_start._M_last

set $start_stop = $start_last

while $start_cur != $start_stop

p *$start_cur

set $start_cur++

set $size++

end

set $finish_first = $arg0._M_impl._M_finish._M_first

set $finish_cur = $arg0._M_impl._M_finish._M_cur

set $finish_last = $arg0._M_impl._M_finish._M_last

if $finish_cur < $finish_last

set $finish_stop = $finish_cur

else

set $finish_stop = $finish_last

end

while $finish_first != $finish_stop

p *$finish_first

set $finish_first++

set $size++

end

printf "Dequeue size = %u\n", $size

end

end

document pdequeue

Prints std::dequeue<T> information.

Syntax: pdequeue <dequeue>: Prints dequeue size, if T defined all elements

Deque elements are listed "left to right" (left-most stands for front and right-most stands for back)

Example:

pdequeue d - prints all elements and size of d

end

#

# std::stack

#

define pstack

if $argc == 0

help pstack

else

set $start_cur = $arg0.c._M_impl._M_start._M_cur

set $finish_cur = $arg0.c._M_impl._M_finish._M_cur

set $size = $finish_cur - $start_cur

        set $i = $size - 1

        while $i >= 0

            p *($start_cur + $i)

            set $i--

        end

printf "Stack size = %u\n", $size

end

end

document pstack

Prints std::stack<T> information.

Syntax: pstack <stack>: Prints all elements and size of the stack

Stack elements are listed "top to buttom" (top-most element is the first to come on pop)

Example:

pstack s - prints all elements and the size of s

end

#

# std::queue

#

define pqueue

if $argc == 0

help pqueue

else

set $start_cur = $arg0.c._M_impl._M_start._M_cur

set $finish_cur = $arg0.c._M_impl._M_finish._M_cur

set $size = $finish_cur - $start_cur

        set $i = 0

        while $i < $size

            p *($start_cur + $i)

            set $i++

        end

printf "Queue size = %u\n", $size

end

end

document pqueue

Prints std::queue<T> information.

Syntax: pqueue <queue>: Prints all elements and the size of the queue

Queue elements are listed "top to bottom" (top-most element is the first to come on pop)

Example:

pqueue q - prints all elements and the size of q

end

#

# std::priority_queue

#

define ppqueue

if $argc == 0

help ppqueue

else

set $size = $arg0.c._M_impl._M_finish - $arg0.c._M_impl._M_start

set $capacity = $arg0.c._M_impl._M_end_of_storage - $arg0.c._M_impl._M_start

set $i = $size - 1

while $i >= 0

p *($arg0.c._M_impl._M_start + $i)

set $i--

end

printf "Priority queue size = %u\n", $size

printf "Priority queue capacity = %u\n", $capacity

end

end

document ppqueue

Prints std::priority_queue<T> information.

Syntax: ppqueue <priority_queue>: Prints all elements, size and capacity of the priority_queue

Priority_queue elements are listed "top to buttom" (top-most element is the first to come on pop)

Example:

ppqueue pq - prints all elements, size and capacity of pq

end

#

# std::bitset

#

define pbitset

if $argc == 0

help pbitset

else

        p /t $arg0._M_w

end

end

document pbitset

Prints std::bitset<n> information.

Syntax: pbitset <bitset>: Prints all bits in bitset

Example:

pbitset b - prints all bits in b

end

#

# std::string

#

define pstring

if $argc == 0

help pstring

else

printf "String \t\t\t= \"%s\"\n", $arg0._M_dataplus._M_p

printf "String size/length \t= %u\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_length

printf "String capacity \t= %u\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_capacity

printf "String ref-count \t= %d\n", (((std::string::_Rep*) ($arg0._M_dataplus._M_p))[-1])._M_refcount

#printf "String \t\t\t= \"%s\"\n", $arg0._M_data()

#printf "String size/length \t= %u\n", $arg0._M_rep()._M_length

#printf "String capacity \t= %u\n", $arg0._M_rep()._M_capacity

#printf "String ref-count \t= %d\n", $arg0._M_rep()._M_refcount

end

end

document pstring

Prints std::string information.

Syntax: pstring <string>

Example:

pstring s - Prints content, size/length, capacity and ref-count of string s

end 

#

# std::wstring

#

define pwstring

if $argc == 0

help pwstring

else

call printf("WString \t\t= \"%ls\"\n", $arg0._M_data())

printf "WString size/length \t= %u\n", $arg0._M_rep()._M_length

printf "WString capacity \t= %u\n", $arg0._M_rep()._M_capacity

printf "WString ref-count \t= %d\n", $arg0._M_rep()._M_refcount

end

end

document pwstring

Prints std::wstring information.

Syntax: pwstring <wstring>

Example:

pwstring s - Prints content, size/length, capacity and ref-count of wstring s

end 

#

# C++ related beautifiers (optional)

#

set print pretty on

set print object on

set print static-members on

set print vtbl on

set print demangle on

set demangle-style gnu-v3

set print sevenbit-strings off

so true 2012-11-07 17:51 发表评论

http://www.jellythink.com/archives/705

http://www.jellythink.com/archives/705

so true 2012-06-11 15:35 发表评论

so true 2012-06-07 11:55 发表评论

so true 2012-04-26 14:38 发表评论

so true 2011-11-26 14:10 发表评论

so true 2011-04-24 12:52 发表评论