精华内容
下载资源
问答
  • 各种 C++ 字符串类型转换(char *、wchar_t*、_bstr_t、CComBSTR、CString、basic_string 和 System.String) 本主题演示如何将各种 C++ 字符串类型转换为其他字符串。可以转换的字符串类型包括 char *、wchar_t*、_...
  • jstring与c++字符串类型转换函数 string到jstringjstring str2jstring(JNIEnv* env,const char* pat) { //定义java String类 strClass jclass strClass = (env)->FindClass("Ljava/lang/String;"); //获取String...

    jstring与c++字符串类型转换函数
    string到jstring

    jstring str2jstring(JNIEnv* env,const char* pat)
    {
        //定义java String类 strClass
        jclass strClass = (env)->FindClass("Ljava/lang/String;");
        //获取String(byte[],String)的构造器,用于将本地byte[]数组转换为一个新String
        jmethodID ctorID = (env)->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
        //建立byte数组
        jbyteArray bytes = (env)->NewByteArray(strlen(pat));
        //将char* 转换为byte数组
        (env)->SetByteArrayRegion(bytes, 0, strlen(pat), (jbyte*)pat);
        // 设置String, 保存语言类型,用于byte数组转换至String时的参数
        jstring encoding = (env)->NewStringUTF("GB2312"); 
        //将byte数组转换为java String,并输出
        return (jstring)(env)->NewObject(strClass, ctorID, bytes, encoding);
    }

    jstring到string

    std::string jstring2str(JNIEnv* env, jstring jstr)
    {   
        char*   rtn   =   NULL;   
        jclass   clsstring   =   env->FindClass("java/lang/String");   
        jstring   strencode   =   env->NewStringUTF("GB2312");   
        jmethodID   mid   =   env->GetMethodID(clsstring,   "getBytes",   "(Ljava/lang/String;)[B");   
        jbyteArray   barr=   (jbyteArray)env->CallObjectMethod(jstr,mid,strencode);   
        jsize   alen   =   env->GetArrayLength(barr);   
        jbyte*   ba   =   env->GetByteArrayElements(barr,JNI_FALSE);   
        if(alen   >   0)   
        {   
            rtn   =   (char*)malloc(alen+1);         
            memcpy(rtn,ba,alen);   
            rtn[alen]=0;   
        }   
        env->ReleaseByteArrayElements(barr,ba,0);   
        std::string stemp(rtn);
        free(rtn);
        return   stemp;   
    } 
    展开全文
  • JNI jstring与c++字符串类型转换函数

    千次阅读 2011-01-25 22:13:00
    jstring 与 c++ 字符串 转换 JNI

    jstring与c++字符串类型转换函数

     

    展开全文
  • c++字符串类型(转载)

    千次阅读 2008-04-22 14:03:00
    区别wchar_t,char,WCHAR ANSI:即 char,可用字符串处理函数:strcat( ),strcpy( ), strlen( )等以str打头的函数。 UNICODE:wchar_t是Unicode字符的数据类型,它实际定义在里: typedef unsigned short wchar_t;...

    这真是好东西,对于处理文字的人来说,以下是本人转载的

    1.区别wchar_t,char,WCHAR

      ANSI:即 char,可用字符串处理函数:strcat( ),strcpy( ), strlen( )等以str打头的函数。
      UNICODE:wchar_t是Unicode字符的数据类型,它实际定义在里:
      typedef unsigned short wchar_t;
      另外,在头文件中有这样的定义:typedef wchar_t WCHAR; 所以WCHAR实际就是wchar_t
      wchar_t 可用字符串处理函数:wcscat(),wcscpy(),wcslen()等以wcs打头的函数。为了让编译器识别Unicode字符串,必须以在前面加一个“L”,例如: wchar_t *szTest=L"This is a Unicode string.";

    2.TCHAR

    在C语言里面提供了 _UNICODE宏(有下划线),在Windows里面提供了UNICODE宏(无下划线),只要定了_UNICODE宏和UNICODE宏,系统就会自 动切换到UNICODE版本,否则,系统按照ANSI的方式进行编译和运行。只定义了宏并不能实现自动的转换,他还需要一系列的字符定义支持。
       1. TCHAR
       如果定义了UNICODE宏则TCHAR被定义为wchar_t。
       typedef wchar_t TCHAR;
      否则TCHAR被定义为char typedef char TCHAR;
       2. LPTSTR
      如果定义了UNICODE宏则LPTSTR被定义为LPWSTR。
      typedef LPTSTR LPWSTR;
      否则TCHAR被定义为char typedef LPTSTR LPSTR;
      说明:在使用字符串常量的时候需要使用_TEXT(“MyStr”)或者_T("")来支持系统的自动转换。

    3.BSTR

      BSTR是一个带长度前缀的字符串,主要由操作系统来管理的,所以要用api.主要用来和VB打交道的(VB里的string就是指它)要操作它的API函数有很多.比如SysAllocString,SysFreeString等等.
      vc里封装它的类如_bstr_t,及ATL中的CComBSTR等.
      一个 BSTR 由头部和字符串组成,头部包含了字符串的长度信息,字符串中可以包含嵌入的 null 值。
      BSTR 是以指针的形式进行传递的。(指针是一个变量,包含另外一个变量的内存地址,而不是数据。) BSTR 是 Unicode 的,即每个字符需要两个字节。 BSTR 通常以两字节的 null 字符结束。 wstr是宽字符,以双字节表示一个字符 bstr是为了与原先的basic字符兼容,它的最前面的4个字节为其长度,以'/0'结束.

    4.更进一步的字符串以及其指针的类型定义 

    由于Win32 API文档的函数列表使用函数的常用名字(例如, "SetWindowText"),所有的字符串都是用TCHAR来定义的。(除了XP中引入的只适用于Unicode的API)。下面列出一些常用的typedefs,你可以在msdn中看到他们。

    typeMeaning in MBCS buildsMeaning in Unicode builds
    WCHARwchar_twchar_t
    LPSTRchar*char*
    LPCSTRconst char*const char*
    LPWSTRwchar_t*wchar_t*
    LPCWSTRwchar_t*wchar_t*
    TCHARTCHAR charwchar_t
    LPTSTRTCHAR*TCHAR*
    LPCTSTRconst TCHAR*const TCHAR*


    5.相互转换

    (1) char*转换成CString
      若将char*转换成CString,除了直接赋值外,还可使用CString::Format进行。例如:
    char chArray[] = "This is a test";
    char * p = "This is a test";
      或
    LPSTR p = "This is a test";
      或在已定义Unicode应的用程序中
    TCHAR * p = _T("This is a test");
      或
    LPTSTR p = _T("This is a test");
    CString theString = chArray;
    theString.Format(_T("%s"), chArray);
    theString = p;
      (2) CString转换成char*
      若将CString类转换成char*(LPSTR)类型,常常使用下列三种方法:
      方法一,使用强制转换。例如:
    CString theString( "This is a test" );
    LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;
      方法二,使用strcpy。例如:
    CString theString( "This is a test" );
    LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
    _tcscpy(lpsz, theString);
      需要说明的是,strcpy(或可移值Unicode/MBCS的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char* (ANSI),系统编译器将会自动对其进行转换。
      方法三,使用CString::GetBuffer。例如:
    CString s(_T("This is a test "));
    LPTSTR p = s.GetBuffer();
    // 在这里添加使用p的代码
    if(p != NULL) *p = _T('/0');
    s.ReleaseBuffer();
    // 使用完后及时释放,以便能使用其它的CString成员函数
      (3) BSTR转换成char*
      方法一,使用ConvertBSTRToString。例如:
    #include
    #pragma comment(lib, "comsupp.lib")
    int _tmain(int argc, _TCHAR* argv[]){
    BSTR bstrText = ::SysAllocString(L"Test");
    char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
    SysFreeString(bstrText); // 用完释放
    delete[] lpszText2;
    return 0;
    }
      方法二,使用_bstr_t的赋值运算符重载。例如:
    _bstr_t b = bstrText;
    char* lpszText2 = b;
      (4) char*转换成BSTR
      方法一,使用SysAllocString等API函数。例如:
    BSTR bstrText = ::SysAllocString(L"Test");
    BSTR bstrText = ::SysAllocStringLen(L"Test",4);
    BSTR bstrText = ::SysAllocStringByteLen("Test",4);
      方法二,使用COleVariant或_variant_t。例如:
    //COleVariant strVar("This is a test");
    _variant_t strVar("This is a test");
    BSTR bstrText = strVar.bstrVal;
      方法三,使用_bstr_t,这是一种最简单的方法。例如:
    BSTR bstrText = _bstr_t("This is a test");
      方法四,使用CComBSTR。例如:
    BSTR bstrText = CComBSTR("This is a test");
      或
    CComBSTR bstr("This is a test");
    BSTR bstrText = bstr.m_str;
      方法五,使用ConvertStringToBSTR。例如:
    char* lpszText = "Test";
    BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);
      (5) CString转换成BSTR
      通常是通过使用CStringT::AllocSysString来实现。例如:
    CString str("This is a test");
    BSTR bstrText = str.AllocSysString();

    SysFreeString(bstrText); // 用完释放
      (6) BSTR转换成CString
      一般可按下列方法进行:
    BSTR bstrText = ::SysAllocString(L"Test");
    CStringA str;
    str.Empty();
    str = bstrText;
      或
    CStringA str(bstrText);
      (7) ANSI、Unicode和宽字符之间的转换
      方法一,使用MultiByteToWideChar将ANSI字符转换成Unicode字符,使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
      方法二,使用“_T”将ANSI转换成“一般”类型字符串,使用“L”将ANSI转换成Unicode,而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如:
    TCHAR tstr[] = _T("this is a test");
    wchar_t wszStr[] = L"This is a test";
    String* str = S”This is a test”;
      方法三,使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类,它具有如图3所示的统一形式:
      其中,第一个C表示“类”,以便于ATL 3.0宏相区别,第二个C表示常量,2表示“to”,EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、 T、W和OLE,其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如,CA2CT就是将ANSI转换成一般类型的字符串常量。下面 是一些示例代码:
    LPTSTR tstr= CA2TEX<16>("this is a test");
    LPCTSTR tcstr= CA2CT("this is a test");
    wchar_t wszStr[] = L"This is a test";
    char* chstr = CW2A(wszStr); 
    展开全文
  • C++中的字符串类型

    2018-03-14 16:17:03
    C++中的字符串类型及相互转化 C++中的字符串类型及相互转化 C++中的字符串类型及相互转化
  • C++ 字符串与字符数组 详解

    万次阅读 多人点赞 2018-03-03 19:28:22
    C++中,有两种类型字符串表示形式: C-风格字符串 C++引入的string类 C-风格字符串 C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。...

    在C++中,有两种类型的字符串表示形式:

    • C-风格字符串
    • C++引入的string类

    C-风格字符串

    C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 ‘\0’ 终止的一维字符数组。因此,一个以 null 结尾的字符串,包含了组成字符串的字符。
    下面的声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符,所以字符数组的大小比单词 “Hello” 的字符数多一个。

    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

    其实,您不需要把 null 字符放在字符串常量的末尾。C++ 编译器会在初始化数组时,自动把 ‘\0’ 放在字符串的末尾。所以也可以利用下面的形式进行初始化

    char greeting[] = "Hello";

    以下是 C/C++ 中定义的字符串的内存表示:
    这里写图片描述
    C++ 中有大量的函数用来操作以 null 结尾的字符串:

    序号函数功能
    1strcpy(s1,s2)复制字符串 s2 到字符串 s1
    2strcat(s1,s2)连接字符串 s2 到字符串 s1 的末尾
    3strlen(s1)返回字符串 s1 的长度
    4strcmp(s1,s2)返回s1与s2的比较结果
    5strchr(s1,ch)返回一个指针,指向字符串s1中字符ch的第一次出现的位置
    6strstr(s1,s2)返回一个指针,指向字符串s1中s2的第一次出现的位置

    C++ 中的 String 类

    C++ 标准库提供了 string 类类型,支持上述所有的操作,另外还增加了其他更多的功能。比如:

    • append() – 在字符串的末尾添加字符
    • find() – 在字符串中查找字符串
    • insert() – 插入字符
    • length() – 返回字符串的长度
    • replace() – 替换字符串
    • substr() – 返回某个子字符串

    4种字符串类型

    C++中的字符串一般有以下四种类型,

    • string

    • char*

    • const char*
    • char[]

    下面分别做简单介绍,并说明其中的一些区别

    string

    string是一个C++类库中的一个类,它位于名称空间std中,因此必须使用using编译指令或者std::string来引用它。它包含了对字符串的各种常用操作,它较char*的优势是内容可以动态拓展,以及对字符串操作的方便快捷,用+号进行字符串的连接是最常用的操作

    char*

    char* 是指向字符串的指针(其实严格来说,它是指向字符串的首个字母),你可以让它指向一串常量字符串。

    const char*

    该声明指出,指针指向的是一个const char类型,即不能通过当前的指针对字符串的内容作出修改

    注意这里有两个概念:

    • char * const [指向字符的静态指针]
    • const char * [指向静态字符的指针]

    前者const修饰的是指针,代表不能改变指针
    后者const修饰的是char,代表字符不能改变,但是指针可以变,也就是说该指针可以指针其他的const char。

    char[]

    与char*与许多相同点,代表字符数组,可以对应一个字符串,如

    char * a="string1";
    char b[]="string2";

    这里a是一个指向char变量的指针,b则是一个char数组(字符数组)
    也就是说:

    二者的不同点

    一,char*是变量,值可以改变, char[]是常量,值不能改变!
    a是一个char型指针变量,其值(指向)可以改变;
    b是一个char型数组的名字,也是该数组首元素的地址,是常量,其值不可以改变

    二,char[]对应的内存区域总是可写,char*指向的区域有时可写,有时只读
    比如:

    char * a="string1";
    char b[]="string2";
    gets(a); //试图将读入的字符串保存到a指向的区域,运行崩溃! 
    gets(b) //OK

    解释: a指向的是一个字符串常量,即指向的内存区域只读;
    b始终指向他所代表的数组在内存中的位置,始终可写!

    注意,若改成这样gets(a)就合法了:

    char * a="string1";
    char b[]="string2";
    a=b; //a,b指向同一个区域
    gets(a) //OK
    printf("%s",b) //会出现gets(a)时输入的结果

    解释: a的值变成了是字符数组首地址,即&b[0],该地址指向的区域是char *或者说 char[8],习惯上称该类型为字符数组,其实也可以称之为“字符串变量”,区域可读可写。

    总结:char *本身是一个字符指针变量,但是它既可以指向字符串常量,又可以指向字符串变量,指向的类型决定了对应的字符串能不能改变!

    三,char * 和char[]的初始化操作有着根本区别:
    测试代码:

    char *a="Hello World"; 
    char b[]="Hello World"; 
    printf("%s, %d\n","Hello World", "Hello World"); 
    printf("%s, %d %d\n", a, a,  &a);                           
    printf("%s, %d %d\n", b,     b,  &b);

    结果:

    Hello World,13457308
    Hello World,13457308    2030316
    Hello World,2030316 2030316

    结果可见:尽管都对应了相同的字符串,但”Hellow World”的地址 和 a对应的地址相同,与b指向的地址有较大差异;&a 、&b都是在同一内存区域,且&b==b
    根据c内存区域划分知识,我们知道,局部变量都创建在栈区,而常量都创建在文字常量区,显然,a、b都是栈区的变量,但是a指向了常量(字符串常量),b则指向了变量(字符数组),指向了自己(&b==b==&b[0])。
    说明以下问题:
    char * a=”string1”;是实现了3个操作:

    1. 声明一个char*变量(也就是声明了一个指向char的指针变量);
    2. 在内存中的文字常量区中开辟了一个空间存储字符串常量”string1”
    3. 返回这个区域的地址,作为值,赋给这个字符指针变量a

    最终的结果:指针变量a指向了这一个字符串常量“string1”
    (注意,如果这时候我们再执行:char * c=”string1”;则,c==a,实际上,只会执行上述步骤的1和3,因为这个常量已经在内存中创建)

    char b[]=”string2”;则是实现了2个操作:

    1. 声明一个char 的数组,
    2. 为该数组“赋值”,即将”string2”的每一个字符分别赋值给数组的每一个元素

    最终的结果:“数组的值”(注意不是b的值)等于”string2”,而不是b指向一个字符串常量

    实际上, char * a=”string1”; 的写法是不规范的!
    因为a指向了即字符常量,一旦strcpy(a,”string2”)就糟糕了,试图向只读的内存区域写入,程序会崩溃的!尽管VS下的编译器不会警告,但如果你使用了语法严谨的Linux下的C编译器GCC,或者在windows下使用MinGW编译器就会得到警告。
    所以,我们还是应当按照”类型相同赋值”的原则来写代码:

    const char * a="string1";

    保证意外赋值语句不会通过编译

    另外,关于char*和char[]在函数参数中还有一个特殊之处,运行下面的代码

    void fun1 ( char *p1,  char p2[] ) {
     printf("%s %d %d\n",p1,p1,&p1);
     printf("%s %d %d\n",p2,p2,&p2);
    p2="asdf"; //通过! 说明p2不是常量! 
    printf("%s %d %d\n",p2,p2,&p2);
    }
    void main(){
    char a[]="Hello";
    fun1(a,a);
    }

    运行结果:

    Hello 3471628 3471332
    Hello 3471628 3471336
    asdf 10704764 3471336

    结果出乎意料!上面结果表明p2这时候根本就是一个指针变量!
    结论是:作为函数的形式参数,两种写法完全等效的!都是指针变量!

    const char*与char[]的区别:
    const char * a=”string1”
    char b[]=”string2”;
    二者的区别在于:

    1. a是const char 类型, b是char const类型
      ( 或者理解为 (const char)xx 和 char (const xx) )

    2. a是一个指针变量,a的值(指向)是可以改变的,但a只能指向(字符串)常量,指向的区域的内容不可改变;

    3. b是一个指针常量,b的值(指向)不能变;但b指向的目标(数组b在内存中的区域)的内容是可变的

    4. 作为函数的声明的参数的时候,char []是被当做char *来处理的!两种形参声明写法完全等效!

    字符串类型之间的转换: string、const char*、 char* 、char[]相互转换

    一、转换表格

    源格式->目标格式stringchar*const char*char[]
    stringNULL直接赋值直接赋值直接赋值
    char*strcpyNULLconst_castchar*=char
    const char*c_str()直接赋值NULLconst char*=char;
    char[]copy()strncpy_s()strncpy_s()NULL

    二、总结方法:

    1. 变成string,直接赋值。
    2. char[]变成别的,直接赋值。
    3. char*变constchar*容易,const char*变char*麻烦。<const_cast><char*>(constchar*);
    4. string变char*要通过const char*中转。
    5. 变成char[]。string逐个赋值,char* const char* strncpy_s()。

    三,代码示例

    1、string转为其他类型

    ①、string转const char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";     //初始化string类型,并具体赋值
        const char* constc = nullptr;         //初始化const char*类型,并赋值为空
        constc= str.c_str();                 //string类型转const char*类型
        printf_s("%s\n", str.c_str());        //打印string类型数据 .c_str()
        printf_s("%s\n", constc);             //打印const char*类型数据
        return 0;
    }

    ②、string转char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";     //初始化string类型,并具体赋值
        char* c = nullptr;                    //初始化char*类型,并赋值为空
        const char* constc = nullptr;         //初始化const char*类型,并赋值为空
        constc= str.c_str();                 //string类型转const char*类型
        c= const_cast<char*>(constc);        //const char*类型转char*类型
        printf_s("%s\n", str.c_str());        //打印string类型数据 .c_str()
        printf_s("%s\n",c);                  //打印char*类型数据
        return 0;
    
    }

    ③、string转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        std::string str = "HelloWorld!";      //初始化string类型,并具体赋值
        char arrc[20] = {0};                   //初始化char[]类型,并赋值为空
        for (int i = 0; i < str.length(); i++) //string类型转char[]类型
        {
            arrc[i]=str[i];
        }
        printf_s("%s\n", str.c_str());         //打印string类型数据 .c_str()
        printf_s("%s\n", arrc);                //打印char[]类型数据
        return 0;
    }

    2、const char*转为其他类型

    ①const char*转string

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        std::string str;                        //初始化string类型
        str= constc;                            //const char*类型转string类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", str.c_str());           //打印string类型数据
        return 0;
    }

    ②const char*转char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        char* c = nullptr;                       //初始化char*类型
        c= const_cast<char*>(constc);           //const char*类型转char*类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", c);                     //打印char*类型数据
        return 0;
    }

    ③const char*转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        const char* constc = "Hello World!";     //初始化const char* 类型,并具体赋值
        char arrc[20] = { 0 };                   //初始化char[]类型,并赋值为空
        strncpy_s(arrc,constc,20);              //const char*类型转char[]类型
        printf_s("%s\n", constc);                //打印const char* 类型数据
        printf_s("%s\n", arrc);                  //打印char[]类型数据
        return 0;
    }

    3、char*转为其他类型

    ①char*转string

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";           //初始化char* 类型,并具体赋值
        std::string str;                   //初始化string类型
        str= c;                            //char*类型转string类型
        printf_s("%s\n", c);                //打印char* 类型数据
        printf_s("%s\n", str.c_str());      //打印string类型数据
        return 0;
    }

    ②char*转const char*

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";         //初始化char* 类型,并具体赋值
        const char* constc = nullptr;     //初始化const char* 类型,并具体赋值
        constc= c;                       //char*类型转const char* 类型
        printf_s("%s\n", c);              //打印char* 类型数据
        printf_s("%s\n", constc);         //打印const char* 类型数据
        return 0;
    }

    ③char*转char[]

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char* c = "HelloWorld!";         //初始化char* 类型,并具体赋值
        char arrc[20] = { 0 };           //初始化char[] 类型,并具体赋值
        strncpy_s(arrc,c,20);             //char*类型转char[] 类型
        printf_s("%s\n", c);              //打印char* 类型数据
        printf_s("%s\n", arrc);           //打印char[]类型数据
        return 0;
    }

    4、char[]转为其他类型

    #include "stdafx.h"
    #include <iostream>
    int _tmain(intargc, _TCHAR* argv[])
    {
        char arrc[20] = "HelloWorld!";//初始化char[] 类型并具体赋值
        std::string str;                 //初始化string
        const char* constc = nullptr;   //初始化const char*
        char*c = nullptr;                //初始化char*
        str= arrc;                     //char[]类型转string类型
        constc= arrc;             //char[]类型转const char* 类型
        c= arrc;                        //char[]类型转char*类型
        printf_s("%s\n", arrc);         //打印char[]类型数据
        printf_s("%s\n", str.c_str());  //打印string类型数据
        printf_s("%s\n", constc);       //打印const char* 类型数据
        printf_s("%s\n", c);            //打印char*类型数据
        return 0;
    }
    展开全文
  • C++ 字符串

    2021-01-03 01:46:31
    C++ 提供了以下两种类型字符串表示形式: C 风格字符串 C++ 引入的 string 类类型 C 风格字符串 C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 ” 终止的一维字符数组。...
  • c++字符串与c字符串

    千次阅读 多人点赞 2019-05-27 19:32:26
    c++字符串与c风格字符串1. C风格的字符串2. 字符串字面量3.C++ std::string 类3.1 C风格字符串的优势和劣势3.2 使用string类3.2.1 std::string 字面量3.2.2 c++字符串的数值转换(1)字符串转数值(2)数值转字符串3.2.3...
  • C++ 字符串 对象 C++ 字符串 对象 创建方法 C++ 字符串 对象 输出到控制台 C++ 字符串 拼接 C++ 字符串 方法调用 ( 栈内存对象 ) C++ 字符串 方法调用 ( 堆内存对象 ) C / C++ 字符串 完整代码示例
  • C++字符串数组 | 字符串数组输出

    千次阅读 2020-12-12 22:12:52
    C++字符串数组定义 在C++中不仅可以用string定义字符串变量,也可以用string定义字符串数组。 string array[3]; 表示定义一个字符串数组,这个数组包含3个字符串元素。 C++字符串数组初始化 string array[3]={{"li...
  • C++字符串数组

    万次阅读 多人点赞 2019-05-30 22:43:54
    C++提供了一种新的数据类型——字符串类型(string类型),在使用方法上,它和char、int类型一样,可以用来定义变量,这就是字符串变量——用一个名字代表一个字符序列。 实际上,string并不是C++语言本身具有的基本类型,它...
  • c++字符串操作

    千次阅读 2019-07-02 09:47:44
    c++中有字符串类型的数据:string 获取某一位置的字符串:str.at(i) 或者str[i] 截取字符串str.substr(begin,end); 最大整形数long long:9223372036854775807 最小整形数long long:-9223372036854775808 过长...
  • C++字符串类 | 使用string输出

    千次阅读 2020-12-12 22:07:58
    C++提供了一种新的数据类型:字符串类型,它和char,int类型一样,可以用来定义变量,用一个名字代表一个字符序列,这就是字符串变量。 读者需要明白string并不是C++本身具有的基本类型,它是在C++标准库中声明的一...
  • 【C/C++字符串类型

    千次阅读 2018-07-23 16:12:49
    C++提供了两种字符串的表示:C 风格的字符串和标准 C++引入的 string 类类型。 1. C 风格字符串 C 风格的字符串起源于 C 语言 并在 C++中继续得到支持。字符串被存储在一个字符数组中 一般通过一个 char*类型的...
  • C++基础知识篇:C++ 字符串

    千次阅读 2020-12-17 22:36:24
    C++ 提供了以下两种类型字符串表示形式: C 风格字符串 C++ 引入的 string 类类型 C 风格字符串 C 风格的字符串起源于 C 语言,并在 C++ 中继续得到支持。字符串实际上是使用null字符 '\0' 终止的一维字符数组...
  • 本文主要介绍在 C++ 编程语言中,将整型转换为字符串类型的具体方法。 1 使用to_string函数 在 C++11 标准中,可以使用 to_string 函数,将整型转换为字符串类型。 1.1 to_string函数介绍 to_string 函数的用法...
  • 文章目录字符串与数字的转换使用方法string-->数字数字-->string面试题 字符串与数字的转换 利用标准库中相关的类 字符串流类(sstream)用于string的转换 sstream相关头文件 istringstream字符串输入流 ...
  • 【C++】C++字符串和数字的拼接

    千次阅读 2019-11-27 11:21:18
    如果你使用过python,你会发现字符串和int/float/double便捷的拼接方式;...通过std::to_string()将数字类型转换成std::string类型,从而可以直接使用+完成字符串的拼接。 # include <iostream> i...
  • C++ 字符串string类型最常用操作总结

    千次阅读 2017-10-03 16:09:46
    C++中string类型各种常用函数的讲解和总结。
  • 在C语言中,应用字符串需要定义字符数组,字符串需要存放在字符数组中。然后利用各种字符串操作函数对其操作。 http://blog.csdn.net/chaipp0607/article/details/56676791但是这种方式存在一些弊端,比如字符数组...
  • C++ 字符串替换

    千次阅读 2015-08-24 16:18:44
    C++实现字符串的分割和替换,作为平时代码库的储备,仅供各位猿友参考.
  • C++ 字符串转换

    千次阅读 2017-08-13 20:42:40
     如 L"我的字符串" 表示将ANSI字符串转换成unicode的字符串,就是每个字符占用两个字节。   strlen("asd") = 3;  strlen(L"asd") = 6; LPCTSTR不是一个类型,而是两种类型:LPCSTR和LPCWSTR其中之一。会...
  • C++字符串输入输出以及复合类型浅谈

    千次阅读 多人点赞 2020-04-04 21:40:53
    想要使用cout输出两个字符数组,第二个被正常输出,第一个正常输出后出现了乱码,处理字符串的函数,像cout输出字符串,它们都会把字符串里面的字符一个一个的进行处理,如果遇到空字符,则停止处理,由于第一种写法...
  • C字符串和C++字符串的区别

    千次阅读 2016-05-10 14:03:32
    C字符串和C++字符串  在C中,并没有字符串这个数据类型,而是使用字符数组来保存字符串。C字符串实际上就是一个以null('\0')字符结尾的字符数组,null字符表示字符串的结束。需要注意的是:只有以null字符结尾...
  • C++字符串hash

    千次阅读 2020-01-16 20:42:53
    程序中声明了一个字符串容器 a set 函数,它是C++STL中一种标准关联容器 set 中每个元素的值都是唯一的即没有重复元素(用来差余) 且set 中元素自动排序 结构为 set<类型> 标识符 //程序中定义一种...
  • C++ 字符串 int转字符串

    千次阅读 2018-10-22 13:08:13
    1、使用stringstream #include &lt;sstream&gt; int i; stringstream ss; string s; ss&lt;&... 在C++中可以使用stringstream来很方便的进行类型转换,字符串串接,不过注意重...
  • C++实现字符串类型(String16/String8/const char/char)转换  最近在C++开发的时候遇到这么个问题,需要对函数参数中传来的String16参数进行大小写统一的转换,并且转换后的数据类型还是String16.下面就...
  • C/C++字符串和数字的相互转换

    千次阅读 2019-11-15 21:31:30
    平时有可能会用到将int的1转换为string的"1"的题型,下面对C/C++字符串和数字的相互转换进行整理: int、long 和 double 等类型,有时也需要转换为字符串形式,这样结果字符串才能立即输出到文件或其他输入输出设备...
  • 获取C/C++字符串、字符数组长度

    万次阅读 多人点赞 2018-03-26 21:18:24
    在C/C++中常用的获取字符串长度或者字符串数组长度的函数有 sizeof() length() strlen() size() 其中strlen(str)和str.length()和str.size()都可以用来求字符串的长度 str.length()和str.size()是用于求...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 354,860
精华内容 141,944
关键字:

c++字符串类型

c++ 订阅