C++中各种string的相互转化

转载 2007年09月13日 13:40:00

因工作需要要进行LPCWSTR和string的转换,到网上搜出一篇详细介绍的文章出来了,本着“拿来主义”做个技术积累。 

一 C++ 中 string与wstring互转

方法一:

string WideToMutilByte(const wstring& _src)
{
int nBufSize = WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, NULL, 00, FALSE);

char *szBuf = new char[nBufSize];

WideCharToMultiByte(GetACP(), 
0, _src.c_str(),-1, szBuf, nBufSize, 0, FALSE);

string strRet(szBuf);

delete []szBuf;
szBuf 
= NULL;

return strRet;
}


wstring MutilByteToWide(
const string& _src)
{
//计算字符串 string 转成 wchar_t 之后占用的内存字节数
int nBufSize = MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,NULL,0); 

//为 wsbuf 分配内存 BufSize 个字节
wchar_t *wsBuf = new wchar_t[nBufSize];

//转化为 unicode 的 WideString
MultiByteToWideChar(GetACP(),0,_src.c_str(),-1,wsBuf,nBufSize); 

wstring wstrRet(wsBuf);

delete []wsBuf;
wsBuf 
= NULL;

return wstrRet;
}




转载:csdn

这篇文章里,我将给出几种C++ std::string和std::wstring相互转换的转换方法。
 
第一种方法:调用WideCharToMultiByte()和MultiByteToWideChar(),代码如下(关于详细的解释,可以参考《windows核心编程》):
 

#include <string>
#include 
<windows.h>
using namespace std;
//Converting a WChar string to a Ansi string
std::string WChar2Ansi(LPCWSTR pwszSrc)
{
         
int nLen = WideCharToMultiByte(CP_ACP, 0, pwszSrc, -1, NULL, 0, NULL, NULL);
 
         
if (nLen<= 0return std::string("");
 
         
char* pszDst = new char[nLen];
         
if (NULL == pszDst) return std::string("");
 
         WideCharToMultiByte(CP_ACP, 
0, pwszSrc, -1, pszDst, nLen, NULL, NULL);
         pszDst[nLen 
-1= 0;
 
         std::
string strTemp(pszDst);
         delete [] pszDst;
 
         
return strTemp;
}


 
string ws2s(wstring& inputws)

        
return WChar2Ansi(inputws.c_str()); 
}



 
//Converting a Ansi string to WChar string 

std::wstring Ansi2WChar(LPCSTR pszSrc, int nLen)
 
{
    
int nSize = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pszSrc, nLen, 00);
    
if(nSize <= 0return NULL;
 
         WCHAR 
*pwszDst = new WCHAR[nSize+1];
    
if( NULL == pwszDst) return NULL;
 
    MultiByteToWideChar(CP_ACP, 
0,(LPCSTR)pszSrc, nLen, pwszDst, nSize);
    pwszDst[nSize] 
= 0;
 
    
if( pwszDst[0== 0xFEFF)                    // skip Oxfeff
        for(int i = 0; i < nSize; i ++
                            pwszDst[i] 
= pwszDst[i+1]; 
 
    wstring wcharString(pwszDst);
         delete pwszDst;
 
    
return wcharString;
}


 
std::wstring s2ws(
const string& s)
{
     
return Ansi2WChar(s.c_str(),s.size());
}


  
 
第二种方法:采用ATL封装_bstr_t的过渡:(注,_bstr_是Microsoft Specific的,所以下面代码可以在VS2005通过,无移植性);

#include <string>
#include 
<comutil.h>
using namespace std;
#pragma comment(lib, 
"comsuppw.lib"
 
string ws2s(const wstring& ws);
wstring s2ws(
const string& s);
 
string ws2s(const wstring& ws)
{
         _bstr_t t 
= ws.c_str();
         
char* pchar = (char*)t;
         
string result = pchar;
         
return result;
}


 
wstring s2ws(
const string& s)
{
         _bstr_t t 
= s.c_str();
         wchar_t
* pwchar = (wchar_t*)t;
         wstring result 
= pwchar;
         
return result;
}


 
第三种方法:使用CRT库的mbstowcs()函数和wcstombs()函数,平台无关,需设定locale。

#include <string>
#include 
<locale.h>
using namespace std;
string ws2s(const wstring& ws)
{
         
string curLocale = setlocale(LC_ALL, NULL);        // curLocale = "C";
 
         setlocale(LC_ALL, 
"chs"); 
 
         
const wchar_t* _Source = ws.c_str();
         size_t _Dsize 
= 2 * ws.size() + 1;
         
char *_Dest = new char[_Dsize];
         memset(_Dest,
0,_Dsize);
         wcstombs(_Dest,_Source,_Dsize);
         
string result = _Dest;
         delete []_Dest;
 
         setlocale(LC_ALL, curLocale.c_str());
 
         
return result;
}


 
wstring s2ws(
const string& s)
{
         setlocale(LC_ALL, 
"chs"); 
 
         
const char* _Source = s.c_str();
         size_t _Dsize 
= s.size() + 1;
         wchar_t 
*_Dest = new wchar_t[_Dsize];
         wmemset(_Dest, 
0, _Dsize);
         mbstowcs(_Dest,_Source,_Dsize);
         wstring result 
= _Dest;
         delete []_Dest;
 
         setlocale(LC_ALL, 
"C");
 
         
return result;
}



二 utf8.utf16.utf32的相互转化

可以参考Unicode.org 上有ConvertUTF.c和ConvertUTF.h (下载地址:http://www.unicode.org/Public/PROGRAMS/CVTUTF/

实现文件ConvertUTF.c:(.h省)
/*
 * Copyright 2001-2004 Unicode, Inc.
 * 
 * Disclaimer
 * 
 * This source code is provided as is by Unicode, Inc. No claims are
 * made as to fitness for any particular purpose. No warranties of any
 * kind are expressed or implied. The recipient agrees to determine
 * applicability of information provided. If this file has been
 * purchased on magnetic or optical media from Unicode, Inc., the
 * sole remedy for any claim will be exchange of defective media
 * within 90 days of receipt.
 * 
 * Limitations on Rights to Redistribute This Code
 * 
 * Unicode, Inc. hereby grants the right to freely use the information
 * supplied in this file in the creation of products supporting the
 * Unicode Standard, and to make copies of this file in any form
 * for internal or external distribution as long as this notice
 * remains attached.
 
*/


/* ---------------------------------------------------------------------

    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
    Author: Mark E. Davis, 1994.
    Rev History: Rick McGowan, fixes & updates May 2001.
    Sept 2001: fixed const & error conditions per
    mods suggested by S. Parent & A. Lillich.
    June 2002: Tim Dodd added detection and handling of incomplete
    source sequences, enhanced error detection, added casts
    to eliminate compiler warnings.
    July 2003: slight mods to back out aggressive FFFE detection.
    Jan 2004: updated switches in from-UTF8 conversions.
    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.

    See the header file "ConvertUTF.h" for complete documentation.

------------------------------------------------------------------------ 
*/



#include 
"ConvertUTF.h"
#ifdef CVTUTF_DEBUG
#include 
<stdio.h>
#endif

static const int halfShift  = 10/* used for shifting by 10 bits */

static const UTF32 halfBase = 0x0010000UL;
static const UTF32 halfMask = 0x3FFUL;

#define UNI_SUR_HIGH_START  (UTF32)0xD800
#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
#define UNI_SUR_LOW_START   (UTF32)0xDC00
#define UNI_SUR_LOW_END     (UTF32)0xDFFF
#define false       0
#define true        1

/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF32toUTF16 (
    
const UTF32** sourceStart, const UTF32* sourceEnd, 
    UTF16
** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF32* source = *sourceStart;
    UTF16
* target = *targetStart;
    
while (source < sourceEnd) {
    UTF32 ch;
    
if (target >= targetEnd) {
        result 
= targetExhausted; break;
    }

    ch 
= *source++;
    
if (ch <= UNI_MAX_BMP) /* Target is a character <= 0xFFFF */
        
/* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
        
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        
if (flags == strictConversion) {
            
--source; /* return to the illegal value itself */
            result 
= sourceIllegal;
            
break;
        }
 else {
            
*target++ = UNI_REPLACEMENT_CHAR;
        }

        }
 else {
        
*target++ = (UTF16)ch; /* normal case */
        }

    }
 else if (ch > UNI_MAX_LEGAL_UTF32) {
        
if (flags == strictConversion) {
        result 
= sourceIllegal;
        }
 else {
        
*target++ = UNI_REPLACEMENT_CHAR;
        }

    }
 else {
        
/* target is a character in range 0xFFFF - 0x10FFFF. */
        
if (target + 1 >= targetEnd) {
        
--source; /* Back up source pointer! */
        result 
= targetExhausted; break;
        }

        ch 
-= halfBase;
        
*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        
*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }

    }

    
*sourceStart = source;
    
*targetStart = target;
    
return result;
}


/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF16toUTF32 (
    
const UTF16** sourceStart, const UTF16* sourceEnd, 
    UTF32
** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF16* source = *sourceStart;
    UTF32
* target = *targetStart;
    UTF32 ch, ch2;
    
while (source < sourceEnd) {
    
const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
    ch 
= *source++;
    
/* If we have a surrogate pair, convert to UTF32 first. */
    
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        
/* If the 16 bits following the high surrogate are in the source buffer */
        
if (source < sourceEnd) {
        ch2 
= *source;
        
/* If it's a low surrogate, convert to UTF32. */
        
if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch 
= ((ch - UNI_SUR_HIGH_START) << halfShift)
            
+ (ch2 - UNI_SUR_LOW_START) + halfBase;
            
++source;
        }
 else if (flags == strictConversion) /* it's an unpaired high surrogate */
            
--source; /* return to the illegal value itself */
            result 
= sourceIllegal;
            
break;
        }

        }
 else /* We don't have the 16 bits following the high surrogate. */
        
--source; /* return to the high surrogate */
        result 
= sourceExhausted;
        
break;
        }

    }
 else if (flags == strictConversion) {
        
/* UTF-16 surrogate values are illegal in UTF-32 */
        
if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        
--source; /* return to the illegal value itself */
        result 
= sourceIllegal;
        
break;
        }

    }

    
if (target >= targetEnd) {
        source 
= oldSource; /* Back up source pointer! */
        result 
= targetExhausted; break;
    }

    
*target++ = ch;
    }

    
*sourceStart = source;
    
*targetStart = target;
#ifdef CVTUTF_DEBUG
if (result == sourceIllegal) {
    fprintf(stderr, 
"ConvertUTF16toUTF32 illegal seq 0x%04x,%04x/n", ch, ch2);
    fflush(stderr);
}

#endif
    
return result;
}


/* --------------------------------------------------------------------- */

/*
 * Index into the table below with the first byte of a UTF-8 sequence to
 * get the number of trailing bytes that are supposed to follow it.
 * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
 * left as-is for anyone who may want to do such conversion, which was
 * allowed in earlier algorithms.
 
*/

static const char trailingBytesForUTF8[256= {
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,11,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
    
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,23,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
}
;

/*
 * Magic values subtracted from a buffer value during UTF8 conversion.
 * This table contains as many values as there might be trailing bytes
 * in a UTF-8 sequence.
 
*/

static const UTF32 offsetsFromUTF8[6= 0x00000000UL0x00003080UL0x000E2080UL
             
0x03C82080UL0xFA082080UL0x82082080UL }
;

/*
 * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
 * into the first byte, depending on how many bytes follow.  There are
 * as many entries in this table as there are UTF-8 sequence types.
 * (I.e., one byte sequence, two byte etc.). Remember that sequencs
 * for *legal* UTF-8 will be 4 or fewer bytes total.
 
*/

static const UTF8 firstByteMark[7= 0x000x000xC00xE00xF00xF80xFC };

/* --------------------------------------------------------------------- */

/* The interface converts a whole buffer to avoid function-call overhead.
 * Constants have been gathered. Loops & conditionals have been removed as
 * much as possible for efficiency, in favor of drop-through switches.
 * (See "Note A" at the bottom of the file for equivalent code.)
 * If your compiler supports it, the "isLegalUTF8" call can be turned
 * into an inline function.
 
*/


/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF16toUTF8 (
    
const UTF16** sourceStart, const UTF16* sourceEnd, 
    UTF8
** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF16* source = *sourceStart;
    UTF8
* target = *targetStart;
    
while (source < sourceEnd) {
    UTF32 ch;
    unsigned 
short bytesToWrite = 0;
    
const UTF32 byteMask = 0xBF;
    
const UTF32 byteMark = 0x80
    
const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
    ch 
= *source++;
    
/* If we have a surrogate pair, convert to UTF32 first. */
    
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
        
/* If the 16 bits following the high surrogate are in the source buffer */
        
if (source < sourceEnd) {
        UTF32 ch2 
= *source;
        
/* If it's a low surrogate, convert to UTF32. */
        
if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
            ch 
= ((ch - UNI_SUR_HIGH_START) << halfShift)
            
+ (ch2 - UNI_SUR_LOW_START) + halfBase;
            
++source;
        }
 else if (flags == strictConversion) /* it's an unpaired high surrogate */
            
--source; /* return to the illegal value itself */
            result 
= sourceIllegal;
            
break;
        }

        }
 else /* We don't have the 16 bits following the high surrogate. */
        
--source; /* return to the high surrogate */
        result 
= sourceExhausted;
        
break;
        }

    }
 else if (flags == strictConversion) {
        
/* UTF-16 surrogate values are illegal in UTF-32 */
        
if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
        
--source; /* return to the illegal value itself */
        result 
= sourceIllegal;
        
break;
        }

    }

    
/* Figure out how many bytes the result will require */
    
if (ch < (UTF32)0x80{         bytesToWrite = 1;
    }
 else if (ch < (UTF32)0x800{     bytesToWrite = 2;
    }
 else if (ch < (UTF32)0x10000{   bytesToWrite = 3;
    }
 else if (ch < (UTF32)0x110000{  bytesToWrite = 4;
    }
 else {                bytesToWrite = 3;
                        ch 
= UNI_REPLACEMENT_CHAR;
    }


    target 
+= bytesToWrite;
    
if (target > targetEnd) {
        source 
= oldSource; /* Back up source pointer! */
        target 
-= bytesToWrite; result = targetExhausted; break;
    }

    
switch (bytesToWrite) /* note: everything falls through. */
        
case 4*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 3*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 2*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 1*--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
    }

    target 
+= bytesToWrite;
    }

    
*sourceStart = source;
    
*targetStart = target;
    
return result;
}


/* --------------------------------------------------------------------- */

/*
 * Utility routine to tell whether a sequence of bytes is legal UTF-8.
 * This must be called with the length pre-determined by the first byte.
 * If not calling this from ConvertUTF8to*, then the length can be set by:
 *  length = trailingBytesForUTF8[*source]+1;
 * and the sequence is illegal right away if there aren't that many bytes
 * available.
 * If presented with a length > 4, this returns false.  The Unicode
 * definition of UTF-8 goes up to 4-byte sequences.
 
*/


static Boolean isLegalUTF8(const UTF8 *source, int length) {
    UTF8 a;
    
const UTF8 *srcptr = source+length;
    
switch (length) {
    
defaultreturn false;
    
/* Everything else falls through when "true" */
    
case 4if ((a = (*--srcptr)) < 0x80 || a > 0xBFreturn false;
    
case 3if ((a = (*--srcptr)) < 0x80 || a > 0xBFreturn false;
    
case 2if ((a = (*--srcptr)) > 0xBFreturn false;

    
switch (*source) {
        
/* no fall-through in this inner switch */
        
case 0xE0if (a < 0xA0return falsebreak;
        
case 0xEDif (a > 0x9Freturn falsebreak;
        
case 0xF0if (a < 0x90return falsebreak;
        
case 0xF4if (a > 0x8Freturn falsebreak;
        
default:   if (a < 0x80return false;
    }


    
case 1if (*source >= 0x80 && *source < 0xC2return false;
    }

    
if (*source > 0xF4return false;
    
return true;
}


/* --------------------------------------------------------------------- */

/*
 * Exported function to return whether a UTF-8 sequence is legal or not.
 * This is not used here; it's just exported.
 
*/

Boolean isLegalUTF8Sequence(
const UTF8 *source, const UTF8 *sourceEnd) {
    
int length = trailingBytesForUTF8[*source]+1;
    
if (source+length > sourceEnd) {
    
return false;
    }

    
return isLegalUTF8(source, length);
}


/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF8toUTF16 (
    
const UTF8** sourceStart, const UTF8* sourceEnd, 
    UTF16
** targetStart, UTF16* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF8* source = *sourceStart;
    UTF16
* target = *targetStart;
    
while (source < sourceEnd) {
    UTF32 ch 
= 0;
    unsigned 
short extraBytesToRead = trailingBytesForUTF8[*source];
    
if (source + extraBytesToRead >= sourceEnd) {
        result 
= sourceExhausted; break;
    }

    
/* Do this check whether lenient or strict */
    
if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result 
= sourceIllegal;
        
break;
    }

    
/*
     * The cases all fall through. See "Note A" below.
     
*/

    
switch (extraBytesToRead) {
        
case 5: ch += *source++; ch <<= 6/* remember, illegal UTF-8 */
        
case 4: ch += *source++; ch <<= 6/* remember, illegal UTF-8 */
        
case 3: ch += *source++; ch <<= 6;
        
case 2: ch += *source++; ch <<= 6;
        
case 1: ch += *source++; ch <<= 6;
        
case 0: ch += *source++;
    }

    ch 
-= offsetsFromUTF8[extraBytesToRead];

    
if (target >= targetEnd) {
        source 
-= (extraBytesToRead+1); /* Back up source pointer! */
        result 
= targetExhausted; break;
    }

    
if (ch <= UNI_MAX_BMP) /* Target is a character <= 0xFFFF */
        
/* UTF-16 surrogate values are illegal in UTF-32 */
        
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        
if (flags == strictConversion) {
            source 
-= (extraBytesToRead+1); /* return to the illegal value itself */
            result 
= sourceIllegal;
            
break;
        }
 else {
            
*target++ = UNI_REPLACEMENT_CHAR;
        }

        }
 else {
        
*target++ = (UTF16)ch; /* normal case */
        }

    }
 else if (ch > UNI_MAX_UTF16) {
        
if (flags == strictConversion) {
        result 
= sourceIllegal;
        source 
-= (extraBytesToRead+1); /* return to the start */
        
break/* Bail out; shouldn't continue */
        }
 else {
        
*target++ = UNI_REPLACEMENT_CHAR;
        }

    }
 else {
        
/* target is a character in range 0xFFFF - 0x10FFFF. */
        
if (target + 1 >= targetEnd) {
        source 
-= (extraBytesToRead+1); /* Back up source pointer! */
        result 
= targetExhausted; break;
        }

        ch 
-= halfBase;
        
*target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
        
*target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
    }

    }

    
*sourceStart = source;
    
*targetStart = target;
    
return result;
}


/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF32toUTF8 (
    
const UTF32** sourceStart, const UTF32* sourceEnd, 
    UTF8
** targetStart, UTF8* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF32* source = *sourceStart;
    UTF8
* target = *targetStart;
    
while (source < sourceEnd) {
    UTF32 ch;
    unsigned 
short bytesToWrite = 0;
    
const UTF32 byteMask = 0xBF;
    
const UTF32 byteMark = 0x80
    ch 
= *source++;
    
if (flags == strictConversion ) {
        
/* UTF-16 surrogate values are illegal in UTF-32 */
        
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        
--source; /* return to the illegal value itself */
        result 
= sourceIllegal;
        
break;
        }

    }

    
/*
     * Figure out how many bytes the result will require. Turn any
     * illegally large UTF32 things (> Plane 17) into replacement chars.
     
*/

    
if (ch < (UTF32)0x80{         bytesToWrite = 1;
    }
 else if (ch < (UTF32)0x800{     bytesToWrite = 2;
    }
 else if (ch < (UTF32)0x10000{   bytesToWrite = 3;
    }
 else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
    }
 else {                bytesToWrite = 3;
                        ch 
= UNI_REPLACEMENT_CHAR;
                        result 
= sourceIllegal;
    }

    
    target 
+= bytesToWrite;
    
if (target > targetEnd) {
        
--source; /* Back up source pointer! */
        target 
-= bytesToWrite; result = targetExhausted; break;
    }

    
switch (bytesToWrite) /* note: everything falls through. */
        
case 4*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 3*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 2*--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
        
case 1*--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
    }

    target 
+= bytesToWrite;
    }

    
*sourceStart = source;
    
*targetStart = target;
    
return result;
}


/* --------------------------------------------------------------------- */

ConversionResult ConvertUTF8toUTF32 (
    
const UTF8** sourceStart, const UTF8* sourceEnd, 
    UTF32
** targetStart, UTF32* targetEnd, ConversionFlags flags) {
    ConversionResult result 
= conversionOK;
    
const UTF8* source = *sourceStart;
    UTF32
* target = *targetStart;
    
while (source < sourceEnd) {
    UTF32 ch 
= 0;
    unsigned 
short extraBytesToRead = trailingBytesForUTF8[*source];
    
if (source + extraBytesToRead >= sourceEnd) {
        result 
= sourceExhausted; break;
    }

    
/* Do this check whether lenient or strict */
    
if (! isLegalUTF8(source, extraBytesToRead+1)) {
        result 
= sourceIllegal;
        
break;
    }

    
/*
     * The cases all fall through. See "Note A" below.
     
*/

    
switch (extraBytesToRead) {
        
case 5: ch += *source++; ch <<= 6;
        
case 4: ch += *source++; ch <<= 6;
        
case 3: ch += *source++; ch <<= 6;
        
case 2: ch += *source++; ch <<= 6;
        
case 1: ch += *source++; ch <<= 6;
        
case 0: ch += *source++;
    }

    ch 
-= offsetsFromUTF8[extraBytesToRead];

    
if (target >= targetEnd) {
        source 
-= (extraBytesToRead+1); /* Back up the source pointer! */
        result 
= targetExhausted; break;
    }

    
if (ch <= UNI_MAX_LEGAL_UTF32) {
        
/*
         * UTF-16 surrogate values are illegal in UTF-32, and anything
         * over Plane 17 (> 0x10FFFF) is illegal.
         
*/

        
if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
        
if (flags == strictConversion) {
            source 
-= (extraBytesToRead+1); /* return to the illegal value itself */
            result 
= sourceIllegal;
            
break;
        }
 else {
            
*target++ = UNI_REPLACEMENT_CHAR;
        }

        }
 else {
        
*target++ = ch;
        }

    }
 else /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
        result 
= sourceIllegal;
        
*target++ = UNI_REPLACEMENT_CHAR;
    }

    }

    
*sourceStart = source;
    
*targetStart = target;
    
return result;
}


/* ---------------------------------------------------------------------

    Note A.
    The fall-through switches in UTF-8 reading code save a
    temp variable, some decrements & conditionals.  The switches
    are equivalent to the following loop:
    {
        int tmpBytesToRead = extraBytesToRead+1;
        do {
        ch += *source++;
        --tmpBytesToRead;
        if (tmpBytesToRead) ch <<= 6;
        } while (tmpBytesToRead > 0);
    }
    In UTF-8 writing code, the switches on "bytesToWrite" are
    similarly unrolled loops.

   --------------------------------------------------------------------- 
*/




三 C++ 的字符串与C#的转化

1)将system::String 转化为C++的string:
// convert_system_string.cpp
// compile with: /clr
#include <string>
#include 
<iostream>
using namespace std;
using namespace System;

void MarshalString ( String ^ s, string& os ) {
   
using namespace Runtime::InteropServices;
   
const char* chars = 
      (
const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
   os 
= chars;
   Marshal::FreeHGlobal(IntPtr((
void*)chars));
}


void MarshalString ( String ^ s, wstring& os ) {
   
using namespace Runtime::InteropServices;
   
const wchar_t* chars = 
      (
const wchar_t*)(Marshal::StringToHGlobalUni(s)).ToPointer();
   os 
= chars;
   Marshal::FreeHGlobal(IntPtr((
void*)chars));
}


int main() {
   
string a = "test";
   wstring b 
= L"test2";
   String 
^ c = gcnew String("abcd");

   cout 
<< a << endl;
   MarshalString(c, a);
   c 
= "efgh";
   MarshalString(c, b);
   cout 
<< a << endl;
   wcout 
<< b << endl;
}



2)将System::String转化为char*或w_char*
// convert_string_to_wchar.cpp
// compile with: /clr
#include < stdio.h >
#include 
< stdlib.h >
#include 
< vcclr.h >

using namespace System;

int main() {
   String 
^str = "Hello";

   
// Pin memory so GC can't move it while native function is called
   pin_ptr<const wchar_t> wch = PtrToStringChars(str);
   printf_s(
"%S/n", wch);

   
// Conversion to char* :
   
// Can just convert wchar_t* to char* using one of the 
   
// conversion functions such as: 
   
// WideCharToMultiByte()
   
// wcstombs_s()
   
//  etc
   size_t convertedChars = 0;
   size_t  sizeInBytes 
= ((str->Length + 1* 2);
   errno_t err 
= 0;
   
char    *ch = (char *)malloc(sizeInBytes);

   err 
= wcstombs_s(&convertedChars, 
                    ch, sizeInBytes,
                    wch, sizeInBytes);
   
if (err != 0)
      printf_s(
"wcstombs_s  failed!/n");

    printf_s(
"%s/n", ch);
}
 

相关文章推荐

C++基础——bitset与string的相互转化

bitset类模板提供了非常直接的接口进行与string类型数据的转换。然而一些需要注意的细节又是非常繁琐。 具体如何繁琐,以及如何化繁为简,且看下文分解。

C++ Builder string相互转换

  • 2016-05-08 07:55
  • 396KB
  • 下载

String[] list 相互转化

C/C++ 基本数据类型之间的相互转换 int / char / string / vector windows与linux通用

参考: http://blog.csdn.net/xinwang24/article/details/6612686 http://zhidao.baidu.com/link?url=or5e32M...

C++中int、string、const char*、CString之间的相互转换

1.int与string的相互转化使用stringstream即可 stringstream可以吞下不同的类型,根据b的类型,然后吐出不同的类型。//#includeint a=80; string...

C++ wstring string char* wchar_t相互转换

1. char*->string (1)直接转换 const char* nodename; string temp = nodename;string temp2(nodename); ...

c++中 int 和 string 的相互转换

/************************************************** author: Andrewseu date: 2014.8.8 ***************...

c++中char*\wchar_t*\string\wstring之间的相互转换

string U2A(const wstring& str)//Unicode字符转Ascii字符{ string strDes; if ( str.empty() ) goto __end;...
  • mfcing
  • mfcing
  • 2012-05-02 23:16
  • 14535

几种C++ std::string和std::wstring相互转换的转换方法

几种C++ std::string和std::wstring相互转换的转换方法

C++中int与string的相互转换

一、int转string 1.c++11标准增加了全局函数std::to_string: string to_string (int val); string to_string (long v...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)