std::sort引发的core

    1. #include <stdio.h>
    2. #include <vector>
    3. #include <algorithm>
    4. #include <new>
    5. struct foo_t
    6. {
    7. int size;
    8. };
    9. class cmp_t
    10. {
    11. public:
    12. bool operator()(foo_t *a, foo_t *b)
    13. {
    14. return a->size >= b->size;
    15. }
    16. };
    17. int main(int argc, char *argv[])
    18. {
    19. std::vector<foo_t *> vec;
    20. for (int i = 0; i < 17; i++)
    21. {
    22. foo_t *x = new(std::nothrow) foo_t();
    23. if (NULL == x)
    24. {
    25. goto fail;
    26. }
    27. else
    28. {
    29. x->size = 1;
    30. }
    31. vec.push_back(x);
    32. }
    33. std::sort(vec.begin(), vec.end(), cmp_t());
    34. fail:
    35. for(std::vector<foo_t *>::iterator iter = vec.begin(); vec.end() != iter; ++iter)
    36. {
    37. delete *iter;
    38. *iter = NULL;
    39. }
    40. return 0;
    41. }
    42. 然后编译

      1. g++ main.cpp -Werror -Wall -g

      然后执行，此时系统出core，错误类型为段错误
      如果无core文件产生，可以使用

      1. ulimit -c unlimited

      后重新执行一次，此时就会有core文件生成
      然后

      1. gdb a.out core
      2. (gdb) bt
      3. #0  0x0804889e in cmp_t::operator() (this=0xbfed92d0, a=0x0, b=0x9a9d0c8) at main.cpp:16
        #1 
        0x080497ff in
        std::__unguarded_partition<__gnu_cxx::__normal_iterator<foo_t**,
        std::vector<foo_t*, std::allocator<foo_t*> > >, foo_t*,
        cmp_t> (__first=..., __last=..., [email protected], __comp=...) at
        /usr/include/c++/4.6/bits/stl_algo.h:2233
        #2  0x0804926a in
        std::__unguarded_partition_pivot<__gnu_cxx::__normal_iterator<foo_t**,
        std::vector<foo_t*, std::allocator<foo_t*> > >,
        cmp_t> (__first=..., __last=..., __comp=...) at
        /usr/include/c++/4.6/bits/stl_algo.h:2265
        #3  0x08048e84 in
        std::__introsort_loop<__gnu_cxx::__normal_iterator<foo_t**,
        std::vector<foo_t*, std::allocator<foo_t*> > >, int,
        cmp_t> (
            __first=..., __last=..., __depth_limit=7, __comp=...) at /usr/include/c++/4.6/bits/stl_algo.h:2306
        #4 
        0x08048a22 in std::sort<__gnu_cxx::__normal_iterator<foo_t**,
        std::vector<foo_t*, std::allocator<foo_t*> > >, cmp_t>
        (__first=...,
            __last=..., __comp=...) at /usr/include/c++/4.6/bits/stl_algo.h:5368
        #5  0x080487ce in main (argc=1, argv=0xbfed9464) at main.cpp:38

      可以看到，系统core在了排序函数里面。
      然后通过分析stl代码发现以下一段代码

      1. /// This is a helper function...
      2. template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
      3. _RandomAccessIterator
      4. __unguarded_partition(_RandomAccessIterator __first,
      5. _RandomAccessIterator __last,
      6. const _Tp& __pivot, _Compare __comp)
      7. {
      8. while (true)
      9. {
      10. while (__comp(*__first, __pivot))
      11. ++__first;
      12. --__last;
      13. while (__comp(__pivot, *__last))
      14. --__last;
      15. if (!(__first < __last))
      16. return __first;
      17. std::iter_swap(__first, __last);
      18. ++__first;
      19. }
      20. }

      此函数完成快速排序中分区功能，即将比哨兵小的数据放在其前，大的放在其后。
      函数中使用的是
      while (__comp(*__first, __pivot))
          ++__first;

      如果当比较元素相同返回真时，此时比较元素将会继续向下遍历，在极端情况下，例如程序中所有元素都是一样的情况下，在这种情况下，就会出现访问越界，结果就是导致程序出现segment fault

      所以在写c++ stl中的比较函数是，bool返回真的时候，一定是“真的”大，或者小，等于的时候只能返回false。

时间： 2024-10-28 13:57:26

std::sort引发的core的相关文章

GDB实践：一场std::sort引发的coredump

以前只掌握gdb一些基础知识,还没有真正"实战"过.刚好最近同事一个进程coredump了,原因比较深,正好利用这个机会来分析下 // @ 运行:gdb [可执行程序] -c [coredump文件] gdb edu_info_recommend_svr -c core_edu_info_recomm // @ 查看堆栈信息:bt (backtrace) (gdb) bt 10 #0 0x00007fa0809b6144 in __strcmp_sse42 () from /lib64

std::sort 学习：一种递归分治方法

// std::sort 学习:一种递归分治方法 今天看了看 stl 的 std::sort 的代码,众所周知,这个函数是在快速排序递归太深的时候使用堆排序防止过度退化,但是今天说的不是这个.我们只看快速排序的部分. 我们一般实现快速排序大概是这样的(本王随意写了个用下标当参数的排序函数,领会意思即可). void quick_sort(int first, int last) // 某个数组的 [first, last) {  if ((last - first) > 1) {  int mi

源码阅读笔记 - 1 MSVC2015中的std::sort

大约寒假开始的时候我就已经把std::sort的源码阅读完毕并理解其中的做法了,到了寒假结尾,姑且把它写出来 这是我的第一篇源码阅读笔记,以后会发更多的,包括算法和库实现,源码会按照我自己的代码风格格式化,去掉或者展开用于条件编译或者debug检查的宏,依重要程度重新排序函数,但是不会改变命名方式(虽然MSVC的STL命名实在是我不能接受的那种),对于代码块的解释会在代码块前(上面)用注释标明. template<class _RanIt, class _Diff, class _Pr> in

std::sort要求strict weak ordering

strict weak ordering简单地说就是小于语义,非小于等于语义,也就是说对于相等的或者异常的元素比较应当返回false 后果很严重,在google搜一下violating strict weak ordering make std::sort crash能看到很多种后果, 经测试,当待排序元素大于16个时使用std::sort,若传入的callable违反strict weak ordering,则可能死循环也可能越界访问. 待排序元素小于等于16个不会有问题是因为std::sor

测试std::sort 和std::qsort 的性能， 修改编译器栈大小

根据effective STL中Item 46 提到, C程序员很难接受C++的STL中std::sort(定义于头文件<algorithm>)竟然比C语言的std::qsort(定义与头文件<cstdlib>中)快了670%. 最后Scot Meyer建议我们我们要使用C++的std::sort函数. 我们知道qsort 实现的排序算法是快排, 但是std::sort 实现的排序算法并不知道, 有人说这得看是哪一个STL版本了. std::sort的大部分实现的是quick so

[C/C++标准库]_[初级]_[使用std::sort排序各种类型数据]

std::sort 场景: 1. 在使用sort排序时,有时候需要对对象的某个值进行排序,比如对类对象的某个id的int类型值或者bool类型值,其实bool类型值排序研究了半天.. test_sort.cpp #include <stdlib.h> #include <string.h> #include <string> #include <vector> #include <algorithm> #include <iostream&

非常无聊——STD::sort VS 基数排序

众所周知,Std::sort()是一个非常快速的排序算法,它基于快排,但又有所修改.一般来说用它就挺快的了,代码一行,时间复杂度O(nlogn)(难道不是大叫一声"老子要排序!!"就排好了么...).我们也知道,不基于比较的排序可以达到O(n),比如说基数排序.什么,它是O(n * log(10)( max(n) ) ) 的?NO!!我们可以用sqrt(max(n))来作为进制,这样就是(N*logMax(n))=O(2*n)的了..看起来很不错, 代码量嘛....呵呵 所谓基数排序,

将三维空间的点按照座标排序（兼谈为std::sort写compare function的注意事项）

最近碰到这样一个问题:我们从文件里读入了一组三维空间的点,其中有些点的X,Y,Z座标只存在微小的差别,远小于我们后续数据处理的精度,可以认为它们是重复的.所以我们要把这些重复的点去掉.因为数据量不大,这里不准备使用划分包围盒或者建立k-d tree这样的重型武器,我们简单的把点按照其三维坐标进行排序就好. 我们准备使用STL的std::sort来做这个排序.它要求提供一个符合如下签名的比较函数: bool cmp(const Type1 &a, const Type2 &b) 怎么样写这个

std::sort()

原文地址:http://blog.csdn.net/factor2000/article/details/3936195 1 #include "stdafx.h" 2 #include <vector> 3 #include <algorithm> 4 #include <functional> 5 #include <iostream> 6 7 using namespace std; 8 9 //Return whether fir