Ako previesť z ANSI & Unicode Unicode do formátu ANSI pre OLE

Preklady článku Preklady článku
ID článku: 138813
Rozbaliť všetko | Zbaliť všetko

SUHRN

Všetky reťazce, ktoré sú postúpené a dostala od 32-bitové OLE API a rozhranie metódy používať kódovanie Unicode. To si vyžaduje aplikácie, ktoré používajú ANSI reťazce skonvertovať na Unicode pred absolvovanie im do OLE a s Konverzia Unicode reťazce, ktoré sú obdržané od OLE ANSI. Toto článok ukazuje, ako možno tieto prevody urobiť.

DALSIE INFORMACIE

Windows NT implementuje Unicode (alebo širokých znakov) a ANSI verzie Win32 funkcie, ktoré využívajú parametrov reťazca. Avšak systém Windows 95 nepodporuje implementovať Unicode verzia väčšine Win32 funkcie, ktoré využívajú reťazec parametre. Namiesto toho implementuje iba ANSI verzie týchto funkcie.

Hlavné výnimkou tohto pravidla je 32-bitové OLE. 32-bitový OLE API a rozhranie metódy na Windows NT a Windows 95 používajú výlučne Unicode. ANSI verzie tieto funkcie nie sú implementované buď na Windows NT alebo Windows 95.

To znamená, že 32-bitové aplikácie, ktoré potrebuje na spustenie na obe okná 95 a Windows NT musí používať ANSI verzie z non - OLE Win32 funkcie a musí previesť ANSI struny do Unicode skôr, ako sú odovzdaný OLE.

32-Bitová aplikácia Unicode, ktorý beží iba na Windows NT potrebujú používať funkcie pre konverziu akéhokoľvek ANSI/Unicode.

Win32 poskytuje MultiByteToWideChar a WideCharToMultiByte na konverziu ANSI reťazce na znaky Unicode a reťazcov Unicode do formátu ANSI. Tento článok poskytuje AnsiToUnicode a UnicodeToAnsi, ktorý používa tieto funkcie ANSI/Unicode konverzie.
/*
 * 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;

}
				
Vzorky používanie týchto funkcií je. CoTaskMemFree sa používa na Voľný konvertované reťazec, ak CoTaskMemAlloc bolo použité na pridelenie reťazec. Konvertovaný reťazec musí byť uvoľnený nie vrátené prostredníctvom an out-parameter iného komponentu OLE, pretože tento komponent je zodpovedný za uvoľnenie reťazec. LPOLESTR je smerník na Unicode reťazec.
// 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 UnicodeToAnsi týkajúce sa prideľovacieho koeficientu, ktorý sa používa na pridelenie konvertované reťazec. CoTaskMemAlloc (OLE prideľovača) je potrebné používať, len ak výsledný reťazec budú prenesené na inom OLE komponentu, a ak môžete uvoľniť tento komponent reťazec. To znamená, že struny, ktoré prechádzajú ako v-parametre OLE rozhranie metódami potrebujú nesmie používať OLE prideľovača. Reťazce, ktoré sú ako v-out-parametre alebo vrátené prostredníctvom out-parametre alebo v- out-parametre musia prideliť pomocou OLE prideľovača.

Reťazcové konštanty možno previesť do Unicode pri kompilácii pomocou OLESTR makro. Napríklad:
CreateFileMoniker(OLESTR("c:\\boo\\har.doc"), &pmk);
				
Ďalším príkladom ANSI/Unicode konverzie rutiny možno nájsť v Microsoft nadácie tried (MFC) zdrojový kód, ktorý sa dodáva s Vizuálne 4.0 c ++ kompilátor. Tieto rutiny sú opísané v MFC Technote 59: Používanie MFC. MBCS/Unicode konverzie makrá. Definícia týchto makrá OLE2T, T2OLE, OLE2CT, T2COLE, A2W, W2A, A2CW, W2CA a USES_CONVERSION sú \msdev\mfc\include\afxpriv.h. Pozri aj AfxA2WHelper a AfxW2AHelper v MFC zdrojového kódu v \msdev\mfc\src a používanie OLE2T, T2OLE, OLE2CT a T2COLE v MFC zdrojového kódu v \msdev\mfc\src. Tieto funkcie umožňujú kód byť zostavené buď pre Unicode alebo ANSI závislosti od toho, či Preprocesor _UNICODE dosiahol sa definícia. Napríklad, CreateFileMoniker hovor nad príkladom možné vykonať takto s MFC makrá:
USES_CONVERSION;
GetOpenFileName(&ofn);
CreateFileMoniker(T2OLE(ofn.lpstrFile), &pmk);
				
Ak je definovaná _UNICODE, T2OLE je definovaný takto:
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
				
Ak nie je definovaná _UNICODE, T2OLE je definovaný takto:
#define T2OLE(lpa) A2W(lpa)
				
T v T2OLE naznačuje, že typ sa prepočíta na reťazec OLE (Unicode na reťazec) je reťazec Unicode, keď je definovaná _UNICODE a Reťazec ANSI keď _UNICODE nie je definovaná. Podobne je definovaná LPTSTR Smerník na reťazec Unicode, ak je definovaná _UNICODE a ako ukazovateľ na reťazec ANSI keď _UNICODE nie je definovaná. T2OLE nemá vykonajte konverzia Ak je definovaná _UNICODE (LPTSTR == LPOLESTR). Keď Unicode je nedefinovali, sa nazýva A2W. A2W konvertuje reťazec ANSI na Unicode ako takto:
#define A2W(lpa) (\ 
        ((LPCSTR)lpa == NULL) ? NULL : (\ 
            _convert = (strlen(lpa)+1),\ 
            AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)\ 
        )\ 

)
				
AfxA2WHelper používa MultiByteToWideChar urobiť konverziu.

MFC konverzie makrá použiť _alloca na pridelenie priestoru z programu zásobník pre konvertované reťazec. Priestor je automaticky deallocated Ak sa dokončil volanie procedúry. OLE vyžaduje OLE prideľovača na použijú na všetky reťazce (údaje), ktoré budú pridelené jednej zložky a uvoľnené iný. To znamená, že reťazce prejsť cez vý- parametre a v-out-parametre OLE rozhraní musia prideliť s OLE prideľovača. Vstupné parametre nemusia rozdeliť s OLE Prideľovač pretože volajúci je zodpovedný za ich uvoľnenie. Most Prepájanie a Embedding OLE rozhrania a API preniesť struny ako vstupné parametre. Následne MFC konverzie makrá možno vo väčšine prípadov. V MFC konverzie makrá sa nemôže použi na in-out parametre alebo na vykazujúcich hodnoty prostredníctvom out-parametre, pretože nemôže prideliť miesta pomocou OLE prideľovača. AnsiToUnicode a UnicodeToAnsi môžu byť v týchto prípadoch použiť.

Ešte iný súbor rutiny konverzia Unicode/ANSI možno nájsť v Don Bloku stĺpec v OLE v Microsoft systémy vestníku, August 1995, Vol. 10 No. 8, stránku 86. Don Box definuje c ++ triedy s prevádzkovateľom odliatku ktoré Vráti reťazec Unicode/ANSI skonvertujú. Vyhradený priestor je automaticky uvoľnených keď objekt dostane mimo rozsahu. Do tejto triedy môže byť modifikovaných prideliť pomocou OLE prideľovača a nie voľného pridelené miesto na reťazce, ktoré prechádzajú cez-out alebo vý- parametre.

Jednej z tried String16, Don políčka stĺpca, ktorý konvertuje ANSI reťazec Unicode, takto. Inej triedy, String8, podobné tohle sa používa ANSI Unicode konverzie. V CreateFileMoniker volanie z predchádzajúceho príkladu môžete vykonať takto s tejto triedy:
GetOpenFileName(&ofn);
CreateFileMoniker(String16(ofn.lpstrFile), &pmk);
				
V horeuvedenom kóde, sa vytvorí inštanciu triedy String16. Konštruktér triedy konvertovať reťazec ANSI na Unicode. Jazyk implementáciu budú volať odliatku prevádzkovateľom, prevádzkovateľ const wchar_t *, odovzdať tento parameter typu z CreateFileMoniker to prvý parameter. Prevádzkovateľ odliatku vráti reťazec Unicode, ktorý je prejsť do CreateFileMoniker. Objekt bude expIoduje keď v goes von pôsobnosť.
// 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á kontrola: 10. októbra 2011 - Revízia: 2.0
Kľúčové slová: 
kbcode kbhowto kbprogramming kbmt KB138813 KbMtsk
Strojovo preložené
DÔLEŽITÉ: Tento článok bol preložený pomocou softvéru na strojový preklad od spoločnosti Microsoft, nie prekladateľom. Spoločnosť Microsoft ponúka články preložené prekladateľmi aj strojovo preložené články, vďaka čomu máte možnosť prístupu ku všetkým článkom databázy Knowledge Base vo svojom jazyku. Strojovo preložený článok však nie je vždy perfektný. Môže obsahovať chyby týkajúce sa slovnej zásoby, syntaxe alebo gramatiky, podobne ako cudzinec môže robiť chyby, keď rozpráva vašim jazykom. Spoločnosť Microsoft nenesie zodpovednosť za akékoľvek nepresnosti, chyby alebo škody spôsobené akýmkoľvek nepresným prekladom obsahu alebo jeho použitím zo strany zákazníkov. Spoločnosť Microsoft softvér na strojový preklad pravidelne aktualizuje.
Pokiaľ chcete vidieť anglickú verziu článku, kliknite sem:138813

Odošlite odozvu

 

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