如何：在各种字符串类型之间进行转换

最新推荐文章于 2019-03-20 11:17:28 发布

theForger

最新推荐文章于 2019-03-20 11:17:28 发布

阅读量578

点赞数 1

分类专栏： C++ 文章标签： wchar-t char CString basic-str

本文链接：https://blog.csdn.net/theforger/article/details/50865905

版权

C++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

// 从 char *（C风格字符串）转换到其它字符串类型
// convert_from_char.cpp
// compile with: /clr /link comsuppw.lib

    #include <iostream>
    #include <stdlib.h>
    #include <string>

    #include "atlbase.h"
    #include "atlstr.h"
    #include "comutil.h"

    using namespace std;
    using namespace System;

    int main()
    {
        //初始化C风格字符串
        char *orig = "Hello, World!";
        cout << orig << " (char *)" << endl;

        //宽字符串长度
        size_t newsize = strlen(orig) + 1;
        //在堆上分配一个宽字符串数组
        wchar_t * wcstring = new wchar_t[newsize];

        //从 char* 类型字符串转换到 wchar_t* 类型字符串.
        size_t convertedChars = 0;
        mbstowcs_s(&convertedChars, wcstring, newsize, orig, _TRUNCATE);
        //输出转换后结果.
        wcout << wcstring << _T(" (wchar_t *)") << endl;

        //转换 char* 字符串转换到 CStringA （多字节CString）.
        CStringA cstringa(orig);
        cstringa += " (CStringA)";
        cout << cstringa << endl;

        //转换 char* 字符串转换到 CStringW （宽字节CString）.
        CStringW cstring(orig);
        cstring += " (CStringW)";
        //使用wcout输出宽字节字符串
        wcout << (LPCTSTR)cstring << endl;

        //转换 char* 字符串转换到 basic_string （STL字符串类型）.
        string basicstring(orig);
        basicstring += " (basic_string)";
        cout << basicstring << endl;

        //转换 char* 字符串转换到 System::String （.NET字符串）.
        String ^systemstring = gcnew String(orig);
        systemstring += " (System::String)";
        Console::WriteLine("{0}", systemstring);
        delete systemstring;
    }

// 从 wchar_t *（宽字节字符串）转换到其它字符串类型
// convert_from_wchar_t.cpp
// compile with: /clr /link comsuppw.lib

    #include <iostream>
    #include <stdlib.h>
    #include <string>

    #include "atlbase.h"
    #include "atlstr.h"
    #include "comutil.h"

    using namespace std;
    using namespace System;

    int main()
    {
        //初始化宽字节字符串
        wchar_t *orig = _T("Hello, World!");
        wcout << orig << _T(" (wchar_t *)") << endl;

        //字符串长度
        size_t origsize = wcslen(orig) + 1;
        size_t convertedChars = 0;

        //添加输出类型标记.
        char strConcat[] = " (char *)";
        size_t strConcatsize = (strlen( strConcat ) + 1)*2;

        //宽字节字符串每个字符占2字节，包括结尾0
        const size_t newsize = origsize*2;
        //在堆上分配内存用于存储转换后的字符串
        char *nstring = new char[newsize+strConcatsize];

        //转换复制
        wcstombs_s(&convertedChars, nstring, newsize, orig, _TRUNCATE);
        //添加字符类型标识.
        _mbscat_s((unsigned char*)nstring, newsize+strConcatsize, (unsigned char*)strConcat);
        //输出结果
        cout << nstring << endl;

        //从 wchar_t 字符串转换到多字节 CStringA,
        CStringA cstringa(orig);
        cstringa += " (CStringA)";
        cout << cstringa << endl;

        //从wchar_t 字符串转换到 宽字符 CStringW
        CStringW cstring(orig);
        cstring += " (CStringW)";
        //使用宽字符 wcout 输出结果
        wcout << (LPCTSTR)cstring << endl;

        //从 wchar_t 字符串 转换到 STL basic_string
        wstring basicstring(orig);
        basicstring += _T(" (basic_string)");
        wcout << basicstring << endl;

        //从 wchar_t 字符串转换到.NET　System::String string
        String ^systemstring = gcnew String(orig);
        systemstring += " (System::String)";
        Console::WriteLine("{0}", systemstring);
        delete systemstring;
    }

// 从 CString（MFC字符串）转换到其它字符串类型
// convert_from_cstring.cpp
// compile with: /clr /link comsuppw.lib

    #include <iostream>
    #include <stdlib.h>
    #include <string>

    #include "atlbase.h"
    #include "atlstr.h"
    #include "comutil.h"

    using namespace std;
    using namespace System;

    int main()
    {
        //初始化多字节CString.
        CStringA origa("Hello, World!");
        cout << origa << " (CStringA)" << endl;
        //初始化宽字节CString.
        CStringW origw("Hello, World!");
        wcout << (LPCTSTR)origw << _T(" (CStringW)") << endl;

        //转换 CStringA string 到  char* string
        const size_t newsizea = (origa.GetLength() + 1);
        char *nstringa = new char[newsizea];
        strcpy_s(nstringa, newsizea, origa);
        cout << nstringa << " (char *)" << endl;

        //转换CStringW string 到 char* string
        const size_t newsizew = (origw.GetLength() + 1)*2;
        char *nstringw = new char[newsizew];
        size_t convertedCharsw = 0;
        wcstombs_s(&convertedCharsw, nstringw, newsizew, origw, _TRUNCATE );
        cout << nstringw << " (char *)" << endl;

        //转换 CStringA 到 wchar_t*
        size_t convertedCharsa = 0;
        wchar_t *wcstring = new wchar_t[newsizea];
        mbstowcs_s(&convertedCharsa, wcstring, newsizea, origa, _TRUNCATE);
        wcout << wcstring << _T(" (wchar_t *)") << endl;

        //转换 CStringW 到 wchar_t* string
        wchar_t *n2stringw = new wchar_t[newsizew];
        wcscpy_s( n2stringw, newsizew, origw );
        wcout << n2stringw << _T(" (wchar_t *)") << endl;

        //转换 CStringA 到 basic_string string.
        string basicstring(origa);
        basicstring += " (basic_string)";
        cout << basicstring << endl;

        //转换 CStringW 到 basic_string string.
        wstring basicstringw(origw);
        basicstringw += _T(" (basic_string)");
        wcout << basicstringw << endl;

        //转换 CStringA 到 System::String.
        String ^systemstring = gcnew String(origa);
        systemstring += " (System::String)";
        Console::WriteLine("{0}", systemstring);
        delete systemstring;
        //转换 CStringW 到 System::String.
        String ^systemstringw = gcnew String(origw);
        systemstringw += " (System::String)";
        Console::WriteLine("{0}", systemstringw);
        delete systemstringw;
    }

// 从 basic_string （STL字符串）转换到其它字符串类型
// convert_from_basic_string.cpp
// compile with: /clr /link comsuppw.lib

    #include <iostream>
    #include <stdlib.h>
    #include <string>

    #include "atlbase.h"
    #include "atlstr.h"
    #include "comutil.h"

    using namespace std;
    using namespace System;

    int main()
    {
        //初始化 basic_string string.
        string orig("Hello, World!");
        cout << orig << " (basic_string)" << endl;

        //转换宽字节 basic_string string 到多字节 char* string. 
        const size_t newsize = (strlen(orig.c_str()) + 1)*2;
        char *nstring = new char[newsize];
        strcpy_s(nstring, newsize, orig.c_str());
        cout << nstring << " (char *)" << endl;

        //转换 basic_string string 到宽字节 wchar_t* string. 
        //需要先转换到 char* string
        const size_t newsizew = strlen(orig.c_str()) + 1;
        size_t convertedChars = 0;
        wchar_t *wcstring = new wchar_t[newsizew];
        mbstowcs_s(&convertedChars, wcstring, newsizew, orig.c_str(), _TRUNCATE);
        wcout << wcstring << _T(" (wchar_t *)") << endl;

        //转换 basic_string string 到多字节 CStringA string.
        CStringA cstring(orig.c_str());
        cstring += " (CStringA)";
        cout << cstring << endl;

        //转换 basic_string string 到宽字节 CStringW string.
        CStringW cstringw(orig.c_str());
        cstringw += _T(" (CStringW)");
        wcout << (LPCTSTR)cstringw << endl;

        //转换 basic_string string 到 System::String
        String ^systemstring = gcnew String(orig.c_str());
        systemstring += " (System::String)";
        Console::WriteLine("{0}", systemstring);
        delete systemstring;
    }

// 从  (Unicode) System::String （.NET字符串）转换到其它字符串类型
// convert_from_system_string.cpp
// compile with: /clr /link comsuppw.lib

    #include <iostream>
    #include <stdlib.h>
    #include <string>

    #include "atlbase.h"
    #include "atlstr.h"
    #include "comutil.h"
    #include "vcclr.h"

    using namespace std;
    using namespace System;
    using namespace System::Runtime::InteropServices;

    int main()
    {
        //初始化 System::String.
        String ^orig = gcnew String("Hello, World!");
        Console::WriteLine("{0} (System::String)", orig);

        // Obtain a pointer to the System::String in order to
        // first lock memory into place, so that the
        // Garbage Collector (GC) cannot move that object
        // while we call native functions.
        pin_ptr<const wchar_t> wch = PtrToStringChars(orig);

        //转换 system string 到多字节 char* string.
        size_t origsize = wcslen(wch) + 1;
        const size_t newsize = origsize*2;
        size_t convertedChars = 0;
        char *nstring = new char[newsize];
        wcstombs_s(&convertedChars, nstring, newsize, wch, _TRUNCATE);
        cout << nstring << " (char *)" << endl;

        //转换宽字节 system string 到宽字节 wchar_t* string.
        const size_t newsizew = origsize;
        wchar_t *wcstring = new wchar_t[newsizew];
        wcscpy_s(wcstring, newsizew, wch);
        wcout << wcstring << _T(" (wchar_t *)") << endl;

        //转换宽字节 System::String 到多字节 CStringA string.
        CStringA cstring(wch);
        cstring += " (CStringA)";
        cout << cstring << endl;

        //转换宽字节 System::String 到宽字节 CStringW string.
        CStringW cstringw(wch);
        cstringw += " (CStringW)";
        wcout << (LPCTSTR)cstringw << endl;

        //转换宽字节 System::String 到宽字节 basic_string.
        wstring basicstring(wch);
        basicstring += _T(" (basic_string)");
        wcout << basicstring << endl;

        delete orig;
    }