C++ 基数排序崩溃

我想我已经正确地完成了我的算法，但是当我运行代码时它会崩溃。我想知道我能不能用你的眼睛看看我犯了什么错误。我想创建一个基数排序来对列表进行排序

#include <stdio.h>
#include <algorithm>
#include <list>
#include <iostream>

using namespace std;
void radixsort(list<int> s);
int find_max(list<int> t);
void splicing(list<int> s);
void radix_final(list<int> s, int maximum);

int main(int argc, char **argv)
{
    list<int>::iterator it;
    list<int> x;

    x.push_front(40);
    x.push_front(60);
    x.push_front(20);
    x.push_front(10);
    x.push_front(10);

    radixsort(x);
    for (it = x.begin(); it != x.end(); ++it)
    cout << ' ' << *it;
    cout << '\n';
    return 0;
}

void radixsort(list<int> s)
{
    int max = find_max(s);
    splicing(s);
    radix_final(s,max);

}

void radix_final(list<int> s, int maximum)
{
    list<int> list0;
    list<int> list1;
    const int MAX_ITERATOR = sizeof(maximum)*8;
    int divisor = 1;

    for(int i =0; i<MAX_ITERATOR;i++){
        if((s.front()/divisor)%2==0)
        {
            list0.push_back(s.front());
            s.pop_front();
        }
        else
        {
            list1.push_back(s.front());
            s.pop_front();
        }
        divisor = 2*divisor;
    }

    list<int>::iterator it;
    it = s.begin();
    s.splice(it,list1);
    s.splice(it,list0);
}

void splicing(list<int> s)
{
    list<int> even;
    list<int> odd;
    for(unsigned int i = 0; i<s.size();i++)
    {
        if(s.front()%2 ==0)
        {
            even.push_back(s.front());
            s.pop_front();
        }
        else
        {
            odd.push_back(s.front());
            s.pop_front();
        }
    } 
    list<int>::iterator it;
    it = s.begin();
    s.splice(it,odd);
    s.splice(it,even);
}

int find_max(list<int> t)
{
    int max = t.front();

    for(unsigned int i = 0; i<t.size();i++)
    {
        if (t.front() >= max)
        {
            max = t.front();
        }
        t.pop_front();
    }
    return max;
}

#包括
#包括
#包括
#包括
使用名称空间std；
无效radixsort（列表s）；
int find_max（列表t）；
无效拼接（列表s）；
无效基数_最终值（列表s，整数最大值）；
int main（int argc，字符**argv）
{
列表：：迭代器；
清单十；
x、 向前推（40）；
x、 向前推（60）；
x、 向前推（20）；
x、 向前推（10）；
x、 向前推（10）；
radixsort（x）；
for（it=x.begin（）；it！=x.end（）；++it）
cout
void radix\u final（列表s，整数最大值）
{
列表0；
清单1；
常量int MAX_迭代器=sizeof（最大值）*8；
//^^^嗯?？
整数除数=1；
对于（列表：：迭代器x=s.begin（）；x！=s.end（）；++x）{
如果（（*x/除数）%2==0）
列表0.推回（*x）；
其他的
列表1.将_向后推（*x）；
除数=2*除数；
}
列表：：迭代器；
it=s.begin（）；
s、 拼接（it，列表1）；
s、 拼接（it，list0）；
}
无效拼接（列表s）
{
并列；
单数；
对于（列表：：迭代器x=s.begin（）；x！=s.end（）；++x）{
如果（（*x）%2）=0）
偶数。向后推_（*x）；
其他的
奇数。推回（*x）；
}
列表：：迭代器；
it=s.begin（）；
s、 拼接（it，奇数）；
s、 拼接（it，偶数）；
}
int find_max（列表t）
{
int max=t.front（）；
对于（列表：：迭代器x=t.begin（）；x！=t.end（）；++x）
{
如果（*x>=最大值）
{
max=*x；
}
}
返回最大值；
}

是您的代码的固定版本。我不知道算法会发生什么；但是我确实找到了导致崩溃的列表的问题。它与所有的弹出有关。加上max迭代器对我来说毫无意义。
使用调试器检查代码时，您观察到了什么？它会在max=t.front（）处介入；然后当我单击“下一步”时，它会崩溃。在单击“下一步”之前，变量值是什么？它不会显示任何变量值。我确信您可以从IDE中看到它们是什么。您正在犯与OP相同的战术错误，这就是调用
t.front（）
而不检查空列表。您的代码可能会工作，但不检查调用
front
是危险的。这是真的；但我的目标是修复他当前遇到的崩溃错误。我认为，由于这很可能是一项正在进行的工作或实践中的工作，因此在进行错误检查和错误预防的过程中，这些逻辑步骤将起作用是他后来做的事情。因为它在之前，他有一个崩溃的程序，在他解决这个问题之前无法继续。因为它在现在，他的逻辑基本上是一样的。和家庭作业一样（尽管我认为不是这样），我怀疑我不应该为他做整件事。你如何在调用t.front（）时检查空列表。我想这没关系，因为我正在实际地将东西放入列表？或者它停止检查列表？
size（）
将是0。或者我首选的方法是
。begin（）==.end（）
，除非我误解了这个问题。
void radix_final(list<int> s, int maximum)
{
  list<int> list0;
  list<int> list1;

  const int MAX_ITERATOR = sizeof(maximum)*8;
  //^^^ Eh?
  int divisor = 1;

    for(list<int>::iterator x = s.begin(); x != s.end(); ++x){
        if((*x/divisor)%2==0)
             list0.push_back(*x);
        else
            list1.push_back(*x);
        divisor = 2*divisor;
    }

    list<int>::iterator it;
    it = s.begin();
    s.splice(it,list1);
    s.splice(it,list0);
}

void splicing(list<int> s)
{
    list<int> even;
    list<int> odd;
    for(list<int>::iterator x = s.begin(); x != s.end(); ++x){
    if( ((*x)%2)  == 0)
       even.push_back(*x);
    else
        odd.push_back(*x);


  }
   list<int>::iterator it;
    it = s.begin();
    s.splice(it,odd);
    s.splice(it,even);
}

int find_max(list<int> t)
{
int max = t.front();
for(list<int>::iterator x = t.begin(); x != t.end(); ++x)
{
    if (*x >= max)
    {
        max = *x;
        }
    }
    return max;
}