Question

我有一个名为Position的课程：

class Position
{
    public:
    ... //Constructor, Destructor, ...

    private:

      signed int x_;
      signed int y_;
}

然后我有一个存储指针Positions：

的向量

std::vector<Position*> positions

如何检查向量中是否包含Position？例如，我有一个Position：

的对象

Position* p_ = new Position(0, 0);

我想检查矢量是否包含具有相同坐标的Position？我需要哪个操作员超载？

谢谢，芭芭拉

Answer 1

auto it = find_if(positions.begin(), positions.end(), 
                 [=](position* p)
                 {
                    return p->x() == p_->x() && p->y() == p_->y();
                 });

if(it != positions.end())
{
       //object found
}

但是，除非您有真正的理由在向量中存储指针（例如，您将要使用多态），否则直接存储对象要简单得多。

vector<position> v;
v.push_back(Position(1, 2));
...
Position p_(1, 4);
auto it = find_if(v.begin(), v.end(), 
                  [=](position p)
                  {
                      return p.x() == p_.x() && p.y() == p_.y();  
                  });
if(it != v.end())
{
   //position found
}

在后一种情况下，可以通过重载operator == for position来进一步简化代码。

bool operator == (position p1, position p2)
{
   return p1.x == p2.x && p1.y == p2.y; //assuming operator == is declared friend
}

然后你可以

auto it = find(v.begin(), v.end(), p_);

Answer 2

将此添加到班级位置

Public:
bool isSamePosition(position * p){
    return p->x == this->x && p->y ==this->y;
}

然后与向量中的所有进行比较

bool unique = true;
for (int i = 0; i < positions.length(); ++i){
    if (new_position->isSamePosition(positions[i])
        unique = false;
}
if (unique==true)
 //do something like push_back vector
;

Answer 3

我想检查矢量是否包含具有相同坐标的位置？我需要哪个操作员超载？

如果您有一个位置向量（而不是指向位置的向量），那么您必须重载的运算符将是：

bool Position::operator==(const Position& p);

使用此代码，您可以编写（假设您使用的是std::vector<Position> positions;，而不是std::vector<Position*> positions;）：

using std::find; using std::begin; using std::end;
const Position p{}; // element that is sought after
bool exists = (end(positions) != find(begin(positions), end(positions), p));

[评论：]是的，我也很不确定。我问我的一个队友他为什么这样做[即按指针存储]他说它会更高效，更快，不应该改变 - 永远。

它可能不比按值存储更有效，也更快。如果您无法更改向量，则必须添加上面声明的运算符，以及将Position实例与Position指针中的值进行比较的谓词，并将其与std :: find：<一起使用。 / p>

    const Position p{}; // element that is sought after
    auto matches_position = [&p](Position const* const x)
    {
        return x != nullptr // can positions in the vector be null?
            && p == *x;
    };

    bool exists = (end(positions) != find(begin(positions), end(positions),
        matches_position));

==应对策略==

通过执行以下操作，我会选择第一个版本（向量中没有指针）：

创建一个新的（简约）项目，它填充两个单独的向量，带有一堆随机位置（固定数量的位置，在2000到10000个实例之间）;向量应分别包含指针和值的位置，每个位置的值相同（位置应在两个向量中，在同一索引处）
在两个向量中搜索相同的值。
多次重复搜索（平均并最小化时间错误）
将结果传达给您的同事。

这有两个结果：要么你的同事是对的（这似乎不太可能，但嘿！谁知道？）或者他错了，他的代码“永远不应该改变” - 好吧......应该改变。

在向量C ++中查找对象的指针

3 个答案: