请精通stl的大神解答。

[登疯作极]

下面C++代码，请问为什么会有问题呢？请精通stl的大神解答。

bool cmp(float& i1, float& i2){
return i1 <= i2;
}

int main(){

list<float> a;
a.push_front(2.0);
a.push_front(2.0);
a.sort(cmp);

return 0;
}

[dustpg]

这精通也太廉价了吧, comparator会交换两个参数判断是否一样, 也都返回false, 你这样都会返回true.

    a.sort([](const float& a, const float& b) { return a < b; });

用匿名表达式提高效率吧

[ri_aje]

用 < 排序才行。标准的说法叫 strict weak ordering.

[paschen]

引用 3 楼 xfboy2008 的回复:

[quote=引用 1 楼 dustpg 的回复:] 这精通也太廉价了吧, comparator会交换两个参数判断是否一样, 也都返回false, 你这样都会返回true.

    a.sort([](const float& a, const float& b) { return a < b; });

用匿名表达式提高效率吧

soga，那它为什么不直接用==判断是否相等呢，而是用了一种交换比较的方法，这样做有什么好处么？[/quote] 你要的是排序，你只知道两个相等或不等，怎么确定排在前还是排在后 其次只需要使用<即可，判断 a与b相等则为a不小于b同时b不小于a ，这是一种strict weak ordering

[登疯作极]

引用 4 楼 paschen 的回复:

[quote=引用 3 楼 xfboy2008 的回复:] [quote=引用 1 楼 dustpg 的回复:] 这精通也太廉价了吧, comparator会交换两个参数判断是否一样, 也都返回false, 你这样都会返回true.

    a.sort([](const float& a, const float& b) { return a < b; });

用匿名表达式提高效率吧

soga，那它为什么不直接用==判断是否相等呢，而是用了一种交换比较的方法，这样做有什么好处么？[/quote] 你要的是排序，你只知道两个相等或不等，怎么确定排在前还是排在后 其次只需要使用<即可，判断 a与b相等则为a不小于b同时b不小于a ，这是一种strict weak ordering[/quote] 你再仔细看下2楼说的，他讲的意思是comparator用的是交换两个参数来确定是否相等？不知道你理解这个意思是什么样子的

[paschen]

引用 5 楼 xfboy2008 的回复:

[quote=引用 4 楼 paschen 的回复:] [quote=引用 3 楼 xfboy2008 的回复:] [quote=引用 1 楼 dustpg 的回复:] 这精通也太廉价了吧, comparator会交换两个参数判断是否一样, 也都返回false, 你这样都会返回true.

    a.sort([](const float& a, const float& b) { return a < b; });

用匿名表达式提高效率吧

soga，那它为什么不直接用==判断是否相等呢，而是用了一种交换比较的方法，这样做有什么好处么？[/quote] 你要的是排序，你只知道两个相等或不等，怎么确定排在前还是排在后 其次只需要使用<即可，判断 a与b相等则为a不小于b同时b不小于a ，这是一种strict weak ordering[/quote] 你再仔细看下2楼说的，他讲的意思是comparator用的是交换两个参数来确定是否相等？不知道你理解这个意思是什么样子的[/quote] 搞笑，你确定个毛相等，我告诉你sort要用小于，不是你函数起个名叫cmp就是用来比相等的

[登疯作极]

引用 1 楼 dustpg 的回复:

这精通也太廉价了吧, comparator会交换两个参数判断是否一样, 也都返回false, 你这样都会返回true.

    a.sort([](const float& a, const float& b) { return a < b; });

用匿名表达式提高效率吧

soga，那它为什么不直接用==判断是否相等呢，而是用了一种交换比较的方法，这样做有什么好处么？

[lp310018931]

对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

[paschen]

引用 7 楼 lp310018931 的回复:

对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

可以用大于，这样是从大到小排，但肯定不能是等于、大于等于、小于等于...

[登疯作极]

引用 11 楼 fefe82 的回复:

[quote=引用 9 楼 xfboy2008 的回复:] [quote=引用 8 楼 paschen 的回复:] [quote=引用 7 楼 lp310018931 的回复:] 对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

可以用大于，这样是从大到小排，但肯定不能是等于、大于等于、小于等于...[/quote] 对啊，我也知道不能用任何有等于的返回，关键问题是为什么不行？知其然要知其所以然[/quote] 用小于可以实现等于: 若 !(a<b) && !(b<a) 则 a==b 。 同时，stl 一般要求的 < 与 == 需要满足以下条件： a < b && b < c 可以推出 a < c a == a 恒为 true a == b && b == c 可以推出 a == c 满足以上条件的关系，用 < 可以实现其它所有的关系运算 标准选择了小于作为关系运算的基础，使用小于实现其它关系。满足以上条件的其它关系也可以。 （使用其它关系为基础，各个不同关系的实现方式会不同） stl 的实现的时候基于以上假设，如果提供的关系不满足以上假设，就有可能出错。[/quote] 谢啦，这才是我要的答案。。。

[登疯作极]

引用 8 楼 paschen 的回复:

[quote=引用 7 楼 lp310018931 的回复:] 对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

可以用大于，这样是从大到小排，但肯定不能是等于、大于等于、小于等于...[/quote] 对啊，我也知道不能用任何有等于的返回，关键问题是为什么不行？知其然要知其所以然

[赵4老师]

参考《数论》中相关章节。

[fefe82]

引用 9 楼 xfboy2008 的回复:

[quote=引用 8 楼 paschen 的回复:] [quote=引用 7 楼 lp310018931 的回复:] 对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

可以用大于，这样是从大到小排，但肯定不能是等于、大于等于、小于等于...[/quote] 对啊，我也知道不能用任何有等于的返回，关键问题是为什么不行？知其然要知其所以然[/quote] 用小于可以实现等于: 若 !(a<b) && !(b<a) 则 a==b 。 同时，stl 一般要求的 < 与 == 需要满足以下条件： a < b && b < c 可以推出 a < c a == a 恒为 true a == b && b == c 可以推出 a == c 满足以上条件的关系，用 < 可以实现其它所有的关系运算 标准选择了小于作为关系运算的基础，使用小于实现其它关系。满足以上条件的其它关系也可以。 （使用其它关系为基础，各个不同关系的实现方式会不同） stl 的实现的时候基于以上假设，如果提供的关系不满足以上假设，就有可能出错。

[paschen]

引用 9 楼 xfboy2008 的回复:

[quote=引用 8 楼 paschen 的回复:]
[quote=引用 7 楼 lp310018931 的回复:]
对于内置类型，不是默认就是<，使用a.sort()，结果不是一样？a.sort([](const float& a, const float& b) { return a < b; });不是多此一举

可以用大于，这样是从大到小排，但肯定不能是等于、大于等于、小于等于...[/quote]

对啊，我也知道不能用任何有等于的返回，关键问题是为什么不行？知其然要知其所以然[/quote]

前面我已经说了：strict weak ordering
楼主可参看相关资料