C++ 如何使用中间变量编写用于stl排序的比较器类点 { int x； } 静态点参照点；结构比较器 { 布尔ABS比较器（常数点和p1、常数点和p2） { 返回abs（p1.x-referencePoint.x）_C++_Sorting_Stl

C++ 如何使用中间变量编写用于stl排序的比较器类点 { int x； } 静态点参照点；结构比较器 { 布尔ABS比较器（常数点和p1、常数点和p2） { 返回abs（p1.x-referencePoint.x）

c++ sorting

C++ 如何使用中间变量编写用于stl排序的比较器类点 { int x； } 静态点参照点；结构比较器 { 布尔ABS比较器（常数点和p1、常数点和p2） { 返回abs（p1.x-referencePoint.x）,c++,sorting,stl,C++,Sorting,Stl,但是我不能使用静态引用点来保证多线程安全，还有其他方法吗？？谢谢。为什么不简单地将参考点或点内的整数值保存为比较器内的成员，这样，您总是在比较器函数中访问它。为什么不简单地将参考点或点中的整数值保存为比较器中的一个成员，这样您总是在比较器函数中访问它。将其作为比较器的一部分： class Point { int x; } static Point referencePoint; struct Comparator { bool AbsComparat

但是我不能使用静态引用点来保证多线程安全，还有其他方法吗？？

谢谢。

为什么不简单地将

参考点

或

点

内的整数值保存为

比较器

内的成员，这样，您总是在比较器函数中访问它。

为什么不简单地将

参考点

或

点

中的整数值保存为

比较器

中的一个成员，这样您总是在比较器函数中访问它。

将其作为

比较器

的一部分：

class Point    
{    
    int x;  
}    
static Point referencePoint;
struct Comparator
{
    bool AbsComparator(const Point& p1, const Point& p2)
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};    
list<Point> points;
points.sort(Comparator::AbsComparator);

结构比较器 { 点参照点；比较器（点referencePoint）：referencePoint（referencePoint）{} 比较器（常数比较器和rhs）{ referencePoint=rhs.referencePoint； } 布尔运算符（）（常数点和p1、常数点和p2）常数 { 返回abs（p1.x-referencePoint.x）将其作为比较器的一部分：

class Point    
{    
    int x;  
}    
static Point referencePoint;
struct Comparator
{
    bool AbsComparator(const Point& p1, const Point& p2)
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};    
list<Point> points;
points.sort(Comparator::AbsComparator);

改用局部变量：

struct Comparator
{
    Point referencePoint;

    Comparator(Point referencePoint): referencePoint(referencePoint) {}

    Comparator(const Comparator& rhs) {
        referencePoint = rhs.referencePoint;
    }

    bool operator()(const Point& p1, const Point& p2) const
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};    

...

points.sort(Comparator(refP));

或者简单地说

Point referencePoint(10,20); //use local variable!

points.sort(Comparator(referencePoint));

其中，

比较器

定义为：

points.sort(Comparator(Point(10,20)));

结构比较器 { 点参照点；显式比较器（常量点&pt）：引用点（pt）{} 布尔运算符（）（常数点和p1、常数点和p2）常数 { 返回abs（p1.x-referencePoint.x）你完了

请注意

operator（）

的实现。这使类成为函子。

避免全局变量。这是编写多线程代码的开始

改用局部变量：

struct Comparator
{
    Point referencePoint;

    Comparator(Point referencePoint): referencePoint(referencePoint) {}

    Comparator(const Comparator& rhs) {
        referencePoint = rhs.referencePoint;
    }

    bool operator()(const Point& p1, const Point& p2) const
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};    

...

points.sort(Comparator(refP));

或者简单地说

Point referencePoint(10,20); //use local variable!

points.sort(Comparator(referencePoint));

其中，

比较器

定义为：

points.sort(Comparator(Point(10,20)));

请注意

operator（）

的实现。这使类成为函子。

您可以简单地以解构或结构化方式存储此变量

struct Comparator
{
    Point referencePoint;

    explicit Comparator(const Point & pt) : referencePoint(pt) {}

    bool operator() (const Point& p1, const Point& p2) const
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};

如果需要排序，我建议不要使用

列表<代码>列表

不擅长于此…

您可以简单地以解构或结构化方式存储此变量

struct Comparator
{
    Point referencePoint;

    explicit Comparator(const Point & pt) : referencePoint(pt) {}

    bool operator() (const Point& p1, const Point& p2) const
    {    
        return abs(p1.x - referencePoint.x) < abs(p2.x - referencePoint.x);
    }   
};

如果需要排序，我建议不要使用

列表<代码>列表

不擅长…

如果引用点用作只读确保您可以使用（TLS）。如果引用点用作只读确保您可以使用（TLS）。最好将

运算符（）

设置为常量函数！此外，不需要复制构造函数。编译器生成一个就足够了。最好将

操作符（）

设为常量函数！此外，不需要复制构造函数。编译器生成一个就足够了。@MatthieuM.：在这种情况下，我看不到显式的有什么好处，是吗？我看不到隐式的好处。编写新数字类的情况并不罕见。默认情况下，我倾向于将所有“单参数”构造函数编写为

显式。如果它被隐式使用，至少我会得到通知，反之亦然：）@MatthieuM.：令人信服的论点。谢谢。：-）（编辑帖子）@MatthieuM.：在这种情况下，我看不到显式的
有什么好处，是吗？我看不到隐式的好处。编写新数字类的情况并不罕见。默认情况下，我倾向于将所有“单参数”构造函数编写为显式。如果它被隐式使用，至少我会得到通知，反之亦然：）@MatthieuM.：令人信服的论点。谢谢。：-）（该帖编辑）