Установите указатель на элемент в векторе равным нулю, затем проверьте, является ли указатель нулевым (С++)

Мне кажется, вы пытаетесь отслеживать «посещенные» элементы, не зная точно, каким образом.

Вместо «изменения» элементов вы можете использовать «внешнюю» метку. Набор выглядит здесь хорошо. Вы можете использовать набор iterator в списке частиц или, в данном случае, набор indices (i,j), который, вероятно, будет более стабильным.

Вот начало:

#include <vector>
#include <set>

struct particle { };

double distance(particle const&, particle const&) { return 1.0; }

struct context
{
    std::size_t numparticles;
    std::vector<particle> particlelist;

    context() : numparticles(100), particlelist(numparticles) {}
};

static context c;

int main()
{
    using std::vector;
    using std::size_t;

    vector<particle> pl = c.particlelist;
    vector<vector<particle>> collisionlist;

    std::set<size_t> collision;

    for(size_t i = 0; i < c.numparticles-1; i++)
    {
        particle first = pl[i];
        for(size_t j = i+1; j < c.numparticles; j++)
        {
            particle second  = pl[j];
            double d = distance(first, second);
            if(d < 0.0001)
            {
                collisionlist.push_back({pl[i], pl[j]});
                collision.insert(i);
                collision.insert(j);
            }
            else
            {
            }
        }
    }

    for(size_t i = 0; i < pl.size(); i++)
    {
        if(collision.end() != collision.find(i))
        {
            // do something
        }
    }

    // alternatively
    for (int index : collision)
    {
        particle& p = pl[index];
        // do something
    }
}

ПРИМЕЧАНИЕ Будьте очень осторожны при сравнении с плавающей запятой, например

 if (d==0.0) // uhoh

потому что это, вероятно, не будет делать то, что вы ожидаете

• Насколько опасно сравнивать значения с плавающей запятой?
• Каков наиболее эффективный способ сравнения с плавающей запятой и двойного сравнения?
• Является ли число с плавающей запятой == всегда в порядке?

Вы используете & для получения указателя на временное значение (возврат из getxpos), что не разрешено; поскольку временный адрес будет уходить, адрес никоим образом не будет полезен, поэтому язык не позволяет этого. Это определенно никогда не было бы NULL, даже если бы вы могли получить его адрес.

noncollision[i].setxposint(NULL);

Все, что делает эта строка, это устанавливает xpos в ноль. Обычно термин NULL используется с указателями, а 0 используется с такими вещами, как целые числа. NULL в любом случае обычно является макросом для 0L.

&(noncollision[i].getxpos()) == NULL

Что это делает, что неверно, пытается взять адрес возвращаемого значения из метода-члена getxpos() и сравнить его с NULL. В то время как то, что вы действительно хотите сделать, это просто посмотреть, возвращает ли функция ноль. Поэтому просто измените эту строку на:

noncollision[i].getxpos() == 0

Я объясню, почему компилятор не понимает, что вы имеете в виду.

Когда вы пишете

&(someFunction())

вы запрашиваете адрес того, что возвращает функция. Но функции возвращают значения. Значение не имеет адреса. Переменные имеют адреса.

Когда что-то является словом памяти (которое будет содержать значение), его можно использовать как lvalue (левое значение), потому что вы можете помещать вещи в это слово памяти:

int b = 1; //make room for an `int` on the stack, then put a `1` there.

Когда что-то является просто значением, его можно использовать только как rvalue. Следующее не будет компилироваться по той же причине, что и ваш код:

int b; //make room for an `int` on the stack.
42 = b; //ERROR, this makes no sense.
if (42 == NULL) { std::cout << "this is never true" << std::endl; }
&42; //ERROR, 42 isn't a piece of memory, it's a value.

(Предостережение: вы можете использовать значения для ссылки на слова в памяти: такое использование называется указателем, например.

int b = 1;
*((int *)(42)) = b;

что означает «поместить значение b в память с адресом 42. Это компилируется нормально (но вылетает, если вам не разрешено записывать в память по адресу 42).

Похоже, вы пытаетесь проверить пары точек на коллизии. Затем вы записываете для каждой точки, имеет ли она какое-либо столкновение. Лучше всего с этим справляется простой список флагов:

std::vector<bool> has_collision(c.numparticles, false); // init: no collisions found

После:

    if (d==0)
    {
        has_collision[i] = true;
        has_collision[j] = true;
    }

В конце перебираем список флагов и получаем точки, в которых нет коллизий:

for (size_t i = 0; i < c.numparticles; ++i)
{
    if (!has_collision[i])
    {
        // whatever
        // possibly push_back pl[i] into some list
    }
}

Кроме того: использование vector для хранения пары (i,j) точек сбивает с толку. Стандартная библиотека имеет тип std::pair для таких целей.

Кроме того: вам не нужно явное динамическое выделение (new); позвольте стандартной библиотеке управлять памятью безопасным и не запутанным способом. Вместо

vector<vector<particle>> collisionlist = *new vector<vector<particle>>();

Использовать

vector<vector<particle>> collisionlist;

(или vector<pair<particle, particle>>, как описано выше).