Безопасно / не рекомендуется создавать общие указатели из слабого указателя - PullRequest
Новая
       31

Безопасно / не рекомендуется создавать общие указатели из слабого указателя

0 голосов
/ 05 ноября 2018

Введение

У меня есть два класса, которые я называю Node и Point здесь. Точки - это объекты, которые содержат конкретную информацию (какая именно информация не имеет значения, я использую в примере простое целое число). Узлы - это объекты, которые управляют несколькими точками, если они должны совместно использовать одну и ту же информацию. Таким образом, Node имеет список указателей на все точки, которыми он управляет (что хорошо, потому что Point удаляет свою ссылку из узла, если заканчивается его время жизни), и каждая точка имеет обратную ссылку на сам узел. Это создает круговую ссылку, которая делает вещи немного сложнее. Я не использую многопоточность, поэтому гонки любого рода не являются проблемой. Кроме того, я обязан использовать C ++ 03 (так что в основном C ++ 98) и повысить уровень 1,53, поэтому есть ограничения по возможностям, которые я могу использовать.

EDIT:

поскольку это кажется немного неясным, я хотел добавить, что это действительно очень минималистичное извлечение реального кода. Поскольку я хотел предоставить минимальный рабочий пример, я старался изо всех сил извлечь функциональность из оригинальной программы. Однако убедитесь, что использование общих указателей необходимо в реальной программе, поскольку эти ресурсы совместно используются несколькими объектами разных классов. Также я использую общие указатели, потому что они всегда являются необязательными, что означает, что вы можете проверить их на NULL и действовать по-другому, если они не назначены, как также можно увидеть в коде ниже.

Проблема

Я еще не описывал «обратную ссылку на узел», потому что именно здесь начинается проблема. Итак, на данный момент я согласился с этим решением:

Мой Node содержит слабый указатель на себя, поэтому владение может быть разделено с другими точками. При добавлении точки узел создает общий указатель из слабого указателя, как это 

p->node = this->weakThis.lock();

но я не знаю, является ли это просто плохой практикой или содержит серьезные проблемы, которых я не вижу, так как ссылка на weak_ptr :: lock () только утверждает, что он создает новый общий объект, несмотря на его запутанное имя, или если это приемлемый код.

Другие решения, о которых я думал

  • Все классы получают общие указатели

    • хорошо: не нужно создавать общие объекты из слабых
    • плохо: общий объект внутри класса необходимо явно удалить (например, при вызове метода, например Node::destroySelfReference(), который можно легко забыть. В противном случае объект может жить вечно со ссылкой на себя.

  • Все классы получают слабые указатели

    • хорошо: нам просто нужно скопировать слабый указатель, а не делиться владельцем
    • плохо: каждый раз, когда мы хотели получить доступ к узлу из точки, нам нужно было позвонить lock(). А поскольку ссылка в Point на самом деле не используется в качестве наблюдателя, а используется как общая ссылка, она устарела.

Вопрос

Что было бы лучшим решением здесь? И какова их реальная опасность?

Код 

/* Using boost 1.53 */
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/weak_ptr.hpp>

using boost::shared_ptr;
using boost::make_shared;
using boost::weak_ptr;
using std::cout;
using std::endl;

/*-------------Classes-----------*/

class Point;

class Node {
private:
    std::vector<Point *> points;
    weak_ptr<Node> weakThis;
public:
    int value;
    Node(Point * p, shared_ptr<Node> & sp);
    void add(Point * p);
    void remove(Point * p);
    int getValue() {
        return this->value;
    }
};

class Point {
private:
    int value;
public:
    shared_ptr<Node> node;
    Point() : value(2) {}
    ~Point() {
        if(this->node != NULL) {
            this->node->remove(this);
        }
    }
    int getValue() {
        if (this->node == NULL) return this->value;
        else {
            return this->node->getValue();
        }
    }
};

/*----------Node definition------------*/

Node::Node(Point * p, shared_ptr<Node> & sp) : value(1) {
    sp.reset(this);
    this->weakThis = sp;
    this->add(p);
}

void Node::add(Point * p) {
    this->points.push_back(p); /* simplified without checking if element exists since it is unnecessary for the problem */
    p->node = this->weakThis.lock(); /* <- critical part */
}

void Node::remove(Point * p) {
    std::vector<Point *>::iterator it = std::find(this->points.begin(), this->points.end(), p);
    if (it != this->points.end()) {
        Point * pr = *it;
        this->points.erase(it);
        pr->node.reset();
    }
}

/*------------main-----------*/

int main() {
    Point p;
    cout << "Value of unmanaged p is " << p.getValue() << endl;
    shared_ptr<Node> n;
    new Node(&p, n); /* This is a bit strange too but other creations will not work */
    cout << "Added p to n" << endl;
    cout << "Value of managed p is " << p.getValue() << endl;

    n->remove(&p);
    n.reset();
    return 0;
}
...