C++ 通过嵌套调用传递指向新对象的指针

代码非常简单，由不同类上嵌套的类似方法调用组成，但是程序在Add方法期间始终在随机情况下保持segfaulting

我调用方法Add on类CScreen instance来添加一个对象CCircle，该对象将被克隆。创建一个新实例，并按层次传递指针，直到它到达xnode我自己的list node实现

int main (){
  CScreen S1;
  S1 . Add ( CCircle ( 3, 20, 20, 15 ) );
}

class CScreen {
  public:
    Qlist <Planimetric*> objects;

    void Add (const Planimetric & ob ) {
        objects.push_back( ob.clone() ); // returns pointer to new instance
        }
    ...

template<typename _Type>
class Qlist{
  public:
    Qnode <_Type> *start;

    Qlist() : start(null) {
        start = new Qnode<_Type>(-coordInfinity, -coordInfinity, coordInfinity, coordInfinity);
    }

    void push_back (const _Type & data) {
        start->push_back(data);
        }
    ...

template<typename _Type>
struct Qnode{
    xlist <_Type> objects;

    void push_back (const _Type & data) {
        objects.push_back(data);
        }
    ...

template<typename _Type>
class xlist{
  public:
    int sizeOfList;
    xnode<_Type> *first, *last;

    void push_back (const _Type & data) {
        sizeOfList ++;
        xnode<_Type> *nnp; // new node pointer ;)
        if(first == null)
            first = last = new xnode<_Type> (data);
         else
             last = last->next = nnp = new xnode<_Type>(data, last);
        }
    ...

template<typename _Type>
struct xnode{
    _Type data;
    xnode *prev, *next;
    xnode(const _Type & data, xnode* prev = null, xnode* next = null)
        : data(data), prev(prev), next(next) {}
    ...

class CCircle : public Planimetric {
  public:
    long long int x,y;
    long long int rsq;

    CCircle * clone () const {return new CCircle(*this);}

    CCircle (int ID, int x, int y, int r) : Planimetric(ID), x(x), y(y) { ...
            ...
    }

我认为这可能是由于高开销造成的堆栈溢出，但有时在第一次调用时会出现错误。在我实现Qlist之前，xlist和xnode的实现工作得非常好

---

我传递常量指针引用，然后将其复制到xnode的构造函数中。有问题吗？我尝试过使用gdb进行调试，但没有成功。

您尝试过valgrind吗？克隆是否在Planimetric中声明为虚拟？否则这可能会导致切片。是的，它是虚拟的：虚拟平面*克隆常数=0；是的，我试过valgrind，但没有成功