Cross references when using template parameters

Question

I usually know how to deal with cross references, but here i'm stuck.

Let a smart pointer class :

template< typename T >
SharedPointer
{
    T * _ptr;
};

And :

class Array;

class Value
{
    SharedPointer< Array > _pa;
};

And :

class Array
{
    Value someFunc();
}

Here i'm having warnings in the SharedPointer class saying that i'm deleting pointers to incomplete type objects, which I guess is due to the forward declaration.

Warning 2   warning C4150: deletion of pointer to incomplete type 'script::Array'; no destructor called c:\XXXXX\SharedPointer.h    77

What could i do to solve this ? The only solution i see is rewriting the whole SharedPointer class to something like :

template< typename pT >
SharedPointer
{
    pT _ptr;
};

And use it like this instead :

SharedPointer< Array * >

I would like to avoid rewriting this class if possible. Is there another solution ? Thank you :)

EDIT: Here is the real source code :

class Value
{
    PUBLIC enum type_e
    {
        E_NULL,

        E_INT,

        E_FLOAT,

        E_STRING,

        E_ARRAY,

        E_MAP,

        E_FUNCTION,

        E_REFERENCE // TODO For functions like fn( scalar & val )
    };

    PRIVATE union
    {
        int _i;

        float _f;

        std::string * _ps;

        IFunction * _pf;
    };

    PRIVATE SharedPointer< Array > _pa;

    PRIVATE SharedPointer< Map > _pm;

    PRIVATE SharedPointer< Value > _ref;

    PRIVATE type_e _type;

    PUBLIC Value();

    PUBLIC Value( bool b );

    PUBLIC Value( int i );

    PUBLIC Value( float f );

    PUBLIC Value( const std::string & s );

    PUBLIC Value( SharedPointer< Array > pa );

    PUBLIC Value( SharedPointer< Map > pm );

    PUBLIC Value( IFunction * pf );

    PUBLIC Value( SharedPointer< Value > ref );

    PUBLIC Value( const Value & v );

    PUBLIC ~Value() { }

    PUBLIC Value operator + ( const Value & v ) const;

    PUBLIC Value operator - ( const Value & v ) const;

    PUBLIC Value operator * ( const Value & v ) const;

    PUBLIC Value operator / ( const Value & v ) const;

    PUBLIC Value operator % ( const Value & v ) const;

    PUBLIC Value operator ^ ( const Value & v ) const;

    PUBLIC Value operator << ( const Value & v ) const;

    PUBLIC Value operator - () const;

    PUBLIC Value operator && ( const Value & v ) const;

    PUBLIC Value operator || ( const Value & v ) const;

    PUBLIC Value xor( const Value & v ) const;

    PUBLIC Value operator ! () const;

    PUBLIC Value & operator = ( const Value & v );

    PUBLIC Value operator () ( Scope & scope, const std::vector< Value > & args ) const;

    PUBLIC Value & getRef( const Value & v ) const;

    PUBLIC Value getCpy( const Value & v ) const;

    PUBLIC inline type_e getType() const throw() { return _type; }

    PUBLIC inline bool isNull() const throw() { return E_NULL == _type; }

    PUBLIC inline bool isInt() const throw() { return E_INT == _type; }

    PUBLIC inline bool isFloat() const throw() { return E_FLOAT == _type; }

    PUBLIC inline bool isString() const throw() { return E_STRING == _type; }

    PUBLIC inline bool isArray() const throw() { return E_ARRAY == _type; }

    PUBLIC inline bool isMap() const throw() { return E_MAP == _type; }

    PUBLIC inline bool isFunction() const throw() { return E_FUNCTION == _type; }

    PUBLIC inline bool isReference() const throw() { return E_REFERENCE == _type; }

    PUBLIC inline bool isNumeric() const throw() { return E_INT == _type || E_FLOAT == _type; }

    PUBLIC type_e toNumeric( int & asInt, float & asFloat ) const;

    PUBLIC std::string toString() const;

    PUBLIC operator bool () const throw();
};

class Array
{
    PRIVATE std::vector< Value > _items;

    PUBLIC Array( const std::vector< Value > & items );

    PUBLIC ~Array();

    PUBLIC Value & getRef( int index );

    PUBLIC Value getCpy( int index ) const;

    PUBLIC int getSize() const;
};


template< typename T >
class SharedPointer
{
    template< typename U >
    friend class SharedPointer;

    PRIVATE T * p;

    PRIVATE size_t * c;

    PUBLIC SharedPointer()
      : p()
      , c() { }

    PUBLIC explicit SharedPointer( T * s )
      : p( s )
      , c( new size_t( 1 ) ) { }

    PUBLIC SharedPointer( const SharedPointer & s )
      : p( s.p )
      , c( s.c )
    {
        if( this->c )
        {
            ++*(this->c);
        }
    }

    PUBLIC SharedPointer & operator = ( const SharedPointer & s )
    {
        if( this != & s )
        {
            this->clear();

            this->p = s.p;
            this->c = s.c;

            if( this->c )
            {
                ++*(this->c);
            }
        }
        return *this;
    }

    PUBLIC template< typename U >
    SharedPointer( const SharedPointer< U > & s )
      : p( s.p )
      , c( s.c )
    {
        if( c )
        {
            ++*(this->c);
        }
    }

    PUBLIC ~SharedPointer()
    {
        this->clear();
    }

    PUBLIC void clear() 
    { 
        if( this->c )
        {
            if( *(this->c) == 1 )
            {
                delete this->p;
            }
            if( ! --*(this->c) )
            {
                delete this->c;
            }
        }

        this->c = NULL;
        this->p = NULL;
    }

    PUBLIC T * get() const
    {
        return this->c ? this->p : NULL;
    }

    PUBLIC T * operator -> () const
    {
        return this->get();
    }

    PUBLIC T & operator * () const
    {
        return *(this->get());
    }
};

Answer 1

The problem is that since Value doesn't have a destructor, the default destructor is created for you. Since it ends up being defined inline, in the class definition, you end up deleting an incomplete type. In other words, it is as if you had written this in your header file:

class Value
{
    SharedPointer< Array > _pa;
    ~Value() { //This will end up calling the destructor for `_pa`. To do that, if needs `Array` to be a completely defined type. }
};

Make the destructor explicit and move it to the cpp file. Note that you can use the default keyword for definitions occurring outside the class as well.