如何对向量进行排序?

发布于 2024-12-11 05:00:43 字数 267 浏览 0 评论 0原文

#include <algorithm>

bool comparisonFunc(char* c1, char* c2)
{
     return strcmp(c1, c2) ? 0 : 1;
}

vector<char*> myVec;
vector<char*>::iterator itr;
sort(myVec.begin(), myVec.end(), comparisonFunc)

这是正确的还是有更好的方法?

#include <algorithm>

bool comparisonFunc(char* c1, char* c2)
{
     return strcmp(c1, c2) ? 0 : 1;
}

vector<char*> myVec;
vector<char*>::iterator itr;
sort(myVec.begin(), myVec.end(), comparisonFunc)

Is that correct or is there a better way to do it?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(3

内心旳酸楚 2024-12-18 05:00:43

std::sort需要一个“小于”谓词。您应该像这样实现您的 comparisonFunc() :(

bool comparisonFunc(const char *c1, const char *c2)
{
    return strcmp(c1, c2) < 0;
}

注意 const;它们很重要。)

您当前的实现不可能工作,因为您只是返回如果值是否相等。这些信息不足以进行排序 - 您需要知道哪一个较小,哪一个较大(当然,除非值相等)。

std::sortexpects a "less than" predicate. You should implement your comparisonFunc() like this:

bool comparisonFunc(const char *c1, const char *c2)
{
    return strcmp(c1, c2) < 0;
}

(Note the consts; they are important.)

Your current implementation couldn't possibly work because you just return if the values are equal or not. That information is not enough to sort - you need to know which one is smaller and which one is bigger (unless, of course, the values are equal).

你曾走过我的故事 2024-12-18 05:00:43

使用现代 C++,您可以内联定义比较方法:

std::vector<const char*> strings;
/* fill strings vector */
std::sort(strings.begin(), strings.end(), [](const char* lhs, const char* rhs) {
    return strcmp(lhs, rhs) < 0;
});

请注意,strcmp 返回 -1/0/+1 来指示序数,因此 0 比较。

With modern C++, you can define the comparison method inline:

std::vector<const char*> strings;
/* fill strings vector */
std::sort(strings.begin(), strings.end(), [](const char* lhs, const char* rhs) {
    return strcmp(lhs, rhs) < 0;
});

Note that strcmp returns -1/0/+1 to indicate ordinality, hence the < 0 comparison.

巴黎夜雨 2024-12-18 05:00:43

我更经常想要对指向记录的指针向量进行排序,而不仅仅是普通的 C 字符串...

    template<>
    struct std::less<const foo*>
    {
       bool operator()(const foo* lhs, const foo* rhs) const
       {
          return strcmp(lhs->key, rhs->key);
       }
    };

这重新定义了 foo* 的比较,以便默认比较在排序中起作用。对我来说,这种风格更具声明性,而另一种风格则更具程序性。如果您需要多次订购,则使用默认值是有问题的;如果您想确保 foo*s 的所有有序集合都按相同的顺序排列,那就很好。

std::vector<foo*> db;
std::sort(db.begin(), db.end());

I more often want to sort a vector of pointer to records than just plain C-strings...

    template<>
    struct std::less<const foo*>
    {
       bool operator()(const foo* lhs, const foo* rhs) const
       {
          return strcmp(lhs->key, rhs->key);
       }
    };

This redefines comparison of foo* such that the default comparison works in the sort. To me this style feels more declarative, the other more procedural. If you need multiple orderings this use of the default is problematic; if you want to be sure that all ordered collections of foo*s are in the same order it's good.

std::vector<foo*> db;
std::sort(db.begin(), db.end());
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文