只有当this->x和this->y小于point中的x和y时，operator<的实现才会返回true，这显然没有与origo进行距离比较：

bool Point::operator<(const Point& point) const { 
   return (((point.x) < (x))&& (point.y)<(y));
}

如果this更接近origo，你需要比较的是它们到origo的距离--但是，你真的需要这个距离吗？不，比较平方距离会产生完全相同的结果。

bool Point::operator<(const Point& point) const { 
   return x * x + y * y < point.x * point.x + point.y * point.y;
}

为了完成你所需要的打印，你可以为operator<<添加一个重载，同时，你也可以添加一个operator>>重载来读取Point：

// a function to read `Point` values from an `istream`:
friend std::istream& operator>>(std::istream& is, Point& p) {
    return is >> p.x >> p.y;
}

// a function to print a `Point` to an `ostream`:
friend std::ostream& operator<<(std::ostream& os, const Point& p) {
    return os << '(' << p.x << ',' << p.y << ')';
}

这样，你就可以像这样读取和打印Point：

if(int n; std::cin >> n && n > 0) {
    // create `n` `Point`s:
    std::vector<Point> pnts(n);

    // fill in the values by reading from `std::cin`:
    for(auto& pnt : pnts) std::cin >> pnt;

    // print the `Point`s in the original order:
    for(const auto& pnt : pnts) std::cout << pnt << ' ';
    std::cout << '\n';

    // sort according to `Point::operator<`:
    std::sort(pnts.begin(), pnts.end());

    // display the `Point`s sorted according to distances to origo:
    for(const auto& pnt : pnts) std::cout << pnt << ' ';
    std::cout << '\n';
}

Demo
如果你想要一个单独的displayPoints函数，让它接受vector乘以const&：

void displayPoints(const std::vector<Point>& points) {
    for (size_t i = 0; i < points.size(); ++i) {
        std::cout << points[i] << ' ';
    }   
    std::cout << '\n';
}

或者更简单地，使用基于范围的for-循环：

void displayPoints(const std::vector<Point>& points) {
    for (const auto& pnt : points) {
        std::cout << pnt << ' ';
    }
    std::cout << '\n';
}

您已经有了计算两点之间距离的算法，只需要将该算法应用于operator<（即，它不属于operator-）。如果this（比较的左侧Point）比输入点（比较的右侧Point）更接近原点，否则返回false。
例如，尝试类似下面的操作（假设原点为(0,0)）：

//Distance
// d=√((x2 – x1)² + (y2 – y1)²)
bool Point::operator<(const Point& point) const { 
    const Point origin{0, 0};
    double distance1 = sqrt(pow(x - origin.x, 2) + pow(y - origin.y, 2));
    double distance2 = sqrt(pow(point.x - origin.x, 2) + pow(point.y - origin.y, 2));
    return distance1 < distance2;

    /* which can be simplified to:
    return (pow(x,2) + pow(y,2)) < (pow(point.x,2) + pow(point.y,2));
    or:
    return ((x*x) + (y*y)) < ((point.x * point.x) + (point.y * point.y));
    */
}

您可以考虑在Point类中添加一个DistanceFrom()类型的方法，例如：

double Point::DistanceFrom(const Point &point) const {
    return sqrt(pow(x - point.x, 2) + pow(y - point.y, 2));
    /* alternatively:
    double xd = x - point.x;
    double yd = y - point.y;
    return sqrt((xd * xd) + (yd * yd));
    */
}

然后，您可以在operator<中使用它，例如：

bool Point::operator<(const Point& point) const { 
    const Point origin{0, 0};
    return DistanceFrom(origin) < point.DistanceFrom(origin);
}

无论哪种方式，您都可以使用标准std::sort()算法实现实际排序，该算法使用operator<对项目进行排序，例如：

#include <iostream>
#include <vector>
#include <algorithm>

void display(const std::vector<Point>& points) {
    for(const auto &point: points) {
        std::cout << '(' << point.x << ',' << point.y << ") ";
    }
    std::cout << std::endl;
}

...

std::vector<Point> points;
int count;

std::cin >> count;
for(int i = 0; i < count; ++i)
{
    double x, y;
    std::cin >> x >> y;
    points.emplace_back(x, y);
}

display(points);
std::sort(points.begin(), points.end());
display(points);