How to: conversione da ANSI a Unicode & Unicode ad ANSI per OLE

Il presente articolo è stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell’utente. Tuttavia, un articolo tradotto in modo automatico non è sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, più o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non è la sua. Microsoft non è responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell’utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.

Clicca qui per visualizzare la versione originale in inglese dell’articolo: 138813
Sommario
Tutte le stringhe che vengono passate a e ricevute da OLE API a 32 bit e i metodi di interfaccia utilizzano Unicode. Questa operazione richiede applicazioni che utilizzano stringhe ANSI per convertirli in Unicode prima di passarli a OLE e per convertire le stringhe Unicode ricevuti da OLE al formato ANSI. In questo articolo viene illustrato come sono possibile queste conversioni.
Informazioni
Windows NT implementa Unicode (o caratteri estesi) e versioni ANSI di funzioni Win32 che accettano i parametri della stringa. Tuttavia Windows 95 non implementa la versione Unicode della maggior parte delle funzioni di Win32 che accettano i parametri della stringa. Implementa invece solo le versioni ANSI di queste funzioni.

Un'eccezione principale a questa regola è OLE a 32 bit. OLE API a 32 bit e i metodi di interfaccia in Windows NT e Windows 95 utilizzano Unicode in modo esclusivo. Le versioni ANSI di queste funzioni non sono implementate su Windows NT o Windows 95.

Ciò significa che un'applicazione a 32 bit che deve eseguire nel sia Windows 95 e Windows NT deve utilizzare le versioni di ANSI delle funzioni non OLE Win32 e deve convertire stringhe ANSI in Unicode prima che vengano passati a OLE.

Un'applicazione di Unicode di 32 bit che viene eseguita solo in Windows NT non necessario utilizzare le funzioni di conversione ANSI/Unicode.

Win32 sono disponibili MultiByteToWideChar e WideCharToMultiByte per convertire stringhe ANSI a Unicode e le stringhe Unicode in formato ANSI. In questo articolo vengono fornite AnsiToUnicode e UnicodeToAnsi, che utilizza queste funzioni per la conversione 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;}				
utilizzo di esempio di queste funzioni è la seguente. CoTaskMemFree viene utilizzata per liberare la stringa convertita se è stato utilizzato CoTaskMemAlloc per allocare la stringa. La stringa convertita deve non liberata se viene restituito tramite un parametro di uscita a un altro componente OLE, poiché tale componente è responsabile di liberare la stringa. LPOLESTR è un puntatore a una stringa 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.lpstrFileGetOpenFileName(&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);}				
Nota : commenti in AnsiToUnicode e UnicodeToAnsi riguardanti l'allocatore di viene utilizzato per allocare la stringa convertita. CoTaskMemAlloc (l'allocatore OLE) è necessario per essere utilizzato solo se la stringa risultante sarà essere passata un altro componente OLE e se tale componente è possibile liberare la stringa. Ciò significa che le stringhe che viene passati come in parametri metodi di interfaccia OLE non necessario utilizzare l'allocatore OLE. Stringhe che vengono passate come in uscita-parametri o restituite tramite parametri out o in uscita-parametri devono essere allocate utilizza l'allocatore di OLE.

Costanti di stringa possono essere convertite in Unicode in fase di compilazione utilizzando la macro OLESTR. Ad esempio:
CreateFileMoniker(OLESTR("c:\\boo\\har.doc"), &pmk);				
un altro esempio di routine di conversione ANSI/Unicode può trovarsi nel codice sorgente Microsoft Foundation Classes (MFC) fornito con il compilatore Visual c ++ 4.0. Queste routine descritti nella nota tecnica MFC 59: 'Utilizzo di macro di conversione MBCS/Unicode di MFC'. La definizione di queste macro OLE2T, T2OLE, OLE2CT, T2COLE, A2W, W2A, A2CW, W2CA e USES_CONVERSION sono in \msdev\mfc\include\afxpriv.h. Consente di vedere anche AfxA2WHelper e AfxW2AHelper nel codice sorgente MFC in \msdev\mfc\src e l'utilizzo di OLE2T, T2OLE, OLE2CT e T2COLE nel codice sorgente MFC in \msdev\mfc\src. Queste funzioni consentono codice essere compilato per Unicode o ANSI a seconda se è stata effettuata la definizione del preprocessore _UNICODE. Ad esempio, la chiamata di CreateFileMoniker nell'esempio precedente è possibile eseguire come indicato di seguito con le macro MFC:
USES_CONVERSION;GetOpenFileName(&ofn);CreateFileMoniker(T2OLE(ofn.lpstrFile), &pmk);				
se è stato definito _UNICODE, T2OLE viene definita come segue:
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }				
se non è definito _UNICODE, T2OLE viene definita come segue:
#define T2OLE(lpa) A2W(lpa)				
T in T2OLE indica che il tipo da convertire in una stringa OLE (stringa Unicode) è una stringa Unicode quando viene definito _UNICODE ed è una stringa ANSI quando non è definito _UNICODE. Allo stesso modo LPTSTR viene definita come un puntatore a una stringa Unicode quando viene definito _UNICODE e come un puntatore a una stringa ANSI quando non è definito _UNICODE. T2OLE non qualsiasi conversione quando viene definito _UNICODE (LPTSTR == LPOLESTR). Quando Unicode non è definito, viene chiamato A2W. A2W converte una stringa ANSI in Unicode come segue:
#define A2W(lpa) (\         ((LPCSTR)lpa == NULL) ? NULL : (\             _convert = (strlen(lpa)+1),\             AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\         )\ )				
AfxA2WHelper utilizza MultiByteToWideChar per la conversione.

Le macro della conversione di MFC utilizzare _alloca per allocare spazio di stack del programma per la stringa convertita. Lo spazio viene deallocato automaticamente quando la chiamata di routine è stata completata. OLE è necessario l'allocatore OLE da utilizzare per tutte le stringhe (dati) che verranno allocate da un componente e liberate da un'altra. Ciò significa che le stringhe passate tramite parametri out e in uscita-parametri di interfacce OLE devono essere allocati con l'allocatore OLE. In parametri non necessario allocati con l'allocatore OLE poiché il chiamante è responsabile di liberare i. La maggior parte delle API e le interfacce OLE di collegamento/Embedding passare stringhe come in parametri. Di conseguenza, le macro della conversione di MFC possono essere utilizzate nella maggior parte dei casi. Impossibile utilizzare le macro della conversione di MFC per i parametri in / out o per la restituzione di valori tramite parametri di uscita poiché che non allocano spazio utilizzando l'allocatore OLE. In questi casi è possibile utilizzare AnsiToUnicode e UnicodeToAnsi.

Ancora un'altra serie di routine di conversione Unicode/ANSI sono reperibili nella colonna di Don Box OLE in Microsoft Systems Journal, agosto 1995, Vol 10 Nr. 8, 86 della pagina. Don Box definisce una classe di c ++ con un operatore cast che restituirà una stringa di conversione Unicode/ANSI. Lo spazio allocato viene liberato automaticamente quando l'oggetto esce dall'ambito. Questa classe può essere modificata per allocare utilizza l'allocatore di OLE e non liberare lo spazio allocato per le stringhe passate tramite in out o parametri out.

Una delle classi String16, dalla colonna di Don Box che converte una stringa ANSI in Unicode, segue. Un'altra classe, String8, simile a questo viene utilizzata per ANSI per la conversione Unicode. Può essere effettuata la chiamata CreateFileMoniker dell'esempio precedente come indicato di seguito con questa classe:
GetOpenFileName(&ofn);CreateFileMoniker(String16(ofn.lpstrFile), &pmk);				
in codice precedente, viene creata un'istanza di String16. Il costruttore della classe convertirà la stringa ANSI in Unicode. L'implementazione del linguaggio chiamerà l'operatore di cast, l'operatore const wchar_t *, il cast di questo parametro al tipo di primo parametro del CreateFileMoniker. L'operatore di cast restituirà la stringa Unicode che viene passata a CreateFileMoniker. L'oggetto verrà distruggere in va rientra nell'ambito.
// String16 //////////////////////////////////////////////////////// // Shim class that converts both 8-bit (foreign) and// 16-bit (native) strings to 16-bit widenessclass 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-throughinline String16::String16(const wchar_t *p16): m_sz((wchar_t *)p16), m_bIsForeign(FALSE){}// simply give out the native wideness stringinline String16::operator const wchar_t * (void) const{  return m_sz;}// foreign constructor requires allocation of a native// string and conversioninline 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 constructorinline String16::~String16(void) {  if (m_bIsForeign)    delete[] m_sz;}				
convertire le funzioni di routine di supporto

Avviso: questo articolo è stato tradotto automaticamente

Proprietà

ID articolo: 138813 - Ultima revisione: 03/16/2005 20:45:27 - Revisione: 2.4

Microsoft OLE 4.0

  • kbmt kbcode kbhowto kbprogramming KB138813 KbMtit
Feedback