Question

代码非常简单，由不同类的嵌套类似方法调用组成，但程序在随机场合保持segfaulting（总是在Add方法中）。

我在类CScreen实例上调用方法Add来添加一个对象CCircle，它被克隆（创建一个新实例）并且指针被分层传递，直到它到达xnode（我自己的列表节点实现）。

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) { ...
            ...
    }

我认为它可能是一个堆栈溢出，因为开销很高，但它有时会在第一次调用时出现段错误。 xlist和xnode实现完美无缺，直到我实现了Qlist。

我传递了const指针引用，然后将其复制到xnode中的构造函数中。问题可能存在吗？我试着用gdb调试，没有运气。

通过嵌套调用将指针传递给新对象

0 个答案: