ATL Internals 2ed复习.chapter 3.CComSafeArray

最新推荐文章于 2022-01-22 13:17:29 发布
原创 最新推荐文章于 2022-01-22 13:17:29 发布 · 754 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了CComSafeArray类的使用方法，包括构造函数、析构函数、赋值操作及Attach/Detach方法等。此外，还讲解了如何进行多维数组的操作以及一些重要的注意事项。 
template <typename T,                               
    VARTYPE _vartype = _ATL_AutomationType<T>::type>
class CComSafeArray {                               
  ...                                               
public:                                             
     LPSAFEARRAY m_psa;                             
}


m_psa是CComSafeArray唯一的state

 
#define DEFINE_AUTOMATION_TYPE_FUNCTION(ctype,
 typewrapper, oleautomationtype) \            
    template <> \                             
    struct _ATL_AutomationType<ctype> { \     
    typedef typewrapper _typewrapper;\        
    enum { type = oleautomationtype }; \      
    static void* GetT(const T& t) { \         
        return (void*)&t; \                   
    } \                                       
};

DEFINE_AUTOMATION_TYPE_FUNCTION用于将C++类型转换成VARTYPE

DEFINE_AUTOMATION_TYPE_FUNCTION(CHAR, CHAR, VT_I1)               
DEFINE_AUTOMATION_TYPE_FUNCTION(SHORT, SHORT, VT_I2)             
DEFINE_AUTOMATION_TYPE_FUNCTION(INT, INT, VT_I4)                 
DEFINE_AUTOMATION_TYPE_FUNCTION(LONG, LONG, VT_I4)               
DEFINE_AUTOMATION_TYPE_FUNCTION(LONGLONG, LONGLONG, VT_I8)       
DEFINE_AUTOMATION_TYPE_FUNCTION(BYTE, BYTE, VT_UI1)              
DEFINE_AUTOMATION_TYPE_FUNCTION(USHORT, USHORT, VT_UI2)          
DEFINE_AUTOMATION_TYPE_FUNCTION(UINT, UINT, VT_UI4               
DEFINE_AUTOMATION_TYPE_FUNCTION(ULONG, ULONG, VT_UI4)            
DEFINE_AUTOMATION_TYPE_FUNCTION(ULONGLONG, ULONGLONG, VT_UI8)    
DEFINE_AUTOMATION_TYPE_FUNCTION(FLOAT, FLOAT, VT_R4)             
DEFINE_AUTOMATION_TYPE_FUNCTION(DOUBLE, DOUBLE, VT_R8)           
DEFINE_AUTOMATION_TYPE_FUNCTION(DECIMAL, DECIMAL, VT_DECIMAL)    
DEFINE_AUTOMATION_TYPE_FUNCTION(VARIANT, CComVariant, VT_VARIANT)
DEFINE_AUTOMATION_TYPE_FUNCTION(CY, CY, VT_CY)


于是_ATL_Automation_Type<long>::type＝VT_I4

 

Constructors and Destructor

template只是确定array的元素类型，还需要确定维数和各维的size
有7个不同的构造函数用于这个工作，除了第一个Default无参构造函数外（m_psa=NULL），其余的函数都将使用到CComSafeArrayBound用于确定这些细节：
class CComSafeArrayBound : public SAFEARRAYBOUND {             
    CComSafeArrayBound(ULONG ulCount = 0, LONG lLowerBound = 0)
    { ... }                                                    
    CComSafeArrayBound&                                        
    operator=(const CComSafeArrayBound& bound)                 
    { ... }                                                    
    CComSafeArrayBound& operator=(ULONG ulCount) { ... }       
    ULONG GetCount() const  { ... }                            
    ULONG SetCount(ULONG ulCount)  { ... }                     
    LONG GetLowerBound() const  { ... }                        
    LONG SetLowerBound(LONG lLowerBound)  { ... }              
    LONG GetUpperBound() const  { ... }                        
};


例如：

explicit CComSafeArray(ULONG ulCount, LONG lLBound = 0)
    : m_psa(NULL) {                                    
    CComSafeArrayBound bound(ulCount, lLBound);        
    HRESULT hRes = Create(&bound);                     
    if (FAILED(hRes))                                  
       AtlThrow(hRes);                                 
}

Create是一层API的helper：

HRESULT Create(const SAFEARRAYBOUND *pBound, UINT uDims = 1) {
    ATLASSERT(m_psa == NULL);                                 
    ATLASSERT(uDims > 0);                                     
    HRESULT hRes = S_OK;                                      
    m_psa = SafeArrayCreate(_vartype, uDims,                  
    const_cast<LPSAFEARRAYBOUND>(pBound));                    
    if (NULL == m_psa)                                        
        hRes = E_OUTOFMEMORY;                                 
    else                                                      
        hRes = Lock();                                        
    return hRes;                                              
}

建立1维数组的例子：

// create a 1-D zero-based SAFEARRAY of long with 10 elements
CComSafeArray<long> sa(10);

// create a 1-D one-based SAFEARRAY of double with 5 elements
CComSafeArray<double> sa(5,1);


也可以使用这个来建立1D数组：

explicit CComSafeArray(const SAFEARRAYBOUND& bound);

这个例子就不如上述例子简洁：
CComSafeArrayBound bound(5,1);    // 1-D one-based array
CComSafeArray<long> sa(bound);


使用下面的函数来建立多维数组：

explicit CComSafeArray(const SAFEARRAYBOUND *pBound, UINT uDims = 1);


例子：

// 3-D array with all dimensions
// left-most dimension has 3 elements
CComSafeArrayBound bound1(3);
// middle dimension has 4 elements
CComSafeArrayBound bound2(4);
// right-most dimension has 5 elements
CComSafeArrayBound bound3(5);

// equivalent C-style array indices would be [3][4][5]
CComSafeArrayBound rgBounds[] = { bound1, bound2, bound3 };
CComSafeArray<int> sa(rgBounds, 3);


从已有数组：

CComSafeArray(const SAFEARRAY *psaSrc) : m_psa(NULL);   
CComSafeArray(const SAFEARRAY& saSrc) : m_psa(NULL);    
CComSafeArray(const CComSafeArray& saSrc) : m_psa(NULL);


例子：

CComSafeArray<int> saSrc(5);    // source is 1-D array of 5 ints
// allocate storage for 1-D array of 5 ints
// and copy contents of source
CComSafeArray<int> saDest(saSrc);


析构函数调用Detroy()：

HRESULT Destroy() {                            
    HRESULT hRes = S_OK;                       
    if (m_psa != NULL) {                       
        hRes = Unlock();                       
        if (SUCCEEDED(hRes)) {                 
            hRes = SafeArrayDestroy(m_psa);    
            if (SUCCEEDED(hRes))               
                m_psa = NULL;                  
        }                                      
    }                                          
    return hRes;                               
}


请注意Unlock()函数，用于释放SAFEARRAY的计数

 

Assignment

CComSafeArray<T>& operator=(const CComSafeArray& saSrc) {
    *this = saSrc.m_psa;                                 
    return *this;                                        
}                                                        
CComSafeArray<T>& operator=(const SAFEARRAY *psaSrc) {   
    ATLASSERT(psaSrc != NULL);                           
HRESULT hRes = CopyFrom(psaSrc);                         
    if (FAILED(hRes))                                    
        AtlThrow(hRes);                                  
    return *this;                                        
}


CopyFrom会先释放内部m_psa

例子：

CComSafeArray<long> sa1(10);
// do something interesting with sa1
CComSafeArray<long> sa2(5);

// free contents of sa1, duplicate contents
// of sa2 and put into sa1
sa1 = sa2;

 

 

The Detach and Attach Methods 

HRESULT Attach(const SAFEARRAY *psaSrc) {              
    ATLENSURE_THROW(psaSrc != NULL, E_INVALIDARG);     
                                                       
    VARTYPE vt;                                        
    HRESULT hRes = ::ATL::AtlSafeArrayGetActualVartype(
        const_cast<LPSAFEARRAY>(psaSrc), &vt);         
    ATLENSURE_SUCCEEDED(hRes);                         
    ATLENSURE_THROW(vt == GetType(), E_INVALIDARG);    
    hRes = Destroy();                                  
    m_psa = const_cast<LPSAFEARRAY>(psaSrc);           
    hRes = Lock();                                     
    return hRes;                                       
}                                                      
                                                       
LPSAFEARRAY Detach() {                                 
    Unlock();                                          
    LPSAFEARRAY pTemp = m_psa;                         
    m_psa = NULL;                                      
    return pTemp;                                      
    }

注意Destroy()也用到Unlock()方法，这个属于Win16的遗留

例如以下代码是错误的：

SAFEARRAY *psa = ::SafeArrayCreateVector(VT_I4, 0, 10);
// BAD - this pointer may not be valid!
int *pData = reinterpret_cast<int *>(pda->pvData);
// BOOM (maybe)
pData[0] = 5;

应该使用Lock：

SAFEARRAY *psa = ::SafeArrayCreateVector(VT_I4, 0, 10);
// GOOD - this will allocate the actual storage for the data
::SafeArrayLock(psa);
// Now the pointer is valid
int *pData = ( int * )(pda->pvData);
pData[0] = 5;
// Unlock after we're done
::SafeArrayUnlock( psa );


实际上Lock为SAFEARRAY分配存储空间，并且设置pvData。CComSafeArrayy构造函数调用Lock()，析构函数调用Destroy()，后者调用Unlock()。

Attach用于处理[in]SAFEARRAY，例如：

STDMETHODIMP SomeClass::AverageArray(/* [in] */ SAFEARRAY* psa,
    /* [out] */ LONG* plAvg) {
    if (!plAvg) return E_POINTER;
    CComSafeArray<long> sa; // Note: no type check is done
                            // against psa type
    sa.Attach(psa);         // we're pointing at the same
                            // memory as psa

    ... perform some calculations

    sa.Detach(); // Must detach here or risk a crash
    return S_OK;
}


Detach用于处理[out]SAFEARRAY，例如：

STDMETHODIMP SomeClass::get_Array(/* [out] */ SAFEARRAY** ppsa) {
    if (!ppsa) return E_POINTER;
    CComSafeArray<long> sa(10);

    ... populate sa instance

    // no resources released when we leave scope
    // and no copying performed
    *ppsa = sa.Detach();
    return S_OK;
}


Attach/Detach不会做数据的Copy，下边的代码是错误的：

STDMETHODIMP SomeClass::DontDoThis(SAFEARRAY* psa) {
    // We have two references to the safearray
    CComSafeArray<long> sa1, sa2;
    sa1.Attach(psa);
    sa2.Attach(psa);

    // manipulate the array here
    // BUG: Don't do this
    sa2.Destroy( );
}


千万不要对同一SAFEARRAY采用多个Attach

 

CComSafeArray Operations

LONG GetLowerBound(UINT uDim = 0) const;
LONG GetUpperBound(UINT uDim = 0) const;
ULONG GetCount(UINT uDim = 0) const;    
UINT GetDimensions() const;             
VARTYPE GetType() const ;               
bool IsSizable() const;

其中类成员fFeatures控制IsSizable()，默认应该＝TRUE

LPSAFEARRAY* GetSafeArrayPtr() {
    return &m_psa;              
}


 

HRESULT Resize(ULONG ulCount, LONG lLBound = 0);
HRESULT Resize(const SAFEARRAYBOUND *pBound);


 

HRESULT Resize(const SAFEARRAYBOUND *pBound)                              { 
    ATLASSUME(m_psa != NULL);                                               
    ATLASSERT(pBound != NULL);                                              
    if (!IsSizable()) {                                                     
        return E_FAIL;                                                      
    }                                                                       
    HRESULT hRes = Unlock();                                                
    if (SUCCEEDED(hRes)) {                                                  
        hRes = SafeArrayRedim(m_psa, const_cast<LPSAFEARRAYBOUND>(pBound)); 
        if (SUCCEEDED(hRes)) {                                              
            hRes = Lock();                                                  
        }                                                                   
    }                                                                       
    return hRes;                                                            
}

这个函数有bug，应该检查返回的HRESULT

HRESULT Add(const T& t, BOOL bCopy = TRUE);                
HRESULT Add(ULONG ulCount, const T *pT, BOOL bCopy = TRUE);
HRESULT Add(const SAFEARRAY *psaSrc);


Add流程:Create,Resize,SetAt

CComSafeArray Element Accessors

const typename _ATL_AutomationType<T>::_typewrapper&      
GetAt(LONG lIndex) const {                                
    ATLASSUME(m_psa != NULL);                             
    if(m_psa == NULL)                                     
        AtlThrow(E_FAIL);                                 
    LONG lLBound = GetLowerBound();                       
    ATLASSERT(lIndex >= lLBound);                         
    ATLASSERT(lIndex <= GetUpperBound());                 
    if ((lIndex < lLBound) || (lIndex > GetUpperBound())) 
        AtlThrow(E_INVALIDARG);                           
                                                          
    return ( (_ATL_AutomationType<T>::_typewrapper*)      
        m_psa->pvData )[lIndex-lLBound];                  
}                                                         
                                                          
_ATL_AutomationType<T>::_typewrapper& GetAt(LONG lIndex) {
    // code identical to const version                    
}


 

HRESULT SetAt(LONG lIndex, const T& t, BOOL bCopy = TRUE) {
    bCopy;                                                 
    ATLASSERT(m_psa != NULL);                              
    LONG lLBound = GetLowerBound();                        
    ATLASSERT(lIndex >= lLBound);                          
    ATLASSERT(lIndex <= GetUpperBound());                  
    ((T*)m_psa->pvData)[lIndex-lLBound] = t;               
    return S_OK;                                           
}


例子：

CComSafeArray<long> sa(5);
long lNewVal = 14;
// replace the 4th element with the value 14
sa.SetAt(3, lNewVal);


 

template<>                                               
HRESULT CComSafeArray<BSTR>::SetAt(LONG lIndex,          
    const BSTR& strData, BOOL bCopy) {                   
    // validation code omitted for clarity               
                                                         
    BSTR strOrg = ((BSTR*)m_psa->pvData)[lIndex-lLBound];
    if (strOrg)                                          
        ::SysFreeString(strOrg);                         
                                                         
    if (bCopy) {                                         
        BSTR strTemp = ::SysAllocString(strData);        
        if (NULL == strTemp)                             
            return E_OUTOFMEMORY;                        
        ((BSTR*)m_psa->pvData)[lIndex-lLBound] = strTemp;
    }                                                        
    else                                                 
        ((BSTR*)m_psa->pvData)[lIndex-lLBound] = strData;
    return S_OK;                                         
}

例子：

BSTR bstr1 = ::SysAllocString(OLESTR("Go Longhorns!"));
BSTR bstr2 = ::SysAllocString(OLESTR("ATL Rocks!"));

CComSafeArray<BSTR> sa(5);
sa.SetAt(2, bstr1, true);  // sa generates its own copy of bstr1
sa.SetAt(3, bstr2, false); // sa assigns element to bstr2
::SysFreeString(bstr1);    // ok, sa still has a copy
::SysFreeString(bstr2);    // wrong!!! we don't own bstr2


例子：

IUnknown* pUnk1, pUnk2;
// assign both pointers to refer to an object
CComSafeArray<IUnknown*> sa(5);
sa.SetAt(2, pUnk1, true);  // sa calls AddRef on pUnk1
sa.SetAt(3, pUnk2, false); // sa assigns element to pUnk2
                           // without AddRefing
pUnk1->Release();          // ok, refcount non-zero because
                           // of sa AddRef
pUnk2->Release();          // wrong!!! we don't own pUnk2


 

HRESULT MultiDimGetAt(const LONG *alIndex, T& t) {               
    ATLASSERT(m_psa != NULL);                                    
    return SafeArrayGetElement(m_psa,                            
        const_cast<LONG*>(alIndex), &t);                         
}                                                                
HRESULT MultiDimSetAt(const LONG *alIndex, const T& t) {         
    ATLASSERT(m_psa != NULL);                                    
    return SafeArrayPutElement(m_psa, const_cast<LONG*>(alIndex),
    _ATL_AutomationType<T>::GetT(t));                            
}


例子：

// 2-D array with all dimensions
// left-most dimension has 3 elements
CComSafeArrayBound bound1(3);
// right-most dimension has 4 elements
CComSafeArrayBound bound2(4);

// equivalent C-style array indices would be [3][4]
CComSafeArrayBound rgBounds[] = { bound1, bound2 };
CComSafeArray<int> sa(rgBounds, 2);

int rgIndElement1[] = { 0, 1 };    // access element at sa[1][0]
int rgIndElement2[] = { 3, 2 };    // access element at sa[2][3]

long lVal = 0;
// retrieve value at sa[1][0]
sa.MultiDimGetAt(rgIndElement1, lVal);

// multiply value by 2 and store it
// in element located at sa[2][3]
sa.MultiDimSetAt(rgIndElement2, lVal*=2);


CComSafeArray Operators

const typename                       
_ATL_AutomationType<T>::_typewrapper&
operator[](int nIndex) const {       
    return GetAt(nIndex);            
}                                    
typename                             
_ATL_AutomationType<T>::_typewrapper&
operator[](int nIndex) {             
    return GetAt(nIndex);            
}                                    
const typename                       
_ATL_AutomationType<T>::_typewrapper&
operator[](LONG nIndex)              
    const {                          
    return GetAt(nIndex);            
}                                    
typename                             
_ATL_AutomationType<T>::_typewrapper&
operator[](LONG nIndex) {            
    return GetAt(nIndex);            
}


例子：

CComSafeArray<int> sa(5);
ATLASSERT(sa[2] == 0);
sa[2] = 17;
ATLASSERT(sa[2] == 17);


operator const SAFEARRAY *() const {
    return m_psa;                   
}                                   
operator LPSAFEARRAY() {            
    return m_psa;                   
}


CComSafeArray并未定义operator&()，所以下面的代码会发生编译错误：

HRESULT CreateANewSafeArray( SAFEARRAY** ppsa ) {
    *ppsa = SafeArrayCreateVector(VT_I4, 1, 15 );
    return S_OK;
}
HRESULT UseCreatedSafeArray( ) {
    CComSafeArray< int > sa;
    HRESULT hr = CreateANewSafeArray( &sa );
}


可以使用：

HRESULT UseCreatedSafeArray( ) {
    SAFEARRAY *psa = null;
    HRESULT hr = CreateANewSafeArray( &psa );
    CComSafeArray< int > sa;
    sa.Attach( psa );
}

也可以：

HRESULT UseCreatedSafeArray( ) {
    CComSafeArray< int > sa;
    HRESULT hr = CreateANewSafeArray(sa.GetSafeArrayPtr());
}



 

COM编程--字符串结构体转换
qinwei4072880的专栏
03-17 1882
1、将结构体保存到VARIANT中 // @desc : 转为安全数组 HRESULT Hr; SAFEARRAY * pSArray; CComQIPtr spRecordInfo; Hr = ::GetRecordInfoFromGuids(LIBID_VT_CommUtiLib, 1, 0, LOCALE_USER_DEFAULT, __uuidof(TAvailableRoom)
正确的使用CComSafeArray,CComVariant和CComBSTR
boyanhat的博客
01-22 859
如果你用C++来编写COM，那么你将必不可少的使用这三个类型。使用这三种wrapper class毫无疑问会简化我们的编程，使得使用SAFEARRAY, VARIANT和BSTR简单。但是，使用这三个类型依然需要小心，因为使用不当的话，就会造成内存泄漏，或效率降低。 1. 如果拷贝两个BSTR 假如我们一个BSTR，这个时候我希望复制一份BSTR，并丢弃之前的BSTR。通常我们会这么写： CComBSTR StringToBSTR(const string & sVal) { CCom
笔记01
sinat_36391009的博客
11-28 334
SHGetPathFromIDList   AfxSetResourceHandle AfxSetResourceHandle   GetEnvironmentVariable SetEnvironmentVariable   PathFindFileName PathRemoveExtension   PathIsDirectory   PathFileExists ...
ATL CString 的代码 整理
lif12345的专栏
03-01 2237
从ATL整理的CString代码 可以用于其他项目 #pragma once #include &lt;assert.h&gt; #include &lt;mbstring.h&gt; #include &lt;atlexcept.h&gt; #define IN_OPT #define IN_OUT #ifndef MYATLENSURE_RETURN_VAL #define MYAT...
COM、ATL学习的几本书点评
mcmcmc的专栏
09-27 1284
Essential COM：中级教程 我看的是En版，这种很艰深的书还是看原版的比较不容易走火入魔。作者Don Box现在好像成了.Net大佬，不过该书非常经典，美中不足的是有一些问题没有论述。书的末尾有一个例子，但是每一章没有实例，所以显得艰深。这个例子我没有实现。   COM技术内幕：初级教程 只有中文翻译版，初学者可以看懂，基本没有什么内幕，建议看完后（或者不看）直接Essentia
ATL Internals 2ed复习.chapter 8.COM Collection and Enumeration Interfaces
mcmcmc的专栏
10-10 1004
COM Collection接口定义类似于： [ object, dual ] template typename T> interface ICollection : IDispatch { [propget] HRESULT Count([out, retval] long* pnCount); [id(DISPID_VALUE), propget] HRES
ATL Internals 2ed复习.chapter 3.CComPtr CComQIPtr
mcmcmc的专栏
10-01 920
A Review of Smart Pointers 使用smart pointers的好处： 对象析构时，自动release interface 发生异常时，创建在栈上的对象自动release interface assignment操作时，旧的interface自动release，新的interface自动AddRef 提供不同的构造函数 可以在大部分用raw pointer的地方
ATL Internals 2ed复习.chapter 5.CAtlModule
mcmcmc的专栏
10-07 894
The _AtlModule Global Variable 每一个项目，wizard都会生成一个全局变量_AtlModule，用户可以通过全局指针_pAtlModule来访问它，例如： class CMathModule : public CAtlDllModuleT { public: DECLARE_LIBID(LIBID_Math) DECLARE_REGIS
ATL Internals 2ed复习.chapter 7.COM Persistence
mcmcmc的专栏
10-07 888
需要保存自身状态的object应该提供IPersistMedium，这里Medium=Stream,Storage,PropertyBag等 client决定何时在何种媒体上要保存object的状态，调用IPersistMedium的Load()，Save()，并且为这两个函数提供相应的IMedium接口 所有的IPersistMedium都派生自IPersist接口： interface
ATL Internals 2ed复习.chapter 4.IUnknown
mcmcmc的专栏
10-06 850
Standalone Reference Counting template class CComObjectRootEx : public CComObjectRootBase 中的类型定义： typedef ThreadModel _ThreadModel; typedef typename _ThreadModel::AutoCriticalSection _CritSec; t
ATL Internals 2ed复习.chapter 4.Thread
mcmcmc的专栏
10-06 837
Instance Data Synchronization CComCriticalSection：使用Init()生成，Term()销毁 CComAutoCriticalSection：使用构造函数生成，析构函数销毁 CComSafeDeleteCriticalSection：Init()生成，析构函数销毁 CComAutoDeleteCriticalSection：未定义Term()，
ATL Internals 2ed复习.chapter 5.Object Map
mcmcmc的专栏
10-07 834
由于有3种COM Server，ATL提供了CAtlModule的派生类对应 CAtlDllModuleT：in-process dll CAtlExeModuleT：out-process exe CAtlServiceModuleT：system service exe   CAtlModule使用了Object Map管理server中所有的类 CAtlModule的职责 找到
ATL Internals 2ed复习.chapter 6.各种interface map宏
mcmcmc的专栏
10-07 755
COM_INTERFACE_ENTRY and COM_INTERFACE_ENTRY_IID #define COM_INTERFACE_ENTRY_IID(iid, x) \ { &iid, offsetofclass(x, _ComMapClass), _ATL_SIMPLEMAPENTRY}, COM_INTERFACE
ATL Internals 2ed复习.chapter 3.CComGITPtr
mcmcmc的专栏
10-01 733
Global Interface Table (GIT)提供了进程内interface共享机制，用户可以高效的在套间之间传递interface. 使用GIT通常需要下面几步： 1..源套间在GIT中注册interface，需要调用IGlobalInterfaceTable系统服务，取得一个cookie HRESULT RegisterMyInterface(IMyInterface* p
ATL Internals 2ed复习.chapter 4.Debugging
mcmcmc的专栏
10-06 713
ASSERT #ifndef ATLASSERT #define ATLASSERT(expr) _ASSERTE(expr) #endif 上述这个宏依赖CRT 传输到debug output inline void _cdecl AtlTrace(LPCST
ATL Internals 2ed复习.chapter 3.CComVariant
mcmcmc的专栏
10-01 693
在使用COM时，有时候用户不知道函数的输入参数，输出参数的具体类型。例如用户传入long类型，函数会把用户传入的long转换成自己想要的参数类型例如BSTR。其中起到关键作用的就是VARIANT类型 VARIANT.vt==当前存储的数据类型 VARIANT.(bVal,iVal,...,pvarVal,byref)==当前存储的数据   正确使用VARIANT需要注意： 需要使用Var
ATL Internals 2ed复习.chapter 7.ATL Persistence implements
mcmcmc的专栏
10-07 683
The Property Map PROP_ENTRY (szDesc, dispid, clsid) PROP_ENTRY_EX (szDesc, dispid, clsid, iidDispatch) PROP_DATA_ENTRY (szDesc, member, vt)   IPersistPropertyBagImpl 只能实现对VARIANT的读写 VT_UI
ATL Internals 2ed复习.chapter 3.CAutoPtr
mcmcmc的专栏
10-06 679
ATL提供了CAutoPtr, CAutoVectorPtr, CAutoPtrArray, and CAutoPtrList，它们具有类似auto_ptr功能，而没有抛出异常，并且不需要借助于CRT库。 The CAutoPtr and CAutoVectorPtr Classes 例子：   STDMETHODIMP CMyClass::SomeFunc() { CFoo*
C语言数据结构链表二叉树图遍历排序查找算法实战源码
最新发布
06-26
内容概要：本资源提供一套完整可编译的 C 语言数据结构与算法实战源码工程，覆盖单向链表、二叉搜索树、图邻接表、快速排序、归并排序、二分查找和 lower_bound 等核心内容。工程采用标准 C11 编写，包含 include 公开头文件、src 核心实现、tests 单元测试、examples 命令行示例、复杂度说明文档、Makefile 构建脚本和 Dockerfile 验证环境，下载后可通过 make test 和 make demo 直接验证主要功能。 适合人群：适合具备 C 语言基础、正在学习数据结构课程、准备算法面试或希望强化指针与内存管理能力的开发学习者。 能学到什么：①链表节点创建、删除、反转与边界处理；②二叉搜索树插入、查找、删除和中序遍历实现；③图邻接表建模、BFS、DFS 与无权最短路径计算；④快速排序、归并排序和二分查找的工程化写法；⑤Makefile 静态库构建、测试组织和命令行示例设计。 阅读建议：建议先阅读 README 和 include/dskit 头文件理解接口，再结合 examples/demo.c 运行示例，最后进入 src 源码逐步调试链表反转、树节点删除、图遍历队列推进和排序递归过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值