Question

我想使用sort（）来执行以下操作

我有一个文本char [] T，它是一个类的（私有）成员。文字长度为n。
我还有一个数组int [] P，它包含前n个整数。

我想std :: sort P，以便保留T后缀中的词典顺序即，对于任何i < j，我们T[P[i]...n]的lex小于T[P[j]...n]。

当char[] T是全局变量时，我可以通过定义

来实现

bool myfunction (int i,int j) { 
  int m = i, l = j;
  while(m<n and l <n) {
      if(T[m] != T[l]) return (T[m]<T[l]);
      m++; l++;
  }
  return (m<l);
}

并致电std::sort(P, P+n, myfuction)

当T是对象的一个成员时，我处于不稳定状态（并且该对象的方法调用了sort）。

如何定义myfunction以便T可见？它应该是该对象的成员吗？如果有，怎么样？非常感谢你。

编辑：bool而不是int

Answer 1

正如您所猜测的，一种方法是将您的函数（）定义为该类的公共成员。

示例：

#include <algorithm>
#include <vector>

using namespace std;

class T
{
private:
    int value;
public:
    T()
    {
        value = rand() % 100;
    }

    static bool Compare(const T &a, const T &b)
    {
        return a.value < b.value;
    }
};

int main(int argc, char** argv)
{
    vector<T> data;

    //add some data
    for (int i=0; i<10; i++)
        data.push_back(T());

    //sort using static method that can access private attributes
    std::sort(data.begin(), data.end(), T::Compare);
}

Answer 2

如果sort代表std::sort，那么您使用的函数作为谓词是错误的，原因有两个，第一个原因是函数返回的类型应该是{{1而不是bool。

接下来的错误是谓词必须保持一致，即，给定两个输入int和a，b的结果必须为true或false并始终如一。如果不满足该条件，则调用predicate( a, b )的结果将是未定义的，可能包括无限循环。

方法（而不是谓词本身）可能也不好，因为谓词的调用次数取决于输入数据，以及对谓词的不同调用的结果（直到算法认为，根据你的部分顺序，序列被排序）。

Answer 3

您可能需要一个仿函数对象：

struct myfunctor {
    const char *T;
    size_t n;
    myfunctor(const char *T, size_t n) : T(T), n(n) {}
    bool operator()(int i, int j) {
        // stuff using T and n
    }
    // Optionally, something along these lines, I haven't tested it
    template <size_t N> myfunctor(const char (&x)[N]) : T(&x[0]), n(N) {}
    template <size_t N> myfunctor(char (&x)[N]) : T(&x[0]), n(N) {}
};

SomeObjectContainingT x;
std::sort(P, P+n, myfunctor(x.T, x.n));

或者如果x.T是一个实际数组而不仅仅是一个指针，模板构造函数将从类型中捕获数组大小，不需要第二个参数：

std::sort(P, P+n, myfunctor(x.T));

编辑：抱歉，错过了T是私密的。我认为你在这里有两个问题，范围和可访问性。函数解决了范围问题，现在是可访问性问题。

如果您希望外部函数访问T，x必须提供访问它的方法。例如，它可以返回仿函数对象：

class SomeObjectContaining T {
    char T[23];
  public:
    myfunctor comparator() { return myfunctor(T); }
};

std::sort(P, P+n, x.comparator());

或者你可以搞砸friend：将你的仿函数类定义为SomeObjectContainingT的friend，然后将对象传递给它的构造函数而不是数组。

通过在c ++中使用对象的成员进行排序

3 个答案: