วิธีการแปลงจาก ANSI เป็น Unicode & Unicode เพื่อ ANSI สำหรับ OLE

การแปลบทความ การแปลบทความ
หมายเลขบทความ (Article ID): 138813
ขยายทั้งหมด | ยุบทั้งหมด

สรุป

สายอักขระทั้งหมดที่ส่งผ่านไปยัง และได้รับจาก 32 บิต OLE APIs และอินเทอร์เฟซสำหรับวิธี ใช้ Unicode นี้ต้องการให้โปรแกรมประยุกต์ที่ใช้สายอักขระ ANSI การแปลงให้เป็น Unicode ก่อนที่จะส่งผ่าน OLE และ การแปลงสายอักขระ Unicode ที่ได้รับจาก OLE ANSI บทความนี้อธิบายวิธีสามารถทำการแปลงเหล่านี้

ข้อมูลเพิ่มเติม

Windows NT ใช้ Unicode (หรือความกว้างอักขระ) และฟังก์ชัน Win32 ที่ใช้พารามิเตอร์การสตริงที่รุ่น ANSI อย่างไรก็ตาม Windows 95 ไม่ใช้ฟังก์ชัน Win32 ส่วนใหญ่ที่ใช้พารามิเตอร์การสตริงที่รุ่น Unicode แต่ คุณใช้เฉพาะ ANSI รุ่นของฟังก์ชันเหล่านี้

ยกเว้นที่สำคัญของกฎนี้คือ OLE 32 บิต 32 บิต OLE APIs และวิธีการอินเทอร์เฟซใน Windows NT และ Windows 95 ใช้ Unicode แบบเอกสิทธิ์เฉพาะบุคคล ANSI รุ่นฟังก์ชันเหล่านี้จะไม่ใช้งานอย่างใดอย่างหนึ่ง บน Windows NT หรือ Windows 95

ซึ่งหมายความ ว่า โปรแกรมประยุกต์แบบ 32 บิตที่จำเป็นต้องทำงานบน Windows 95 และ Windows NT ต้องใช้ฟังก์ชันไม่ใช่ - OLE Win32 รุ่น ANSI และต้องแปลงสายอักขระ ANSI เป็น Unicode ก่อนที่จะถูกส่งผ่านไป OLE

โปรแกรมประยุกต์ Unicode 32 บิตที่ทำงานบน Windows NT เท่านั้นไม่จำเป็นต้องใช้ฟังก์ชันการแปลง ANSI/Unicode ใด ๆ

win32 ให้ MultiByteToWideChar และ WideCharToMultiByte การแปลงสายอักขระ ANSI เพื่อ Unicode และสายอักขระ Unicode ANSI บทความนี้แสดง 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 ถูกนำมาใช้เพื่อจัดสรรสตริการ สายอักขระที่แปลงแล้วต้องไม่สามารถลงถ้าได้ถูกส่งกลับโดยผ่านการออกแบบพารามิเตอร์องค์ประกอบของ 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 สรร) ไม่จำเป็นที่จะใช้เฉพาะใน กรณีที่สายอักขระ resultant จะถูกส่งผ่านไปยังคอมโพเนนต์ OLE อื่น และ หากคอมโพเนนต์นั้นสามารถว่างสายอักขระ หมายนี้ความว่า strings ที่ผ่านไปยังวิธีการอินเทอร์เฟซ OLE เป็นพารามิเตอร์ ต้องไม่ใช้ตัวจัดสรร OLE สายอักขระที่ส่งผ่านไปเป็นในออกพารามิเตอร์ หรือส่งกลับผ่านพารามิเตอร์ออกหรือในออกพารามิเตอร์ ต้องมีการปันส่วนโดยใช้ตัวจัดสรร OLE

ค่าคงที่สายอักขระสามารถถูกแปลงเป็น Unicode เวลาในการคอมไพล์ โดยใช้แมโคร OLESTR ตัวอย่าง::
CreateFileMoniker(OLESTR("c:\\boo\\har.doc"), &pmk);
				
ตัวอย่างอื่นของ ANSI/Unicode แปลงตามปกติสามารถพบได้ในรหัสต้นทาง Microsoft มูลฐานระดับชั้น (MFC) ที่จัดส่ง ด้วยคอมไพเลอร์ 4.0 c ++ Visual ตามปกติเหล่านี้จะอธิบายไว้ใน 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 หรือ ANSI ขึ้นอยู่กับว่าคำนิยาม preprocessor _UNICODE ที่ถูกทำ ตัวอย่างเช่น เรียก 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)
				
t ใน T2OLE บ่งชี้ว่า ชนิดจะถูกแปลงเป็นสตริ OLE (สายอักขระ Unicode) เป็นสายอักขระ Unicode เมื่อมีกำหนด _UNICODE และสตริ ANSI เมื่อไม่มีกำหนด _UNICODE ในทำนองเดียวกัน LPTSTR ถูกกำหนด เป็นตัวชี้ไปสายอักขระ Unicode เมื่อมีกำหนด _UNICODE และ เป็นตัวชี้การสตริ ANSI เมื่อไม่มีกำหนด _UNICODE 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 จัดสรรเนื้อที่จากกองซ้อนของโปรแกรมสำหรับสายอักขระที่แปลงแล้ว ช่องว่างมี deallocated โดยอัตโนมัติเมื่อมีการเรียกขั้นตอนเสร็จเรียบร้อยแล้ว ole ต้องการจัดสรร OLE ที่จะใช้สำหรับทุกสตริง (ข้อมูล) ที่จะถูกปันส่วน โดยคอมโพเนนต์หนึ่ง และลงตามอื่น ซึ่งหมายความ ว่า สายอักขระที่ส่งผ่านผ่านพารามิเตอร์ออก และต้องมีการปันส่วนในออกพารามิเตอร์ของอินเทอร์เฟซการ OLE มีตัวจัดสรร OLE -พารามิเตอร์ต้องไม่สามารถจัดสรร มีตัวจัดสรร OLE ได้เนื่องจากผู้เรียกรับผิดชอบในการเพิ่มแฟ้มเหล่านั้น เฟซ Linking/Embedding OLE และ API ส่วนใหญ่ผ่านสตริงการเป็นในพารามิเตอร์ ดังนั้น สามารถใช้แมโครการแปลง MFC โดยส่วนใหญ่ ไม่สามารถใช้แมโครการแปลง MFC สำหรับพารามิเตอร์ในหมด หรือ สำหรับการส่งกลับค่าผ่านพารามิเตอร์ออกได้เนื่องจากพวกเขาไม่จัดสรรเนื้อที่ที่ใช้ตัวจัดสรร OLE AnsiToUnicode และ UnicodeToAnsi สามารถใช้ในกรณีดังกล่าว

ได้ ตามปกติแปลง Unicode/ANSI ชุดอื่นสามารถค้นหาในคอลัมน์ของกล่องจะบน OLE ในสมุดรายวันการระบบ Microsoft, 1995 สิงหาคม Vol. 10 หมายเลข 8, 86 หน้า Don Box defines a C++ class with a cast operator which will return a Unicode/ANSI converted string. The allocated space is automatically freed when the object goes out of scope. This class can be modified to allocate using the OLE allocator and to not free the allocated space for strings that are passed through in-out or out- parameters.

One of the classes, String16, from Don Box's column which converts an ANSI string to Unicode, follows. Another class, String8, that is similar to this one is used for ANSI to Unicode conversion. The CreateFileMoniker call from the previous example can be made as follows with this class:
GetOpenFileName(&ofn);
CreateFileMoniker(String16(ofn.lpstrFile), &pmk);
				
In the above code, an instance of String16 is created. The constructor of the class will convert the ANSI string to Unicode. The language implementation will call the cast operator, operator const wchar_t *, to cast this parameter to the type of of CreateFileMoniker's first parameter. The cast operator will return the Unicode string which is passed to CreateFileMoniker. The object will destruct when in goes out of scope.
// 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;

}
				

คุณสมบัติ

หมายเลขบทความ (Article ID): 138813 - รีวิวครั้งสุดท้าย: 6 มกราคม 2554 - Revision: 2.0
Keywords: 
kbcode kbhowto kbprogramming kbmt KB138813 KbMtth
แปลโดยคอมพิวเตอร์
ข้อมูลสำคัญ: บทความนี้แปลโดยซอฟต์แวร์การแปลด้วยคอมพิวเตอร์ของ Microsoft แทนที่จะเป็นนักแปลที่เป็นบุคคล Microsoft มีบทความที่แปลโดยนักแปลและบทความที่แปลด้วยคอมพิวเตอร์ เพื่อให้คุณสามารถเข้าถึงบทความทั้งหมดในฐานความรู้ของเรา ในภาษาของคุณเอง อย่างไรก็ตาม บทความที่แปลด้วยคอมพิวเตอร์นั้นอาจมีข้อบกพร่อง โดยอาจมีข้อผิดพลาดในคำศัพท์ รูปแบบการใช้ภาษาและไวยากรณ์ เช่นเดียวกับกรณีที่ชาวต่างชาติพูดผิดเมื่อพูดภาษาของคุณ Microsoft ไม่มีส่วนรับผิดชอบต่อความคลาดเคลื่อน ความผิดพลาดหรือความเสียหายที่เกิดจากการแปลเนื้อหาผิดพลาด หรือการใช้บทแปลของลูกค้า และ Microsoft มีการปรับปรุงซอฟต์แวร์การแปลด้วยคอมพิวเตอร์อยู่เป็นประจำ
ต่อไปนี้เป็นฉบับภาษาอังกฤษของบทความนี้:138813

ให้ข้อเสนอแนะ

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com