Trouble with destructors in class

void read_poly( Poly & p )
{
    Term t;
    char ch, var;
    int coef, exp;
    while ( ( ch = cin.get() ) && ( ch != '\n' ) )
    {
        if ( ch == '+' )
        {
            cin >> coef >> var >> exp;
            t.set ( coef, var, exp );
            p += t;
        }
        else if ( ch == '-' )
        {
            cin >> coef >> var >> exp;
            t.set ( -1 * coef, var, exp );
            p += t;
        }
    }
}

// input: A Term t
// output: none
// return: returns a pointer to this
// notes: This function assigns the polynomial the term that was  sent to it.  However, the term that is written to the polynomial overwrites the old term that was stored in the poly(this).

Poly Poly::operator+= (const Term &t)
{
    if(this->used < this->size)
    {
        *this[used].terms = t;  //assigns this the value of t's items
                               // ((doesnt work as expected))
        this->used++;    //increases the amount of terms used
    }
    else
    {
        grow(*this);      //grow the array to a larger size
       *this->terms = t; //same as above
        this->used++;
    }

return *this;
}

 
// input: The Polynomial P gets passed to this function
// output: none
// return: a new array with a new size to allow more elements to be put in
// notes: This function takes an array and expands it by 5 and
//        deletes the old array

Poly *grow(Poly &p)
{
    int newsize = p.size + 5;    //declaring new size of old size + 5
    Poly *narr = new Poly[newsize];//allocates new memory location of newsize
    for(int i = 0;i < p.size;++i)//loop to assigne values
        narr[i] = p;
    cerr << "eh?";
    delete [] &p; //delete old array -- does not work - causes seg fault
    narr->size = newsize;
    return narr;
}

/////////////////////////////
///Polynomial class definition
//////////////////////////////
class Poly
{
    public:
        Poly(void);     //constructor
        ~Poly(void);    //destructor
        Poly(const Poly &p);
        friend class Term;
        void copy(const Poly &p);  //copy values
        friend Poly *grow(Poly &p);
        Poly operator+= (const Term &t);
        Poly operator+ (const Poly &p)const;
        Poly operator- (const Poly &p)const;
        Poly operator* (const Poly &p)const;
        Poly operator= (const Poly &p);
        friend ostream& operator<< (ostream &streamout, const Poly &p);
       


    private:
        Term * terms;   //Term values
        int used;      //terms in use
        int size;     //size of poly array
};
 

 
///////////////////////
/////Term class definition
//////////////////////
class Term
{
    friend class Poly;
    public:
        Term(void);
        int getcoef(void)const;
        int getexp(void)const;
        char getvar(void)const;
        void set(int = 0, char = 'x', int = 0);
        friend ostream& operator<< (ostream &streamout, const Term &t);
    private:
        int coef;
        char var;
        int exp;
};