ATL Internals 2ed复习.chapter 2

最新推荐文章于 2018-09-11 11:36:45 发布
最新推荐文章于 2018-09-11 11:36:45 发布
阅读量603 收藏
点赞数
分类专栏： COM/ATL 文章标签： null concatenation behavior string pascal solaris
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mcmcmc/article/details/8027123
版权

String Data Types, Conversion Classes, and Helper Functions

对于字符串表示,不同的系统有不同的方法

C/C++使用在字串末尾加Nul

VB,Java,Pascal在字串头部标识字串长度

COM使用OLECHAR作为字符类型，COM的字符串为Nul结尾的OLECHARs，用LPOLESTR表示。如果向COM interface传递text参数，应该使用LPOLESTR

 

Unicode,=wchar_t, 16-bit，L()宏

MBCS,=unsigned char,1~2Bytes

ANSI,=[signed] char

TCHAR/_TCHAR,由编译条件决定定义类型，_T()宏

OLECHAR,Win32=wchar_t，Win16=char，Mac OS=char，Solaris OS=wchar_t

BSTR,头部标识长度的OLECHAR串,无法使用转换宏，转换类进行变换

 

使用转换类防止内存提前释放

LPOLESTR ConvertString(LPTSTR lpsz) { return CT2OLE(lpsz);}

转换宏，转换类区别

转换类都有C开头

转换宏永远使用栈分配，更快，需要USE_CONVERSION宏，可能在loop中造成程序内存崩溃

转换类更加安全

 

The CComBSTR Smart BSTR Class

BSTR特点

对于非C语言交互，应该使用BSTR作为字符串参数

BSTR包括一串字符串和一个前置整数，BSTR指向字符串，字符串以Nul结尾，前置整数为字符串Byte长度，不包括末尾Nul

BSTR必须使用SysAllocString，SysFreeString，copy必须真实复制字符串而不仅仅是指针

BSTR=NULL表示一个空的字符串

 

The CComBSTR Class

CComBSTR() { m_str = NULL; }           
~CComBSTR() { ::SysFreeString(m_str); }

构造函数变形

CComBSTR(LPCOLESTR pSrc) {              
    if (pSrc == NULL) m_str = NULL;     
    else {                              
        m_str = ::SysAllocString(pSrc); 
        if (m_str == NULL)              
                AtlThrow(E_OUTOFMEMORY);
    }                                   
}                                       

CComBSTR(int nSize, LPCOLESTR sz);

nSize为目标字符串的字符数，不包含末尾Nul

CComBSTR(const CComBSTR& src) {
    m_str = src.Copy();        
    ...                        
}                              

BSTR Copy() const {                             
    if (!*this) { return NULL; }                
    return ::SysAllocStringByteLen((char*)m_str,
        ::SysStringByteLen(m_str));             
}                                               

CComBSTR(LPCSTR pSrc) {         
     ...                        
     m_str = A2WBSTR(pSrc);     
     ...                        
}                               
CComBSTR(int nSize, LPCSTR sz) {
     ...                        
     m_str = A2WBSTR(sz, nSize);
     ...                        
}

CComBSTR(REFGUID src);例子

// Define a GUID as a binary constant
static const GUID GUID_Sample = { 0x8a44e110, 0xf134, 0x11d1,
    { 0x96, 0xb1, 0xBA, 0xDB, 0xAD, 0xBA, 0xDB, 0xAD } };

// Convert the binary GUID to its string representation
CComBSTR str6 (GUID_Sample) ;
// str6 contains "{8A44E110-F134-11d1-96B1-BADBADBADBAD}"

 
Assignment
CComBSTR& operator=(const CComBSTR& src) {               
    if (m_str != src.m_str) {                            
        ::SysFreeString(m_str);                          
        m_str = src.Copy();                              
        if (!!src && !*this) { AtlThrow(E_OUTOFMEMORY); }
    }                                                    
    return *this;                                        
}                                                        

CComBSTR& operator=(LPCOLESTR pSrc) {               
    if (pSrc != m_str) {                            
        ::SysFreeString(m_str);                     
        if (pSrc != NULL) {                         
            m_str = ::SysAllocString(pSrc);         
            if (!*this) { AtlThrow(E_OUTOFMEMORY); }
        } else {                                    
            m_str = NULL;                           
        }                                           
    }                                               
    return *this;                                   
}                                                   

HRESULT AssignBSTR(const BSTR bstrSrc) {                   
    HRESULT hr = S_OK;                                     
    if (m_str != bstrSrc) {                                
        ::SysFreeString(m_str);                            
        if (bstrSrc != NULL) {                             
            m_str = ::SysAllocStringByteLen((char*)bstrSrc,
                ::SysStringByteLen(bstrSrc));              
                                                    
            if (!*this) { hr = E_OUTOFMEMORY; }            
        } else {                                           
            m_str = NULL;                                  
        }                                                  
    }                                                      
                                                           
                                                           
    return hr;                                             
}                                                          

CComBSTR& operator=(LPCSTR pSrc) {                          
    ::SysFreeString(m_str);                                 
    m_str = A2WBSTR(pSrc);                                  
    if (!*this && pSrc != NULL) { AtlThrow(E_OUTOFMEMORY); }
    return *this;                                           
}                                                           

 
bool LoadString(HINSTANCE hInst, UINT nID) ;
bool LoadString(UINT nID) ;

CComBSTR Operations

operator BSTR() const { return m_str; }

#ifndef ATL_CCOMBSTR_ADDRESS_OF_ASSERT    
// Temp disable CComBSTR::operator& Assert
#define ATL_NO_CCOMBSTR_ADDRESS_OF_ASSERT 
#endif                                    
                                          
BSTR* operator&() {                       
#ifndef ATL_NO_CCOMBSTR_ADDRESS_OF_ASSERT 
    ATLASSERT(!*this);                    
#endif                                    
    return &m_str;                        
}                                         

HRESULT CopyTo(BSTR* pbstr);
BSTR Detach() { BSTR s = m_str; m_str = NULL; return s; }
void Attach(BSTR src) {        
    if (m_str != src) {        
        ::SysFreeString(m_str);
        m_str = src;           
    }                          
}


 

void Empty() { ::SysFreeString(m_str); m_str = NULL; }

HRESULT BSTRToArray(LPSAFEARRAY *ppArray) {          
    return VectorFromBstr(m_str, ppArray);           
}                                                    
                                                     
HRESULT ArrayToBSTR(const SAFEARRAY *pSrc) {         
    ::SysFreeString(m_str);                          
    return BstrFromVector((LPSAFEARRAY)pSrc, &m_str);
}

 

String Concatenation Using CComBSTR

HRESULT Append(LPCOLESTR lpsz, int nLen);             
HRESULT Append(LPCOLESTR lpsz);                       
HRESULT Append(LPCSTR);                               
HRESULT Append(char ch);                              
HRESULT Append(wchar_t ch);                           
                                                      
HRESULT Append(const CComBSTR& bstrSrc);          
CComBSTR& operator+=(const CComBSTR& bstrSrc);
                                                      
HRESULT AppendBSTR(BSTR p);                           

HRESULT AppendBytes(const char* lpsz, int nLen);

注意AppendBytes does not perform a conversion from ANSI to Unicode.

Character Case Conversion

HRESULT ToLower() {                                        
        if (m_str != NULL) {                               
#ifdef _UNICODE                                            
               // Convert in place                         
               CharLowerBuff(m_str, Length());             
#else                                                      
            UINT _acp = _AtlGetConversionACP();            
            ...                                            
            int nRet = WideCharToMultiByte(                
                _acp, 0, m_str, Length(),                  
                pszA, _convert, NULL, NULL);               
            ...                                            
                                                           
            CharLowerBuff(pszA, nRet);                     
                                                           
            nRet = MultiByteToWideChar(_acp, 0, pszA, nRet,
                                    pszW, _convert);       
                ...                                        
                                                           
            BSTR b = ::SysAllocStringByteLen(              
                (LPCSTR) (LPWSTR) pszW,                    
                nRet * sizeof(OLECHAR));                   
            if (b == NULL)                                 
                    return E_OUTOFMEMORY;                  
            SysFreeString(m_str);                          
            m_str = b;                                     
#endif                                                     
                                     
            }                                              
            return S_OK;                                   
}                                                          

CComBSTR Comparison Operators
bool operator!() const { return (m_str == NULL); }


 

bool operator<(const CComBSTR& bstrSrc) const {
    return VarBstrCmp(m_str, bstrSrc.m_str,    
        LOCALE_USER_DEFAULT, 0) ==             
    VARCMP_LT;                                 
}                                              
bool operator>(LPCSTR pszSrc) const {
        CComBSTR bstr2(pszSrc);      
        return operator>(bstr2);     
}                                    
bool operator<(LPCOLESTR pszSrc) const {
    CComBSTR bstr2(pszSrc);             
    return operator>(bstr2);            
}                                       
bool operator>(LPOLESTR pszSrc) const { 
    return operator>((LPCOLESTR)pszSrc);
}


CComBSTR Persistence Support

HRESULT WriteToStream(IStream* pStream) {             
    ATLASSERT(pStream != NULL);                       
    if(pStream == NULL)                               
        return E_INVALIDARG;                          
                                                      
    ULONG cb;                                         
    ULONG cbStrLen = ULONG(m_str ?                    
        SysStringByteLen(m_str)+sizeof(OLECHAR) : 0); 
    HRESULT hr = pStream->Write((void*) &cbStrLen,    
        sizeof(cbStrLen), &cb);                       
    if (FAILED(hr))                                   
        return hr;                                    
    return cbStrLen ?                                 
        pStream->Write((void*) m_str, cbStrLen, &cb) :
        S_OK;                                         
}                                                     
 
HRESULT ReadFromStream(IStream* pStream) {                      
    ATLASSERT(pStream != NULL);                                 
    ATLASSERT(!*this); // should be empty                       
    ULONG cbStrLen = 0;                                         
    HRESULT hr = pStream->Read((void*) &cbStrLen,               
        sizeof(cbStrLen), NULL);                                
    if ((hr == S_OK) && (cbStrLen != 0)) {                      
        //subtract size for terminating NULL which we wrote out 
        //since SysAllocStringByteLen overallocates for the NULL
        m_str = SysAllocStringByteLen(NULL,                     
            cbStrLen-sizeof(OLECHAR));                          
        if (!*this) hr = E_OUTOFMEMORY;                         
        else hr = pStream->Read((void*) m_str, cbStrLen, NULL); 
        ...                                                     
    }                                                           
    if (hr == S_FALSE) hr = E_FAIL;                             
    return hr;                                                  
}


注意在Read前，应该保证obj为Empty

CComBSTR注意点

typedef /* [wire_marshal] */ OLECHAR __RPC_FAR *BSTR;两者有时可以混用

将BSTR数据传入LPOLESTR的输入函数中，会导致字串缩短

将BSTR传给[out]OLECHAR**函数，会导致内存泄漏

不要将OLESTR*传给[in]BSTR,因为SysStringLen无法工作正确

将BSTR传给CComBSTR构造函数应该注意

BSTR bstrInput =
  SysAllocStringLen (
    OLESTR ("This is part one\0and here's part two"),
    36) ;

CComBSTR str8 (bstrInput) ; // Wrong! Unexpected behavior here
                            // Note: str2 contains only
                            // "This is part one"

CComBSTR str9 (::SysStringLen (bstrInput),
    bstrInput); // Correct!
// str9 contains "This is part one\0and here's part two"


同理Assignment应该注意

// BSTR bstrInput contains
// "This is part one\0and here's part two"
CComBSTR str10;
str10 = bstrInput; // Wrong! Unexpected behavior here
                   // str10 now contains "This is part one"

str10.Empty();                // Insure object is initially empty
str10.AppendBSTR (bstrInput); // This works!

The CString Class

大部分和MFC中一样

Working with BSTRs and CString

BSTR AllocSysString() const {                                   
    BSTR bstrResult = StringTraits::AllocSysString( GetString(),
        GetLength() );                                          
    if( bstrResult == NULL ) {                                  
        ThrowMemoryException();                                 
    }                                                           
                                                         
    return( bstrResult );                                       
}                                                               
                                                                
BSTR SetSysString( BSTR* pbstr ) const {                        
    ATLASSERT( AtlIsValidAddress( pbstr, sizeof( BSTR ) ) );    
                                                                
    if( !StringTraits::ReAllocSysString( GetString(), pbstr,    
        GetLength() ) ) {                                       
        ThrowMemoryException();                                 
    }                                                           
                                                                
    ATLASSERT( *pbstr != NULL );                                
    return( *pbstr );                                           
}


注意2个函数都是const，对CString中的数据没有影响

 

I_ask_who
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ATL 教程 (2).docx
11-11
。。。
COM中的字符串
hfit000的专栏
11-07 1017
这两天被BSTR折腾了不行，特从网上搜来，做资料查阅 字符串是一个文本类型数据（字符）的数组，我们要处理一个字符串需要考虑这么几点： 第一，   字符类型。不同的操作系统，或者统一操作系统内会有不同的字符类型比如说，, char, unsigned char, wchar类型。 第二，   和字符集不同。如UNICODE, SBCS(ANSI), MBCS, DBCS等不同的字符
BSTR Copy
hx_nwpu的专栏
10-15 539
前一阵一直琢磨怎么把BSTR这种指针的内容复制，后来在CComBSTR代码中找到了答案：   BSTR Copy() const throw()  {   if (!*this)         {    return NULL;         }   return ::SysAllocStringByteLen((char*)m_str, ::SysStringByteLen(
ATL 教程 (2).pdf
11-11
。。。
ICESat2_ATL03A_ATBD.pdf
12-23
ICESAT-2 ATLAS 产品说明,比如介绍各级数据级处理算法和理论基础。该产品由ICESat-2任务生产。 它包括参数的描述和这些ICESat-2参数的推导 。 在ICESat-2科学研究者领导的处理系统(SIPS)上实现的待定bd处理的算法...
ATL Internals源代码.part2
04-09
ATL Internals源代码
ICESat2_ATL01_13Nov2017.pdf
12-23
ICESAT-2 ATLAS 产品说明,比如介绍各级数据级处理算法和理论基础。该产品由ICESat-2任务生产。 它包括参数的描述和这些ICESat-2参数的推导 。 在ICESat-2科学研究者领导的处理系统(SIPS)上实现的待定bd处理的算法...
Cstring的实现_马鸿凯_新浪博客
Ma_Hong_Kai的博客
09-11 530
template&lt; typename BaseType, class StringTraits &gt; class CStringT : public CSimpleStringT&lt; BaseType, _CSTRING_IMPL_::_MFCDLLTraitsCheck::c_bIsMFCDLLTraits &gt; { public: typedef CSimpleS...
COM、ATL学习的几本书点评
mcmcmc的专栏
09-27 1185
Essential COM：中级教程 我看的是En版，这种很艰深的书还是看原版的比较不容易走火入魔。作者Don Box现在好像成了.Net大佬，不过该书非常经典，美中不足的是有一些问题没有论述。书的末尾有一个例子，但是每一章没有实例，所以显得艰深。这个例子我没有实现。   COM技术内幕：初级教程 只有中文翻译版，初学者可以看懂，基本没有什么内幕，建议看完后（或者不看）直接Essentia
ATL Internals 2ed复习.chapter 8.COM Collection and Enumeration Interfaces
mcmcmc的专栏
10-10 899
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 7.COM Persistence
mcmcmc的专栏
10-07 815
需要保存自身状态的object应该提供IPersistMedium，这里Medium=Stream,Storage,PropertyBag等 client决定何时在何种媒体上要保存object的状态，调用IPersistMedium的Load()，Save()，并且为这两个函数提供相应的IMedium接口 所有的IPersistMedium都派生自IPersist接口： interface
ATL Internals 2ed复习.chapter 3.CComPtr CComQIPtr
mcmcmc的专栏
10-01 804
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 795
The _AtlModule Global Variable 每一个项目，wizard都会生成一个全局变量_AtlModule，用户可以通过全局指针_pAtlModule来访问它，例如： class CMathModule : public CAtlDllModuleT { public: DECLARE_LIBID(LIBID_Math) DECLARE_REGIS
ATL Internals 2ed复习.chapter 4.Thread
mcmcmc的专栏
10-06 748
Instance Data Synchronization CComCriticalSection：使用Init()生成，Term()销毁 CComAutoCriticalSection：使用构造函数生成，析构函数销毁 CComSafeDeleteCriticalSection：Init()生成，析构函数销毁 CComAutoDeleteCriticalSection：未定义Term()，
icesat-2 atl03
最新发布
09-02
ICESat-2是美国航天局发起的一个卫星任务，...总之，ICESat-2的ATL03数据是一项重要的科学成果，它提供了全球冰川和冰盖高度变化的精确测量结果，对于研究气候变化、理解冰川物理特性以及制定政策和决策具有重要意义。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值