QGuardedPtr - Template class that provides guarded
       pointers to QObjects

       #include <qguardedptr.h>

   Public Members
       QGuardedPtr ()
       QGuardedPtr ( T * p )
       QGuardedPtr ( const QGuardedPtr<T> & p )
       ~QGuardedPtr ()
       QGuardedPtr<T>& operator= ( const QGuardedPtr<T> & p )
       QGuardedPtr<T>& operator= ( T * p )
       bool operator== ( const QGuardedPtr<T> & p ) const
       bool operator!= ( const QGuardedPtr<T> & p ) const
       bool isNull () const
       T* operator-> () const
       T& operator* () const
       operator T* ()const


DESCRIPTION

       The QGuardedPtr class is a template class that provides
       guarded pointers to QObjects

       A guarded pointer, QGuardedPtr<X>, behaves like a normal
       C++ pointer X*, except that it is automatically set to
       null when the referenced object is destroyed, unlike
       normal C++ pointers which become "dangling pointers" in
       that case. X must be a subclass of QObject.

       Guarded pointers are useful whenever you need to store a
       pointer to a QObject that is owned by someone else and
       therefore might be destroyed while you still keep a
       reference to it. You can safely test the pointer for
       validity.

       Example:

             QGuardedPtr<QFrame> label = new QLabel( 0,"label" );
             label->setText("I like guarded pointers");
             delete (QLabel*) label; // emulate somebody destroying the label
             if ( label)
                 label->show();
             else
                 qDebug("The label has been destroyed");

       The program will output

             The label has been destroyed

       rather than dereferencing an invalid address in
       label->show().

       are the same as those available with a normal unguarded
       pointer, except the pointer arithmetic operators, ++, --,
       -, and +, which are normally only used with arrays of
       objects. Use them like normal pointers and you will not
       need to read this class documentation.

       For creating guarded pointers, you can construct or assign
       to them from an X* or from another guarded pointer of the
       same type. You can compare them with each other for
       equality (==) and inequality (!=), or test for null with
       isNull(). Finally, you can dereference them using either
       the *x or the x->member notation.

       A guarded pointer will automatically cast to an X* so you
       can freely mix guarded and unguarded pointers. This means
       that if you have a QGuardedPtr<QWidget>, then you can pass
       it to a function that requires a QWidget*. For this
       reason, it is of little value to declare functions to take
       a QGuardedPtr as a parameter - just use normal pointers.
       Use a QGuardedPtr when you are storing a pointer over
       time.

       Note again that class X must inherit QObject or a
       compilation or link error will result.


MEMBER FUNCTION DOCUMENTATION


QGuardedPtr::QGuardedPtr ()

       Constructs a null guarded pointer.

       See also isNull().


QGuardedPtr::QGuardedPtr ( T * p )

       Constructs a guarded pointer that points to same object as
       is pointed to by p.


QGuardedPtr::QGuardedPtr ( const QGuardedPtr & p )

       Copy one guarded pointer from another. The constructed
       guarded pointer points to the same object that p pointed
       to (possibly null).


QGuardedPtr::~QGuardedPtr ()

       Destructs the guarded pointer. Note that the object
       pointed to by the pointer is not destructed, just as is
       the case with a normal unguarded pointer.


QGuardedPtr::operator T* () const

       Cast operator, implements pointer semantics. Because of
       this function, you can pass a QGuardedPtr<X> to a function
       where an X* is required.


bool QGuardedPtr::isNull () const

       Returns TRUE if the referenced object has been destroyed
       or if there is no referenced object.

       Unequality operator, implements pointer semantics, the
       negation of operator==().


T& QGuardedPtr::operator* () const

       Dereference operator, implements pointer semantics. Just
       use this operator as you would with a normal C++ pointer.


T* QGuardedPtr::operator-> () const

       Overloaded arrow operator, implements pointer semantics.
       Just use this operator as you would with a normal C++
       pointer.


QGuardedPtr & QGuardedPtr::operator= ( T * p )

       Assignment operator. This guarded pointer then points to
       same object as is pointed to by p.


QGuardedPtr& QGuardedPtr::operator= ( const QGuardedPtr & p

       )
       Assignment operator. This guarded pointer then points to
       the same object as does p.


bool QGuardedPtr::operator== ( const QGuardedPtr & p ) const

       Equality operator, implements traditional pointer
       semantics: returns TRUE if both p and this are null, or if
       both p and this point to the same object.

       See also  operator!=().


SEE ALSO

       http://doc.trolltech.com/qguardedptr.html
       http://www.trolltech.com/faq/tech.html


COPYRIGHT

       Copyright 1992-2001 Trolltech AS,
       http://www.trolltech.com.  See the license file included
       in the distribution for a complete license statement.


AUTHOR

       Generated automatically from the source code.


BUGS

       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.  Good bug reports
       make our job much simpler. Thank you.

       In case of content or formattting problems with this
       manual page, please report them to qt-bugs@trolltech.com.
       Please include the name of the manual page
       (qguardedptr.3qt) and the Qt version (2.3.1).


Man(1) output converted with man2html