关于类的一个小问题

Question

有一个类Class IPtr
{... 一些成员函数
...IY* oprator=(...)
{
...
}//重载了"="IY* m_P;// 一个数据成员};程序中:...
IPtr a;
a=b;
if(a)//这里是什么意思?
{
...
}
...

Answer 1

if(a)//这里是什么意思?
＝＝＝＝＝＝＝＝
应该是判断a是不是NULL吧

Answer 2

谢谢!
请问
什么时候a==null?
这里的null是与a的什么在进行比较?

Answer 3

呵呵,这个是<com技术内幕>中的一个例子,iptr是一个智能指针类,有点看不懂

Answer 4

//
// Ptr.h
//   - Smart interface pointer
//
#include <assert.h>//
// IPtr - Smart Interface Pointer
//   Use:  IPtr<IX, &IID_IX> spIX ;
//   Do not use with IUnknown; IPtr<IUnknown, &IID_IUnknown>
//     will not compile.  Instead, use IUnknownPtr.
//
template <class T, const IID* piid> class IPtr
{
public:
// Constructors
IPtr() 
{
m_pI = NULL ;
} IPtr(T* lp)
{
m_pI = lp ;
if ( m_pI != NULL)
{
m_pI->AddRef() ;
}
} IPtr(IUnknown* pI)
{
m_pI = NULL ;
if (pI != NULL)
{
pI->QueryInterface(*piid, (void **)&m_pI) ;
}
} // Destructor
~IPtr() 
{
Release() ;
} // Reset
void Release()
{
if (m_pI != NULL)
{
T* pOld = m_pI ;
m_pI = NULL ;
pOld->Release() ;
}
} // Conversion
operator T*() { return m_pI ;} // Pointer operations
T& operator*()  { assert(m_pI != NULL) ; return *m_pI ;}
T** operator&() { assert(m_pI == NULL) ; return &m_pI ;}
T* operator->() { assert(m_pI != NULL) ; return m_pI ;} // Assignment from the same interface
T* operator=(T* pI)
{
if (m_pI != pI)
{
IUnknown* pOld = m_pI ;    // Save current value.
m_pI = pI ;                // Assign new value.
if (m_pI != NULL)
{
m_pI->AddRef() ;
}
if (pOld != NULL)
{
pOld->Release() ;       // Release the old interface.
}
}
return m_pI ;
} // Assignment from another interface
T* operator=(IUnknown* pI)
{
IUnknown* pOld = m_pI ;       // Save current value.
m_pI == NULL ; // Query for correct interface.
if (pI != NULL)
{
HRESULT hr = pI->QueryInterface(*piid, (void**)&m_pI) ;
assert(SUCCEEDED(hr) && (m_pI != NULL)) ;
} if (pOld != NULL)
{
pOld->Release() ;         // Release old pointer.
}
return m_pI ;
} // Boolean functions
BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE ;} // Requires a compiler that supports BOOL
operator BOOL() const
{ 
return (m_pI != NULL) ? TRUE : FALSE ; 
} // GUID
const IID& iid() { return *piid ;}private:
// Pointer variable
T* m_pI ;
} ;
//
// IUnknownPtr is a smart interface for IUnknown.
//
class IUnknownPtr
{
public:
// Constructors
IUnknownPtr() 
{
m_pI = NULL ;
} IUnknownPtr(IUnknown* lp)
{
m_pI = lp ;
if ( m_pI != NULL)
{
m_pI->AddRef() ;
}
} // Destructor
~IUnknownPtr() 
{ 
Release() ; 
} // Reset
void Release() 
{
if (m_pI)
{
IUnknown* pOld = m_pI ;
m_pI = NULL ;
pOld->Release() ;
}
} // Conversion
operator IUnknown*() { return (IUnknown*)m_pI ;} // Pointer operations
IUnknown& operator*()  { assert(m_pI != NULL) ; return *m_pI ;}
IUnknown** operator&() { assert(m_pI == NULL) ; return &m_pI ;}
IUnknown* operator->() { assert(m_pI != NULL) ; return m_pI ;} // Assignment
IUnknown* operator=(IUnknown* pI)
{
if (m_pI != pI)
{
IUnknown* pOld = m_pI ;      // Save current value.
m_pI = pI ;                  // Assign new value.
if (m_pI != NULL)
{
m_pI->AddRef() ;
}
if (pOld != NULL)            // Release the old interface.
{
pOld->Release() ;
}
}
return m_pI ;
} // Boolean functions
BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE ;} operator BOOL() const
{ 
return (m_pI != NULL) ? TRUE : FALSE ; 
}private:
// Pointer variable
IUnknown* m_pI ;
} ;

Answer 5

恐怕还是判断一下是不是NULL吧

Answer 6

问题是它这个null指的是什么呢?
iptr没有实现比较运算符的重载呀,它是如何与null比较的?

Answer 7

if (a != NULL)if (a ==NULL)非零即为真！if ( a != 0)

Answer 8

它重载了布尔方法啊, 当然可以这样用了...// Boolean functions
    BOOL operator!() { return (m_pI == NULL) ? TRUE : FALSE ;}    // Requires a compiler that supports BOOL
    operator BOOL() const
    { 
        return (m_pI != NULL) ? TRUE : FALSE ; 
    }