Jak převést ze standardu ANSI na kódování Unicode & Unicode na ANSI technologie OLE

Překlady článku Překlady článku
ID článku: 138813
Rozbalit všechny záložky | Minimalizovat všechny záložky

Souhrn

Všechny řetězce, které jsou předány a obdržela od rozhraní OLE API 32bitového a Unicode použít metody rozhraní. To vyžaduje, aby aplikace, které používají kódování ANSI řetězce převést do kódování Unicode před jejich předáním OLE a do Převod řetězce Unicode na ANSI přijaté od OLE. To článek ukazuje, jak lze tyto převody provádí.

Další informace

Systém Windows NT implementuje Unicode (nebo znaků) a verze ANSI Funkce systému Win32, které parametry řetězce. Avšak systém Windows 95 nepodporuje implementovat verzi většinu funkcí Win32, které řetězce Unicode Parametry. Místo toho implementuje pouze verze ANSI těchto funkce.

Hlavní výjimkou tohoto pravidla je 32bitové OLE. OLE 32bitové rozhraní API a Unicode použít metody rozhraní v systému Windows NT a Windows 95 výhradně. Verze ANSI tyto funkce nejsou implementovány buď v systému Windows NT nebo Windows 95.

To znamená, že 32bitová aplikace, které potřebuje spustit i Windows 95 a Windows NT, musíte použít z non - OLE Win32 verze ANSI funkce a musíte převést řetězce ANSI na kódování Unicode, předtím, než jsou předáno OLE.

Je třeba používat 32bitová aplikace Unicode, který pracuje pouze v systému Windows NT všechny funkce pro převod kódování ANSI nebo Unicode.

Poskytuje Win32 MultiByteToWideChar a WideCharToMultiByte převést Řetězce ANSI do kódování Unicode a řetězce Unicode na ANSI. V tomto článku poskytuje AnsiToUnicode a Unicode-ANSI, který používá tyto funkce pro Převod kódování ANSI nebo 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;

}
				
Ukázka použití těchto funkcí je takto. CoTaskMemFree se používá k Uvolněte převedeného řetězec, pokud CoTaskMemAlloc byla použita pro přidělení řetězec. Převedeného řetězec musí uvolněna, pokud je vrácena prostřednictvím o out parametru do jiné součásti OLE protože je tato komponenta za uvolňování řetězec. LPOLESTR je ukazatel na Unicode řetězec.
// 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);

}
				
POZNÁMKA:: Poznámky v AnsiToUnicode a Unicode-ANSI týkající přidělování, který slouží k přidělení převedeného řetězec. CoTaskMemAlloc (alokátor OLE), je nutné použít, pouze pokud výsledný řetězec budou předány jiným součást OLE a je-li komponenta můžete uvolnit. řetězec. To znamená, řetězce, které jsou předány jako v parametry Metody rozhraní OLE nutné pomocí přidělování OLE. Řetězce, které jsou předána jako parametry v nepřítomnosti nebo vráceny out parametry nebo v- Nedostatek parametrů musí být přidělena přidělování OLE.

Řetězcové konstanty lze převést do kódování Unicode při kompilaci pomocí Makro OLESTR. Například:
CreateFileMoniker(OLESTR("c:\\boo\\har.doc"), &pmk);
				
Dalším příkladem ANSI nebo Unicode conversion rutin lze nalézt v Microsoft Foundation tříd MFC zdrojový kód, který se dodává s Kompilátor Visual C++ 4.0. Tyto rutiny, které jsou popsány v dokumentu Technote MFC 59: Použití makra převod znakové sady MBCS MFC/Unicode. Definice těchto makra OLE2T, T2OLE, OLE2CT, T2COLE, A2W, W2A, A2CW, W2CA a USES_CONVERSION jsou v \msdev\mfc\include\afxpriv.h. Viz také AfxA2WHelper a AfxW2AHelper v jednotka MFC zdrojový kód v \msdev\mfc\src a použití OLE2T, T2OLE, OLE2CT a T2COLE ve zdrojovém kódu v MFC \msdev\mfc\src. Tyto funkce umožňují kód bude zkompilován buď pro Unicode nebo ANSI v závislosti na tom, zda _UNICODE preprocesoru definice byla provedena. Například volání CreateFileMoniker výše uvedené příkladu lze provést takto s makry MFC:
USES_CONVERSION;
GetOpenFileName(&ofn);
CreateFileMoniker(T2OLE(ofn.lpstrFile), &pmk);
				
Pokud je definován _UNICODE, T2OLE je definován takto:
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
				
Pokud není definována _UNICODE, T2OLE je definován takto:
#define T2OLE(lpa) A2W(lpa)
				
T v T2OLE označuje, že typ převáděna na řetězec OLE (Řetězec Unicode) je řetězec znaků Unicode je definován _UNICODE a vlastní Řetězec ANSI při _UNICODE není definována. Podobně, LPTSTR je definován jako ukazatel na řetězec Unicode, pokud je definován _UNICODE a jako ukazatel řetězec ANSI při _UNICODE není definována. T2OLE neprovádí žádné převod při definování _UNICODE (LPTSTR == LPOLESTR). Při kódování Unicode nejsou definovány, se nazývá A2W. A2W převede řetězec ANSI na kódování Unicode jako takto:
#define A2W(lpa) (\ 
        ((LPCSTR)lpa == NULL) ? NULL : (\ 
            _convert = (strlen(lpa)+1),\ 
            AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\ 
        )\ 

)
				
AfxA2WHelper používá MultiByteToWideChar provést převod.

Převod makra MFC použijte alokování z programu _alloca Zásobník pro převedeného řetězec. Prostor je automaticky deallocated Při volání procedury byla dokončena. OLE vyžaduje přidělování OLE k použít pro všechny řetězce (data), které bude přiděleno jedno součástí a uvolněné jiným. To znamená, že řetězce prochází out- parametry a v out parametry rozhraní OLE musí být přidělena s přidělování OLE. V parametrech třeba nelze přidělit OLE přidělování protože volající je odpovědný za jejich uvolnění. Většina Propojování a vkládání objektů OLE rozhraní a rozhraní API předat jako parametry do řetězce. V důsledku převodu MFC makra lze ve většině případů. Na MFC Převod makra nelze použít pro parametry-out nebo vracení hodnot mimo parametry, protože nelze přidělit místo pomocí přidělujícího modulu OLE. Může být AnsiToUnicode a Unicode-ANSI v těchto případech použít.

Ještě jinou sadu Unicode a ANSI převodu rutin lze nalézt v Don Sloupce pole na OLE v deníku systémy společnosti Microsoft, srpen 1995 objemových 10 Číslo 8, 86 stránky. Don pole definuje třídu jazyka C++ s operátorem cast které Vrátí řetězec Unicode a ANSI převedeny. Přidělený prostor je uvolněna automaticky, když se objekt dostane mimo rozsah. Tato třída může být upravené přidělit pomocí přidělujícího modulu OLE a uvolnit místo přidělené pro řetězce, které jsou předávány prostřednictvím-out nebo out- Parametry.

Jedné ze tříd, String16, ze sloupce Don pole, která převede Řetězec ANSI, Unicode, následuje. Jiné třídy String8 nebo podobná k této se používá pro ANSI pro převod znakové sady Unicode. Na CreateFileMoniker volání z předchozího příkladu lze provést takto Pomocí této třídy:
GetOpenFileName(&ofn);
CreateFileMoniker(String16(ofn.lpstrFile), &pmk);
				
Výše uvedený kód je vytvořena instance String16. Konstruktor třídy převede řetězec ANSI na kódování Unicode. Jazyk implementace bude volat operátor přetypování, operátor const wchar_t *, Chcete-li tento parametr typu CreateFileMoniker odevzdaných programu první parametr. Vrátí řetězec znaků Unicode, což je operátoru přetypování předány CreateFileMoniker. Objekt bude destruct v přejde mimo oboru.
// 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;

}
				

Vlastnosti

ID článku: 138813 - Poslední aktualizace: 23. dubna 2011 - Revize: 4.0
Klíčová slova: 
kbcode kbhowto kbprogramming kbmt KB138813 KbMtcs
Strojově přeložený článek
Důležité: Tento článek byl přeložen pomocí software společnosti Microsoft na strojový překlad, ne profesionálním překladatelem. Společnost Microsoft nabízí jak články přeložené překladatelem, tak články přeložené pomocí software na strojový překlad, takže všechny články ve Znalostní databázi (Knowledge Base) jsou dostupné v češtině. Překlad pomocí software na strojový překlad ale není bohužel vždy dokonalý. Obsahuje chyby ve skloňování slov, skladbě vět, nebo gramatice, podobně jako když cizinci dělají chyby při mluvení v češtině. Společnost Microsoft není právně zodpovědná za nepřesnosti, chyby nebo škody vzniklé chybami v překladu, nebo při použití nepřesně přeložených instrukcí v článku zákazníkem. Společnost Microsoft aktualizuje software na strojový překlad, aby byl počet chyb omezen na minimum.
Projděte si také anglickou verzi článku:138813

Dejte nám zpětnou vazbu

 

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