Gewusst wie: Konvertieren von ANSI in Unicode & Unicode zu ANSI für OLE

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 138813 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Zusammenfassung

Alle Zeichenfolgen, die übergeben und Empfangen von 32-Bit-OLE-APIs und Schnittstellenmethoden werden verwendet, Unicode. Dies erfordert Anwendungen, die ANSI-Zeichenfolgen verwenden, um Sie in Unicode zu konvertieren, bevor diese an OLE übergeben und Unicode-Zeichenfolgen zu konvertieren, die von OLE in ANSI empfangen werden. Dieser Artikel beschreibt, wie diese Konvertierungen erfolgen können.

Weitere Informationen

Windows NT Unicode (oder Breitzeichen) implementiert und ANSI-Versionen von Win32-Funktionen, die Parameter akzeptieren. Windows 95 implementiert jedoch nicht der Unicodeversion der meisten Win32-Funktionen, die Parameter akzeptieren. Stattdessen wird nur die ANSI-Versionen dieser Funktionen implementiert.

Eine wichtige Ausnahme dieser Regel ist 32-Bit-OLE. 32-Bit-OLE-APIs und Methoden der Schnittstelle unter Windows NT und Windows 95 verwenden Unicode exklusiv. ANSI-Versionen dieser Funktionen sind nicht auf Windows NT oder Windows 95 implementiert.

Dies bedeutet, dass eine 32-Bit-Anwendung, die unter Windows 95 und Windows NT ausgeführt werden muss die ANSI-Versionen von Win32 den nicht-OLE-Funktionen verwenden muss und muss ANSI-Zeichenfolgen in Unicode konvertieren, bevor diese an OLE übergeben werden.

Eine 32-Bit-Unicode-Anwendung, die nur unter Windows NT ausgeführt wird muss keine ANSI-Unicode-Konvertierungsfunktionen verwenden.

Win32 bietet MultiByteToWideChar und WideCharToMultiByte ANSI-Zeichenfolgen in Unicode und Unicode-Zeichenfolgen in ANSI zu konvertieren. Dieser Artikel bietet AnsiToUnicode und UnicodeToAnsi, die diese Funktionen für die Konvertierung von ANSI-Unicode verwendet.
/*
 * 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;

}
				
Beispiel Verwendung dieser Funktionen ist wie folgt. CoTaskMemFree wird verwendet, um die konvertierte Zeichenfolge freizugeben, wenn CoTaskMemAlloc zum Reservieren der Zeichenfolge verwendet wurde. Die konvertierte Zeichenfolge muss nicht freigegeben werden Wenn Sie über einen Out-Parameter zu einer anderen OLE-Komponente zurückgegeben wird, da die Komponente für die Zeichenfolge freigeben zuständig ist. LPOLESTR ist ein Zeiger auf eine Unicode-Zeichenfolge.
// 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);

}
				
Hinweis : Kommentare im AnsiToUnicode und UnicodeToAnsi bezüglich der Zuweisung, mit der die konvertierte Zeichenfolge zuweisen. CoTaskMemAlloc (die OLE-Zuweisung) ist erforderlich, verwendet werden, nur, wenn die resultierende Zeichenfolge an einem anderen OLE-Komponente übergeben werden und wenn die Komponente die Zeichenfolge freigeben kann. Dies bedeutet, die Zeichenfolgen, die als in-Parameter an Methoden des OLE-Schnittstelle übergeben werden müssen die OLE-Zuweisung nicht verwenden. Zeichenfolgen, die als Out-Parameter übergeben oder durch Out-Parameter oder Out-Parameter zurückgegeben werden müssen mit der OLE-Zuweisung reserviert werden.

Zeichenfolgenkonstanten können in Unicode zur Kompilierzeit konvertiert werden, mithilfe des OLESTR-Makros. Zum Beispiel:
CreateFileMoniker(OLESTR("c:\\boo\\har.doc"), &pmk);
				
anderen Konvertierungsroutinen ANSI-Unicode-Beispiel kann in der Microsoft Foundation Classes (MFC)-Quellcode der im Lieferumfang des Compilers Visual C++ 4.0 gefunden werden. Diese Routinen in MFC TechNote 59 beschrieben werden: "Using MFC MBCS/Unicode-Konvertierung Makros". Die Definition sind diese Makros OLE2T, T2OLE, OLE2CT, T2COLE, A2W, W2A, A2CW, W2CA und USES_CONVERSION in \msdev\mfc\include\afxpriv.h. Siehe auch AfxA2WHelper und AfxW2AHelper im MFC-Quellcode in \msdev\mfc\src und die Verwendung von OLE2T, T2OLE, OLE2CT und T2COLE in der MFC-Quellcode im \msdev\mfc\src ein. Diese Funktionen ermöglichen Code entweder für Unicode oder ANSI abhängig, ob die _UNICODE-Präprozessordefinition vorgenommen wurde kompiliert werden. Z. B. der Aufruf CreateFileMoniker in das obige Beispiel kann vorgenommen werden wie folgt mit MFC-Makros:
USES_CONVERSION;
GetOpenFileName(&ofn);
CreateFileMoniker(T2OLE(ofn.lpstrFile), &pmk);
				
Wenn _UNICODE definiert ist, ist wie folgt T2OLE definiert:
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
				
Wenn _UNICODE nicht definiert ist, ist wie folgt T2OLE definiert:
#define T2OLE(lpa) A2W(lpa)
				
T in T2OLE gibt an, dass der Typ wird in ein OLE-Zeichenfolge (Unicode-Zeichenfolge) konvertiert eine Unicodezeichenfolge, wenn _UNICODE definiert ist und eine ANSI-Zeichenfolge wird, wenn _UNICODE definiert ist. Ebenso ist LPTSTR definiert als ein Zeiger auf eine Unicodezeichenfolge Wenn _UNICODE definiert ist und als ein Zeiger auf eine ANSI-Zeichenfolge, wenn _UNICODE definiert ist. T2OLE macht Konvertierung nicht, wenn _UNICODE definiert ist (LPTSTR == LPOLESTR). Wenn die Unicode nicht definiert ist, wird A2W aufgerufen. A2W wie folgt konvertiert eine ANSI-Zeichenfolge in Unicode:
#define A2W(lpa) (\ 
        ((LPCSTR)lpa == NULL) ? NULL : (\ 
            _convert = (strlen(lpa)+1),\ 
            AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\ 
        )\ 

)
				
AfxA2WHelper verwendet MultiByteToWideChar um die Konvertierung durchzuführen.

Die MFC-Konvertierung Makros verwenden _alloca Speicherplatz aus den Programmstapel für die konvertierte Zeichenfolge zuweisen. Der Speicherplatz wird automatisch freigegeben, wenn der Prozeduraufruf abgeschlossen wurde. OLE erfordert die OLE-Zuweisung für alle Zeichenfolgen (Daten) verwendet werden, die von einer Komponente zugeordneten und von einem anderen freigegeben werden. Dies bedeutet, dass Zeichenfolgen durch Out-Parameter übergeben und in-Out-Parameter des OLE-Schnittstellen mit der OLE-Zuweisung zugewiesen werden müssen. In-Parameter müssen nicht mit der OLE-Zuweisung reserviert werden, da der Aufrufer für diese Freigabe zuständig ist. Die meisten Verknüpfungen-einbetten OLE-Schnittstellen und API-Zeichenfolgen als in-Parameter übergeben. Daher können die Konvertierung MFC-Makros in den meisten Fällen verwendet werden. MFC-Konvertierung Makros können nicht für in Out-Parameter oder Werte über Out-Parameter zurückgeben, da Sie nicht mit der OLE-Zuweisung Speicherplatz reservieren verwendet werden. In diesen Fällen können AnsiToUnicode und UnicodeToAnsi verwendet werden.

Noch kann einen anderen Satz von Unicode-ANSI-Konvertierungsroutinen in Spalte von Don Box auf OLE in Microsoft Systems Journal August 1995 Band 10 Nr. 8 Seiten 86 gefunden werden. Don Box definiert eine C++-Klasse mit einem Umwandlungsoperator der Unicode/ANSI konvertiert Zeichenfolge zurückgegeben wird. Der reservierte Speicher wird automatisch freigegeben, wenn das Objekt den Gültigkeitsbereich verlässt. Diese Klasse kann geändert werden, um mit der OLE-Zuweisung zuordnen und nicht der reservierte Speicher für Zeichenfolgen freizugeben, die in Out oder Out-Parameter übergeben werden.

Eine der Klassen, String16, von Don Box-Spalte, die eine ANSI-Zeichenfolge in Unicode konvertiert folgt. Eine andere Klasse, String8 angehören, die diesem ähnelt wird für ANSI zu Unicode-Konvertierung verwendet. Der Aufruf CreateFileMoniker aus dem vorherigen Beispiel kann wie folgt mit dieser Klasse vorgenommen werden:
GetOpenFileName(&ofn);
CreateFileMoniker(String16(ofn.lpstrFile), &pmk);
				
im obigen Code eine Instanz der String16 wird erstellt. Der Konstruktor der Klasse wird die ANSI-Zeichenfolge in Unicode konvertiert. Der Sprachimplementierung wird aufgerufen, der Typumwandlungs-Operators, der Operator const Wchar_t *, um diesen Parameter den Typ des CreateFileMoniker des ersten Parameters umgewandelt. Typumwandlungs-Operators wird die Unicode-Zeichenfolge zurückgegeben, der an die CreateFileMoniker übergeben wird. Das Objekt wird in geht außerhalb des Gültigkeitsbereichs Zerstörung.
// 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;

}
				

Eigenschaften

Artikel-ID: 138813 - Geändert am: Mittwoch, 16. März 2005 - Version: 2.4
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft OLE 4.0, wenn verwendet mit:
    • Microsoft Windows NT 3.51 Service Pack 5
    • Microsoft Windows NT 4.0
    • Microsoft Windows 95
Keywords: 
kbmt kbcode kbhowto kbprogramming KB138813 KbMtde
Maschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 138813
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

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