STL 重载比较操作符 随机比较问题
问题描述
C++ struct 重载比较操作符 可以实现按照重载函数的规则排序；
如果 重载比较操作符 时，不是按照确定的大小顺序，而是一种随机的大小问题，会出现访问越界的问题？
问题复现
在写代码的过程中，出现了上述的问题，简化后的代码如下，可以在多次运行中出现core
#include<bits/stdc++.h>
using namespace std;
struct Item {
string info_;
string info2_;
string info3_;
bool bool1_;
int64_t id_;
bool bool2_;
Item(const string& info,
const string& info2,
const string& info3,
const bool boo1,
const int64_t id)
:info_(info),
info2_(info2),
info3_(info3),
bool1_(boo1),
id_(id) {
auto pos = info3_.find(info_);
if (pos == string::npos) {
bool1_ = false;
bool2_ = false;
} else if (pos == 0) {
bool2_ = true;
} else {
bool2_ = false;
}
}
bool operator < (const Item& a) {
return (rand() % 10) > 4;
}
};
struct Items {
map<string, vector<Item>>* lists_;
Items() {
lists_ = new map<string, vector<Item>>;
}
void AddItem(const string& info_,
const string& info2_,
const string& info3,
const bool boo1,
const int64_t id) {
Item item(info_, info2_, info3, boo1, id);
auto iter = lists_->find(info2_);
if (iter == lists_->end()) {
vector<Item> s;
(*lists_)[info2_] = s;
}
auto topo = &(*lists_)[info2_];
topo->emplace_back(item);
}
void Sort() {
for (auto iter = lists_->begin(); iter != lists_->end(); iter++) {
vector<Item>* s = &iter->second;
std::sort(s->begin(), s->end());
}
}
};
int main(int argc, char** argv) {
Items* a = new Items();
a->AddItem("1.com", "1-4", "1.com", true, 1);
a->AddItem("2.com", "1-4", "1.com,2.com", true, 2);
a->AddItem("3.com", "1-4", "3.com,1.com", true, 3);
a->AddItem("4.com", "2-4", "4.com", false, 10);
a->AddItem("5.com", "2-4", "1.com", true, 10);
a->AddItem("6.com", "2-4", "1.com", true, 15);
a->AddItem("7.com", "3-4", "7.com", false, 7);
a->AddItem("8.com", "3-4", "1.com", false, 8);
a->AddItem("9.com", "3-4", "1.com", false, 9);
srand((unsigned) time(NULL));
a->Sort();
return 0;
}
STL sort实现
简而言之
- 数据量大时，采用Quick Sort
- 数据量小于某个阈值时，改用Insertion Sort
- 递归层次过深时，改用Heap Sort
算法细节部分进行了优化，但原理不变
问题根源
需要阅读stl源码
此部分参考博客https://liam.page/2018/09/18/std-sort-in-STL/
std::sort
template <class RandomAccessIterator>
inline void sort(RandomAccessIterator first, RandomAccessIterator last) {
if (first != last) {
__introsort_loop(first, last, value_type(first), __lg(last - first) * 2);
__final_insertion_sort(first, last);
}
}
他接受两个随机访问迭代器 [first, last)，这里假设 last 不会先于 first。
__introsort_loop 为具体的排序实现，__final_insertion_sort 则是插入排序。 std::sort 在排序基本完成任务后调用插入排序以提升效率，在__introsort_loop排序基本完成后，frist和last也会相应改变，只剩下[first, last)这个小区间乱序，直接插入排序即可。
__introsort_loop
template <class RandomAccessIterator, class T, class Size>
void __introsort_loop(RandomAccessIterator first,
RandomAccessIterator last, T*,
Size depth_limit) {
while (last - first > __stl_threshold) {
if (depth_limit == 0) {
partial_sort(first, last, last);
return;
}
--depth_limit;
RandomAccessIterator cut = __unguarded_partition
(first, last, T(__median(*first, *(first + (last - first) / 2),
*(last - 1))));
__introsort_loop(cut, last, value_type(first), depth_limit);
last = cut;
}
}
__stl_threshold 是一个预定义的宏，当左闭右开区间的长度不大于该超参数时，转向插入排序。
每次 __introsort_loop 的递归，参数 depth_limit 都会自减一次；当该参数为 0 时，意味着递归深度已经很深，转向堆排，并退出递归。堆排序部分，我们不再赘述
__final_insertion_sort
template <class RandomAccessIterator>
void __final_insertion_sort(RandomAccessIterator first,
RandomAccessIterator last) {
if (last - first > __stl_threshold) {
__insertion_sort(first, first + __stl_threshold);
__unguarded_insertion_sort(first + __stl_threshold, last);
} else {
__insertion_sort(first, last);
}
}
当区间长度较小时，直接调用 __insertion_sort；当区间长度较大时，对前 __stl_threshold 个元素调用 __insertion_sort，而对前 __stl_threshold 个元素之后的元素调用 __unguarded_insertion_sort。 __unguarded_insertion_sort 做了某种优化以提升性能
__insertion_sort
template <class RandomAccessIterator>
void __insertion_sort(RandomAccessIterator first, RandomAccessIterator last) {
if (first == last) return;
for (RandomAccessIterator i = first + 1; i != last; ++i)
__linear_insert(first, i, value_type(first));
}
__linear_insert
template <class RandomAccessIterator, class T>
inline void __linear_insert(RandomAccessIterator first,
RandomAccessIterator last, T*) {
T value = *last;
if (value < *first) {
copy_backward(first, last, last + 1);
*first = value;
} else {
__unguarded_linear_insert(last, value);
}
}
出现问题的函数找到了
__linear_insert 函数模板的意图是将 last 所指向的元素插入到正确位置，这里蕴含的前提假设是[first, last) 区间的元素是已经排好序的。
在这一假设下，若 *last < *first，则last 指向的元素应当插入在上述区间的最前面，因此有 std::copy_backward；
若不满足条件判断，则在 [first, last) 之间必然存在不大于 value 的元素（比如至少 *first 是这样）
__unguarded_linear_insert
template <class RandomAccessIterator, class T>
void __unguarded_linear_insert(RandomAccessIterator last, T value) {
RandomAccessIterator next = last;
--next;
while (value < *next) {
*last = *next;
last = next;
--next;
}
*last = value;
}
next迭代器自减，直到找到比value小的元素；
它在对 next 迭代器的自减中，没有检查 next 迭代器是否向左超越边界，甚至根本没有输入左边界；
由于上一个函数的判断，此处假设应当是：while 循环会在 next 迭代器向左越界之前停止，但是如果两个元素的大小比较并不确定，而是一个随机值，此时就可能出现越界。
