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

Traduzione articoli Traduzione articoli
Identificativo articolo: 138813 - Visualizza i prodotti a cui si riferisce l?articolo.
Espandi tutto | Chiudi tutto

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.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);

}
				
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 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;

}
				

ProprietÓ

Identificativo articolo: 138813 - Ultima modifica: mercoledý 16 marzo 2005 - Revisione: 2.4
Le informazioni in questo articolo si applicano a:
  • Microsoft OLE 4.0áalle seguenti piattaforme
    • Microsoft Windows NT 3.51 Service Pack 5
    • Microsoft Windows NT 4.0
    • Microsoft Windows 95
Chiavi:á
kbmt kbcode kbhowto kbprogramming KB138813 KbMtit
Traduzione automatica articoli
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
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

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