将在函数中创建的对象分配给成员变量

Question

所以我对 C++ 以及随之而来的所有内存管理还很陌生。

我的问题是我在函数 expand 中创建了一个对象，然后将所述对象分配给同一个 class 的另一个对象中的成员变量（class 是一个二叉树，它的数据是一个 InVec 对象）。

函数运行后，m_left和m_right的内存位置为给定的SPnode 相同，但是取消引用的值是垃圾。

我几乎可以肯定这是由于 InVec 和 SPnode 对象超出范围并被销毁，从而产生指针 m_left 和 m_right 指向垃圾。

我的问题是：如何在函数内创建一个对象，将其分配给一个成员变量，并且在函数终止时不销毁它？我确定我遗漏了一些明显的东西，但我无法在任何地方找到答案（我什至不确定如何措辞）。

这是我的代码：

void expand(SPnode &ASP)
{
    if (!(ASP.isLeaf())) return;

    int axis(ASP.m_box.getWidthAxis());
    Interval width(ASP.m_box.getWidth());

    InVec lowerInVec(lower(ASP.m_box, width, axis));
    InVec upperInVec(upper(ASP.m_box, width, axis));


    SPnode leftChild(lowerInVec);
    std::cout << &leftChild << "\n";

    SPnode rightChild(upperInVec);
    std::cout << &rightChild << "\n";


    ASP.m_left = &leftChild;
    std::cout << (ASP.m_left) << "\n";

    ASP.m_right = &rightChild;
    std::cout << (ASP.m_right) << "\n";
}

如果此代码格式不正确或我违反了一些重要规则，我深表歉意 - 任何建设性的批评也将不胜感激。

编辑：这是 Interval、InVec 和 SPnode 的相关代码：

// The Interval class is the base object on which all other classes in this
// module are built. Its implementation is intuitive, as all mathematical
// operations that are relevant for nonlinear image computation are given
// as overloaded operators (i.e. intervalA + intervalB returns the expected
// result from basic interval arithmetic).
class Interval
{
private:

    // infimum (lower bound) of interval
    double m_inf;

    //supremum (upper bound) of interval
    double m_sup;

public:
    Interval(double inf, double sup): m_inf(inf), m_sup(sup) {}

    // getter member functions, where getLen returns the length of the interval
    // and getMidpt returns the midpoint
    double getInf() const {return m_inf;}
    double getSup() const {return m_sup;}
    double getLen() const {return m_sup - m_inf;}
    double getMidpt() const {return (m_inf + m_sup)/2.0;}


// --- Headers -----------------------------------------------------------------

    // determines if a double is in the interval
    bool containsVal(double val) const;

    // determines if another interval is contained in the interval
    bool contains(const Interval &other) const;

    // performs scalar multiplication on the interval
    Interval scalarMul(double scal) const;


    // operator overloading - the specifics of interval arithmetic can be found
    // in a book or online
    friend Interval operator+(const Interval &intA, const Interval &intB);
    friend Interval operator-(const Interval &intA, const Interval &intB);
    friend Interval operator*(const Interval &intA, const Interval &intB);
    friend bool operator==(const Interval &intA, const Interval &intB);
    friend bool operator!=(const Interval &intA, const Interval &intB);
    friend std::ostream& operator<< (std::ostream &out, const Interval &intA);


    friend void expand(SPnode &ASP);
    friend InVec lower(const InVec &box, const Interval &width, int axis);
    friend InVec upper(const InVec &box, const Interval &width, int axis);
};

class InVec
{
private:

    // this is a vector containing the Interval objects that make up the InVec 
    // object
    std::vector<Interval> m_intervals;

public:

    InVec(std::vector<Interval> intervals): m_intervals(intervals) {}

    // returns m_intervals
    std::vector<Interval> getIntervals() const {return m_intervals;}

    // returns the interval at given axis (i.e. index) in m_intervals
    Interval getInterval(int axis) const {return m_intervals.at(axis);}

    // sets the interval at given axis to given Interval object
    void setInterval(int axis, const Interval &intA)
    {m_intervals.at(axis) = intA;}


// --- Headers -----------------------------------------------------------------

    // determines if another InVec object is contained in this InVec object
    bool contains(const InVec &IVB) const;

    // returns the length of the largest Interval object in m_intervals - note
    // that it is necessary to compute this first, before the actual largest
    // Interval can be determined
    double getWidthSize() const;

    // returns the Interval in m_intervals with the longest length 
    // (i.e. the width)
    Interval getWidth() const;


    // returns the axis (i.e. index) on which the width occurs
    double getWidthAxis() const;


    // operator overloading
    friend InVec operator+(const InVec &IVA, const InVec &IVB);
    friend InVec operator-(const InVec &IVA, const InVec &IVB);
    friend InVec operator*(const InVec &IVA, const InVec &IVB);
    friend bool operator==(const InVec &intA, const InVec &intB);
    friend bool operator!=(const InVec &intA, const InVec &intB);
    friend std::ostream& operator<< (std::ostream &out, const InVec &IVA);


    friend void expand(SPnode &ASP);
    friend InVec lower(const InVec &box, const Interval &width, int axis);
    friend InVec upper(const InVec &box, const Interval &width, int axis);

};

class SPnode
{
private:

    InVec m_box;

    // left and right children of this SPnode object - note that these must be
    // pointers in order to use them in the definition of the class, otherwise 
    // SPnode would have an inifinite definition
    SPnode* m_left;
    SPnode* m_right;

public:

    SPnode(InVec box): m_box(box), m_left(NULL), m_right(NULL) {}


    // getters and setters
    InVec getBox() const {return m_box;}
    SPnode* getLeft() const {return m_left;}
    SPnode* getRight() const {return m_right;}
    void setBox(const InVec box) {m_box = box;}
    void setLeft(SPnode* const p_node) {m_left = p_node;}
    void setRight(SPnode* const p_node) {m_right = p_node;}

    bool isLeaf() const;

    friend std::ostream& operator<< (std::ostream &out, const SPnode &ASP);
    friend void expand(SPnode &ASP);
    friend InVec lower(const InVec &box, const Interval &width, int axis);
    friend InVec upper(const InVec &box, const Interval &width, int axis);  
};

Answer 1

您将必须动态分配您的节点。而且您需要使用智能指针管理该内存 - 最有可能的是 std::unique_ptr.

你的代码应该是这样的：

ASP.m_left = std::make_unique<SPnode>(lowerInVec);

这表明 SPNode 构造函数不会尝试保留对其参数的引用（或地址）。如果是这样，则也必须动态分配所述参数。

Answer 2

您应该将您的孩子创建为指针并使用 new 运算符动态分配它们，如下所示：

SPnode * leftChild = new SPnode(lowerInVec);

并将其分配给 object 成员变量，如下所示：

ASP.m_left = leftChild;

您还应该将 m_left 声明为 SPnode 指针，如下所示：

SPNode * m_left;

对右边的做同样的事情。

Ps.: 在理解智能指针之前你应该先理解指针，指针是使用new运算符分配的。

将在函数中创建的对象分配给成员变量

Assigning object created in function to member variable

c++

scope

object

member