Why does this Object wonk out & get deleted ?

Question

Stepping through the debugger, the BBox object is okay at the entry of the function, but as soon as it enters the function, the vfptr object points to 0xccccc. I don't get it.

1. What is causing this ?
2. Why is there a virtual table reference in there when the object is not derived from other class. (Though, it resides in GameObject from which my Player class inherits and I retrieve the BBox from within player. But, why does the BBox have the reference ? Shouldn't it be player who should be maintained in that reference ?)

For 1; some code for reference:

A. I retrieve the bounding box from player. This returns a bounding box as expected. I then send its address to GetGridCells.

 const BoundingBox& l_Bbox = l_pPlayer->GetBoundingBox();

 boost::unordered_set < Cell*, CellPHash >& l_GridCells = GetGridCells ( &l_Bbox ); 

B. This is where a_pBoundingBox goes crazy and gets that garbage value.

 boost::unordered_set< Cell*, CellPHash > CollisionMgr::GetGridCells(const BoundingBox *a_pBoundingBox)
 {

I think the following code is also pertinent, so I'm sticking this in here anyways:

 const BoundingBox& Player::GetBoundingBox(void)
 {
 return BoundingBox( &GetBoundingSphere() );
 }

 const BoundingSphere& Player::GetBoundingSphere(void)
 {
 BoundingSphere& l_BSphere = m_pGeomMesh->m_BoundingSphere;

 l_BSphere.m_Center = GetPosition();

 return l_BSphere;
 }

 // BoundingBox Constructor
 BoundingBox(const BoundingSphere* a_pBoundingSphere);

Can anyone please give me some idea as to why this is happening? Also, if you want me to post more code, please do let me know.

Thanks!

Answer 1

 const BoundingBox& Player::GetBoundingBox(void)
 {
 return BoundingBox( &GetBoundingSphere() );
 }

Here, you're returning a reference to a temporary BoundingBox object. That object goes out of scope as soon as the return statement ends.

Return a BoundingBox instead of a BoundingBox& instead.

---

Also:

 BoundingSphere& l_BSphere = m_pGeomMesh->m_BoundingSphere;

 l_BSphere.m_Center = GetPosition();

Here, you take a reference to the bounding sphere of the m_pGeomMesh, then modify the value it refers to. This will result in a modification of the original object. Are you sure this is what you want?

---

Also:

 // BoundingBox Constructor
 BoundingBox(const BoundingSphere* a_pBoundingSphere);

In the only place where using a reference makes a great deal of sense, you use a pointer instead. Why?

Answer 2

1. As Thomas says, the BoundingBox is created by the return statement and destroyed at the end of the return statement, because it is a temporary. Returning a const reference isn't the same as assigning to a persistent const reference (which does prolong a temporary). Returning a value and assigning it to something in the caller's scope has no overhead due to copy elision, although you might have to define a copy constructor.
2. The vtable is created if the class has any virtual methods, such as the destructor. If you had derived classes which overrided those methods, the base vtable would be required to find the correct override. All that can happen in another compilation unit so the compiler is unlikely to optimize it out.

Answer 3

@Thomas: Here are m classes:

#ifndef BOUNDINGBOX_H
#define BOUNDINGBOX_H

class BoundingSphere;

class BoundingBox
{
public:

    BoundingBox(const BoundingSphere* a_pBoundingSphere);
    //BoundingBox( const BoundingBox& rhs);
    virtual ~BoundingBox(void);

    const std::vector< glm::vec3 > GetCorners() const;

    glm::vec3 m_Center;
    glm::vec3 m_Extents;        // extents along the X, Y, Z axis for the bounding box positioned at the center
};

#endif

---

#ifndef BOUNDINGSPHERE_H
#define BOUNDINGSPHERE_H

class BoundingBox;

class BoundingSphere
{
public:
    BoundingSphere();

BoundingSphere(const BoundingBox* a_pBoundingBox);

    BoundingSphere(const glm::vec3& a_Center, const float& a_Radius);
    virtual ~BoundingSphere(void);

    // Access the Center
    const glm::vec3 &GetCenter(void) const  { return(m_Center);     };
    void SetCenter(const glm::vec3 &Center) { m_Center = Center;    };

    // Access the Radius
    float GetRadius(void) const     { return(m_Radius);     };
    void SetRadius(float Radius)    { m_Radius = Radius;    };

    glm::vec3 m_Center;
    float m_Radius;
};

#endif

---

Now, the way I understand this is: If in the constructor of BoundingBox has a reference to BoundingSphere instead of a pointer, i.e.

BoundingBox(const BoundingSphere& a_pBoundingSphere);

It would require the definition of BoundingSphere to be available at the time it compiles. Thus, I'll have to include BoundingSphere.h in BoundingBox.h to make the definition available. This holds true for vice versa, and thereby creates cyclic references.

Please correct me on this..

Thanks