从 ANSI 到 Unicode Unicode 到 ANSI 用于 OLE 如何转换

本文主要是介绍从 ANSI 到 Unicode Unicode 到 ANSI 用于 OLE 如何转换，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

概要

所有字符串传递到和接收从 32 位 OLE API 和接口方法使用 Unicode。这需要使用 ANSI 字符串要传递给 OLE 它们之前它们转换为 Unicode 和将 Unicode 字符串从 OLE 接收到 ANSI 应用程序。本文演示如何进行这些转换。

更多信息

WindowsNT 实现 Unicode （或宽字符）和 ANSI 版本的 Win 32 函数，接受字符串参数。但是 Windows 95 没有实现 Unicode 版本的大多数 Win 32 函数，接受字符串参数。而它实现只 ANSI 版本的这些函数。

主要例外到此规则是 32 位 OLE。 32 位 OLE API 和接口方法在 WindowsNT 和 Windows 95 独占使用 Unicode。或者在 WindowsNT 或 Windows 95 没有实现这些函数 ANSI 版本。

这意味着，需要在 Windows 95 和 WindowsNT 运行 32 位应用程序必须使用 ANSI 版本的非 OLE Win 32 函数并必须将 ANSI 字符串转换为 Unicode 之前将它们传递给 OLE。

WindowsNT 上只运行 32 位 Unicode 应用程序需要使用任何 ANSI / Unicode 转换函数。

Win 32 提供要 ANSI 到 Unicode 字符串和 Unicode 字符串转换为 ANSI MultiByteToWideChar 和 WideCharToMultiByte。本文提供 AnsiToUnicode 和 UnicodeToAnsi, 使用这些功能对于 ANSI / Unicode 转换。

 /*
 * AnsiToUnicode converts the ANSI string pszA to a Unicode string
 * and returns the Unicode string through ppszW. Space for the
 * the converted string is allocated by AnsiToUnicode.
 */ 
HRESULT __fastcall AnsiToUnicode(LPCSTR pszA, LPOLESTR* ppszW)
{
    ULONG cCharacters;
    DWORD dwError;
    // If input is null then just return the same. 
    if (NULL == pszA)
    {
        *ppszW = NULL;
        return NOERROR;
    }
    // Determine number of wide characters to be allocated for the 
    // Unicode string. 
    cCharacters =  strlen(pszA)+1;
    // Use of the OLE allocator is required if the resultant Unicode 
    // string will be passed to another COM component and if that 
    // component will free it. Otherwise you can use your own allocator. 
    *ppszW = (LPOLESTR) CoTaskMemAlloc(cCharacters*2);
    if (NULL == *ppszW)
        return E_OUTOFMEMORY;
    // Covert to Unicode. 
    if (0 == MultiByteToWideChar(CP_ACP, 0, pszA, cCharacters,
                  *ppszW, cCharacters))
    {
        dwError = GetLastError();
        CoTaskMemFree(*ppszW);
        *ppszW = NULL;
        return HRESULT_FROM_WIN32(dwError);
    }
    return NOERROR;
/*
 * UnicodeToAnsi converts the Unicode string pszW to an ANSI string
 * and returns the ANSI string through ppszA. Space for the
 * the converted string is allocated by UnicodeToAnsi.
 */ 
HRESULT __fastcall UnicodeToAnsi(LPCOLESTR pszW, LPSTR* ppszA)
{
    ULONG cbAnsi, cCharacters;
    DWORD dwError;
    // If input is null then just return the same. 
    if (pszW == NULL)
    {
        *ppszA = NULL;
        return NOERROR;
    }
    cCharacters = wcslen(pszW)+1;
    // Determine number of bytes to be allocated for ANSI string. An 
    // ANSI string can have at most 2 bytes per character (for Double 
    // Byte Character Strings.) 
    cbAnsi = cCharacters*2;
    // Use of the OLE allocator is not required because the resultant 
    // ANSI  string will never be passed to another COM component. You 
    // can use your own allocator. 
    *ppszA = (LPSTR) CoTaskMemAlloc(cbAnsi);
    if (NULL == *ppszA)
        return E_OUTOFMEMORY;
    // Convert to ANSI. 
    if (0 == WideCharToMultiByte(CP_ACP, 0, pszW, cCharacters, *ppszA,
                  cbAnsi, NULL, NULL))
    {
        dwError = GetLastError();
        CoTaskMemFree(*ppszA);
        *ppszA = NULL;
        return HRESULT_FROM_WIN32(dwError);
    }
    return NOERROR;
}
 

这些函数的示例使用如下所示。 CoTaskMemFree 用于释放转换字符串如果 CoTaskMemAlloc 用于分配字符串。因为该组件负责释放字符串转换字符串必须不能释放如果它是通过一个 out 参数返回到其他 OLE 组件。 LPOLESTR 是指针指向 Unicode 字符串。

 // The following code gets an ANSI filename that is specified by the 
// user in the OpenFile common dialog. This file name is converted into 
// a Unicode string and is passed to the OLE API CreateFileMoniker. The 
// Unicode string is then freed. 
OPENFILENAME ofn;
LPOLESTR pszFileNameW;
LPMONIKER pmk;
:
// Get file name from OpenFile Common Dialog. The ANSI file name will 
// be placed in ofn.lpstrFile 
GetOpenFileName(&ofn);
:
AnsiToUnicode(ofn.lpstrFile, &pszFileNameW);
CreateFileMoniker(pszFileNameW, &pmk);
CoTaskMemFree(pszFileNameW);
// The following code implements IOleInPlaceFrame::SetStatusText. 
// The lpszStatusText string, that is received from another OLE 
// component, uses Unicode. The string is converted to ANSI before it is 
// passed to the ANSI version of SetWindowText. Windows 95 supports only 
// the ANSI version of SetWindowText. 
COleInPlaceFrame::SetStatusText(LPCOLESTR pszStatusTextW)
{
    LPSTR pszStatusTextA;
    UnicodeToAnsi(pszStatusTextW, &pszStatusTextA);
    SetWindowText(m_hwndStatus, pszStatusTextA);
    CoTaskMemFree(pszStatusTextA);
}
 

注意： AnsiToUnicode 和 UnicodeToAnsi 有关分配器用于分配转换字符串中注释。 CoTaskMemAlloc （OLE 分配程序）都需要使用仅如果结果字符串将传递到其他 OLE 组件并且该组件可释放字符串。这意味着该字符串作为参数中传递给 OLE 接口方法需要使用 OLE 分配器。必须使用 OLE 分配器分配字符串作为参数中出 - 传递或通过 out 参数或参数中出 - 返回。

通过使用 OLESTR 宏字符串常量可转换为 Unicode 在编译时。例如：

CreateFileMoniker(OLESTR("c://boo//har.doc"), &pmk);

Microsoft 基础类 (MFC) 其中附带 VisualC++4.0 编译器源代码中可以找到其他属于 ANSI / Unicode 转换例程。 MFC Technote 59 中描述这些例程： ' 使用 MFC MBCS/Unicode 转换宏 '。定义这些宏 OLE2T T2OLE、 OLE2CT、 T2COLE、 A2W、 W2A、 A2CW、 W2CA 和 USES_CONVERSION 位于 /msdev/mfc/include/afxpriv.h。同时参阅 AfxA2WHelper 和 AfxW2AHelper MFC /msdev/mfc/src 和 OLE2T T2OLE、 OLE2CT 和 T2COLE MFC /msdev/mfc/src 中源代码中使用中源代码中。这些函数允许要取决于是否作了 _ UNICODE 预处理器定义编译或者对于 Unicode 或 ANSI 代码。例如, 上例中 CreateFileMoniker 调用如下进行与 MFC 宏：

 USES_CONVERSION;
GetOpenFileName(&ofn);
CreateFileMoniker(T2OLE(ofn.lpstrFile), &pmk);
 

如果定义 _ UNICODE, T2OLE 定义如下：

inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }

如果未定义 _ UNICODE, T2OLE 定义如下：

#define T2OLE(lpa) A2W(lpa)

T2OLE 中 T 指示未定义 _ UNICODE 时类型被转换为 OLE 字符串（Unicode 字符串）是 Unicode 字符串当定义 _ UNICODE 和 ANSI 字符串。未定义 _ UNICODE 时同样 LPTSTR 定义作为指向 Unicode 字符串当定义 _ UNICODE 和 ANSI 字符串指向。 T2OLE 定义 _ UNICODE 时不执行任何转换 (LPTSTR = = LPOLESTR)。当未定义 Unicode, A2W 调用。 A2W 将 ANSI 字符串转换为 Unicode 如下：

 #define A2W(lpa) (/  
        ((LPCSTR)lpa == NULL) ? NULL : (/ 
            _convert = (strlen(lpa)+1),/ 
            AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)/ 
        )/ 
)
 

AfxA2WHelper 使用 MultiByteToWideChar 来进行转换。

MFC 转换宏用于 _ alloca 从用于转换字符串程序堆栈分配空间。过程调用完成后自动释放空间。 OLE 要求 OLE 分配器能够用于所有字符串（数据）将由一个组件分配和释放由另。这意味着 out 参数传递字符串并中出参数 - 的 OLE 接口必须与 OLE 分配器分配。因为调用方负责释放它们内参数需要不能分配与 OLE 分配器。大多数 Linking / Embedding OLE 接口和 API 传递字符串作为参数中。因此 MFC 转换宏可用于大多数情况。对于中出参数或者对于因为它们执行未分配空间使用 OLE 分配器返回通过外参数值不能使用 MFC 转换宏。 AnsiToUnicode 和 UnicodeToAnsi 可用于这些情况。

尚未 Unicode/MBCS ANSI 转换例程其他组可以找到 OLE 在 Microsoft Systems 日记本, 上 DonBox 的列中 8月 1995, Vol. 10 否。 8, Page 86。 DonBox 定义用它将返回 Unicode/MBCS 转换 ANSI 字符串转换运算符 C++ 类。对象转超出范围时自动释放分配空间。此类修改和使用 OLE 分配器分配以不释放通过中出或 out 参数传递字符串分配空间。

遵循之一 String16, 类, 从其中将 ANSI 字符串转换为 Unicode, DonBox 的列。其他类, String8, 是类似于这台用于 Unicode 转换为 ANSI 从上例 CreateFileMoniker 调用如下进行与此类：

 GetOpenFileName(&ofn);
CreateFileMoniker(String16(ofn.lpstrFile), &pmk);
 

在上述代码, String16 的实例被创建。的类构造函数会将 ANSI 字符串转换为 Unicode。语言实现将调用转换运算符，运算符 const wchar _ *，转换到的 CreateFileMoniker 的第一个参数的类型参数。转换运算符将返回 Unicode 字符串传递到 CreateFileMoniker。对象将销毁处于转超出范围。

 // String16   
// Shim class that converts both 8-bit (foreign) and 
// 16-bit (native) strings to 16-bit wideness 
class String16 {
public:
// native and foreign constructors 
    String16(const char *p8);
    String16(const wchar_t *p16);
// non-virtual destructor (this class is concrete) 
  ~String16(void);
// native conversion operator 
  operator const wchar_t * (void) const;
private:
// native wideness string 
    wchar_t *m_sz;
// is foreign?? 
    BOOL m_bIsForeign;
// protect against assignment! 
  String16(const String16&);
    String16& operator=(const String16&);
};
// native constructor is a pass-through 
inline String16::String16(const wchar_t *p16)
: m_sz((wchar_t *)p16), m_bIsForeign(FALSE)
{
}
// simply give out the native wideness string 
inline String16::operator const wchar_t * (void) const
{
  return m_sz;
}
// foreign constructor requires allocation of a native 
// string and conversion 
inline String16::String16(const char *p8)
: m_bIsForeign(TRUE)
{
// calculate string length 
  size_t len = strlen(p8);
// calculate required buffer size (some characters may 
// already occupy 16-bits under DBCS) 
  size_t size = mbstowcs(0, p8, len) + 1;
// alloc native string and convert 
  if (m_sz = new wchar_t[size])
    mbstowcs(m_sz, p8, size);
}
// delete native string only if synthesized in foreign constructor 
inline String16::~String16(void) {
  if (m_bIsForeign)
    delete[] m_sz;
}
 