如何使用 lambda 找到最小距離

Question

我有兩個類Entity和Ship 。 Ship繼承自Entity 。 它們具有x和y作為屬性，代表二維平面上的 position。

squared_distance function 返回船舶和實體之間的距離。

class Entity
{
    public:
    int id, x, y;

    Entity(int id, int x, int y) : id(id), x(x), y(y) {}
};

class Ship : public Entity
{
    public:
    int orientation, speed, rum;

    Ship(int id, int x, int y, int ori, int s, int r): 
        Entity(id, x, y)
    {
        orientation = ori;
        speed = s;
        rum = r;
    }
};

int squared_distance(Entity e, Ship s)
{
    return pow((e.x - s.x), 2) + pow((e.y - s.y), 2);
}

我需要找到離船最近的實體。 我有一個名為entities的Entity數組。 一種方法是：讓ship是Ship的 object 。

index將給出ship最近的實體的索引。

int min_distance = 10000000;
int index;
for (int i = 0; i < entities.size(); ++i)
{
    int curr_distance = squared_distance(entities[i], ship);

    if (curr_distance < min_distance)
    {
        min_distance = curr_distance;
        index = i;
    }
}

如何在算法庫中使用帶有std::min_element的 lambda 找到最近的實體？

Answer 1

int squared_distance(const Entity& e, const Ship& s)
{
    return pow((e.x - s.x), 2) + pow((e.y - s.y), 2);
}

std::min_element(std::begin(entities), std::end(entities), [&ship](const Entity& a, const Entity& b) { return squared_distance(a, ship) < squared_distance(b, ship); });

請注意，您需要更新squared_distance聲明中的參數。

Answer 2

您可以像這樣將其轉換為std::min_element ：

auto closer = [&ship](const auto &e1, const auto &e2) {
                return squared_distance(e1, ship) 
                     < squared_distance(e2, ship);
              };

auto it = std::min_element(std::begin(entities), std::end(entities), closer);

請注意，此算法（與大多數算法一樣）將返回一個iterator到最近的船。 您可以通過取消引用此迭代器來獲得最近的船：

auto closest_ship = *it;

您還可以獲得這艘船的索引（就像您的版本一樣）：

int i = std::distance(std::begin(entities), it);

正如@SM 在他們的回答中指出的那樣，您的squared_distance function 應該通過const&獲取其參數，因為您不需要復制這些對象來比較它們。

Answer 3

就像是

#include <iterator>
#include <algorithm>

//...

auto it = std::min_element( std::begin( entities ), std::end( entities ),
                            [&ship]( const auto &first, const auto &second )
                            {
                                return squared_distance( first, ship ) < squared_distance( second, ship );
                            } );   

您可以單獨定義 lambda，例如

auto less_distance = [&ship]( const auto &first, const auto &second )
{
    return squared_distance( first, ship ) < squared_distance( second, ship );
};   

然后算法的調用看起來像

auto it = std::min_element( std::begin( entities ), std::end( entities ),
                            less_distance );