精华内容
下载资源
问答
  • ——字符’\0’结尾的char数组就是一个字符串,但如果char数组没有’\0’结尾,那么就不是一个字符串,只是普通字符数组,所以字符串是一种特殊的char数组。 两者的区别: 字符串: 1、字符串赋初值用双引号引...

    字符串与字符数组

    字符串一定是一个char的数组,但char的数组未必是字符串。——以字符’\0’结尾的char数组就是一个字符串,但如果char数组没有以’\0’结尾,那么就不是一个字符串,只是普通字符数组,所以字符串是一种特殊的char数组

    两者的区别:
    字符串:
    1、字符串赋初值用双引号引起来;
    2、以隐含的空字符\0结束,占用字节数+1,注意:1字节/字母,2字节/汉字;
    3、字符串可以使用%s格式化输出。
    普通字符数组:
    1、普通的字符数组赋初值用大括号引起来;
    2、不包含空字符,占用字节数不需+1;
    3、普通字符数组使用%s格式化输出,输出结果会乱码,因为没有’\0’结束符。
    例如:

    #include <stdio.h>
    #include <string.h>
    int main(void)
    {
        /*字符数组赋初值*/
        char cArr[] = {'I','L','O','V','E','C'};
        /*字符串赋初值*/
        char sArr[] = "ILOVEC";
        /*用sizeof()求长度*/
        printf("cArr的长度=%d\n", sizeof(cArr));
        printf("sArr的长度=%d\n", sizeof(sArr));
        /*用printf的%s打印内容*/
        printf("cArr的内容=%s\n", cArr);
        printf("sArr的内容=%s\n", sArr);
        return 0;
    }
    

    运行结果为:
    在这里插入图片描述
    如果定义:

     char cArr[] = {'I','L','O','V','E','C','\0'};
     char sArr[] = "ILOVEC";
    

    那么cArr与sArr就完全相同,都表示同一字符串。

    另外,%s格式化输出从当前地址到结束标志’\0’之前的所有字符,如:

    #include <stdio.h>
    #include <string.h>
    int main(){
        char str[] = "http://c.biancheng.net";
        printf("%s\n", str); //直接输出字符串
        printf("%s\n", str+1); //输出从第二个地址到最后的值
        printf("%s\n", str+2); //输出从第三个地址到最后的值
        return 0;
    }
    

    在这里插入图片描述
    通过对以上代码的分析,现在我们可以很简单地总结出字符数组和字符串二者之间的区别:
    对于字符数组,其长度是固定的,其中任何一个数组元素都可以为 null 字符。因此,字符数组不一定是字符串。
    对于字符串,它必须以 null 结尾,其后的字符不属于该字符串。字符串一定是字符数组,它是最后一个字符为 null 字符的字符数组。

    字符串数组与字符串指针

    字符串数组:

    //字符串数组
    #include <stdio.h>
    #include <string.h>
    int main(){
        char str[] = "http://c.biancheng.net";
        int len = strlen(str), i;
        //直接输出字符串
        printf("%s\n", str); //可以直接输出当前地址(字符串首地址)到结束标志'\0'之前的所有字符
        //每次输出一个字符
        for(i=0; i<len; i++){
            printf("%c", str[i]);
        }
        printf("\n");
        return 0;
    }
    

    字符串指针:

    //字符串指针
    #include <stdio.h>
    #include <string.h>
     
    int main(){
    char *str = "http://c.biancheng.net";
    int len = strlen(str), i;
     
    //直接输出字符串
    printf("%s\n", str); //可以直接输出当前地址(字符串首地址)到结束标志'\0'之前的所有字符
    //使用*(str+i)
    for(i=0; i<len; i++){
    printf("%c", *(str+i));
    }
    printf("\n");
    //使用str[i]
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }
    printf("\n");
     
    return 0;
    }
    

    运行结果都是:
    http://c.biancheng.net

    这一切看起来和字符数组是多么地相似,它们都可以使用%s输出整个字符串,都可以使用*或[ ]获取单个字符,这两种表示字符串的方式是不是就没有区别了呢?

    有!它们最根本的区别是在内存中的存储区域不一样,字符数组存储在全局数据区或栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。

    内存权限的不同导致的一个明显结果就是,字符数组在定义后可以读取和修改每个字符,而对于第二种形式的字符串,一旦被定义后就只能读取不能修改,任何对它的赋值都是错误的。

    我们将第二种形式的字符串称为字符串常量,意思很明显,常量只能读取不能写入。请看下面的演示:

    
    #include <stdio.h>
    int main(){
    char *str = "Hello World!";
    str = "I love C!"; //正确
    str[3] = 'P'; //错误
     
    return 0;
    }
    

    这段代码能够正常编译和链接,但在运行时会出现段错误(Segment Fault)或者写入位置错误。
    第4行代码是正确的,可以更改指针变量本身的指向;第5行代码是错误的,不能修改字符串中的字符。

    到底使用字符数组还是字符串常量
    在编程过程中如果只涉及到对字符串的读取,那么字符数组和字符串常量都能够满足要求;如果有写入(修改)操作,那么只能使用字符数组,不能使用字符串常量。

    最后我们来总结一下,C语言有两种表示字符串的方法,一种是字符数组,另一种是字符串常量(用指针表示),它们在内存中的存储位置不同,使得字符数组可以读取和修改,而字符串常量只能读取不能修改。

    展开全文
  • java字符串字符串数组Java String array is used to hold fixed number of Strings. String array is very common in simple java programs, specially among beginners to java and to test some specific ...

    java字符串转字符串数组

    Java String array is used to hold fixed number of Strings. String array is very common in simple java programs, specially among beginners to java and to test some specific scenarios. Even java main method argument is string array – public static void main(String[] args). So today we will look into different aspects of java string array with example programs.

    Java String数组用于保存固定数量的String。 字符串 数组简单的Java程序中非常常见,特别是在Java初学者和测试某些特定情况的初学者中。 甚至java main方法的参数也是字符串数组– public static void main(String[] args) 。 因此,今天我们将通过示例程序研究java字符串数组的不同方面。

    • Java String array is basically an array of objects.

      Java String数组基本上是对象的数组。
    • There are two ways to declare string array – declaration without size and declare with size.

      声明字符串数组的方法有两种:不声明大小和声明大小。
    • There are two ways to initialize string array – at the time of declaration, populating values after declaration.

      有两种初始化字符串数组的方法-在声明时,在声明后填充值。
    • We can do different kind of processing on string array such as iteration, sorting, searching etc.

      我们可以对字符串数组进行不同类型的处理,例如迭代,排序,搜索等。

    Let’s go over java string array example programs now.

    现在让我们来看一下Java字符串数组示例程序。

    Java字符串数组声明 (Java String Array Declaration)

    Below code snippet shows different ways for string array declaration in java.

    下面的代码片段显示了Java中字符串数组声明的不同方法。

    String[] strArray; //declare without size
    
    String[] strArray1 = new String[3]; //declare with size

    Note that we can also write string array as String strArray[] but above shows way is the standard and recommended way. Also in the above code, strArray is null whereas strArray1 value is [null, null, null].

    请注意,我们也可以将字符串数组编写为String strArray[]但以上所示的方法是标准和推荐的方法。 同样在上面的代码中, strArraynullstrArray1值为[null, null, null]

    Java字符串数组初始化 (Java String Array Initialization)

    Let’s look at different ways to initialize string array in java.

    让我们看看在Java中初始化字符串数组的不同方法。

    //inline initialization
    String[] strArray1 = new String[] {"A","B","C"};
    String[] strArray2 = {"A","B","C"}; 
    
    //initialization after declaration
    String[] strArray3 = new String[3];
    strArray3[0] = "A";
    strArray3[1] = "B";
    strArray3[2] = "C";

    All the three string arrays will have same values. However if you will call equals method on them, it will return false.

    三个字符串数组都将具有相同的值。 但是,如果您将对它们调用equals方法,它将返回false。

    System.out.println(strArray1.equals(strArray2)); // false
    System.out.println(Arrays.toString(strArray1).equals(Arrays.toString(strArray2)));// true

    The reason is that array are Objects and Object class implements equals() method like below.

    原因是数组是Objects,而Object类实现了equals()方法,如下所示。

    public boolean equals(Object obj) {
            return (this == obj);
        }

    Second statement is true because when converted to String, their values are same and String class equals() method implementation check for values. For more details, please check String class API documentation.

    第二条语句是正确的,因为当转换为String时,它们的值是相同的,并且String类equals()方法实现会检查值。 有关更多详细信息,请查看String类API文档。

    遍历Java字符串数组 (Iterating over java string array)

    We can iterate over string array using java for loop or java foreach loop.

    我们可以使用java for循环java foreach循环遍历字符串数组。

    String[] strArray2 = {"A","B","C"}; 
    for (int i = 0; i < strArray2.length; i++) {
    	System.out.print(strArray2[i]);
    }
    
    for (String str : strArray2) {
    	System.out.print(str);
    }

    在字符串数组中搜索字符串 (Search for a String in the String array)

    We can use for loop to search for an string in the array, below is a simple example for that.

    我们可以使用for循环在数组中搜索一个字符串,下面是一个简单的例子。

    package com.journaldev.stringarray;
    
    public class JavaStringArrayExample {
    
    	public static void main(String[] args) {
    		String[] strArray = { "A", "B", "C" };
    		
    		boolean found = false;
    		int index = 0;
    		String s = "B";
    		for (int i = 0; i < strArray.length; i++) {
    			if(s.equals(strArray[i])) {
    				index = i; found = true; break;
    			}
    		}
    		if(found)
    			System.out.println(s +" found at index "+index);
    		else
    			System.out.println(s +" not found in the array");
    		
    	}
    
    }

    Notice the use of break keyword to get out of the loop as soon as we found the string.

    注意,一旦找到字符串,就使用break关键字退出循环。

    Java字符串数组排序 (Java String Array Sorting)

    We can implement our own sorting algorithm, or we can use Arrays class sorting method.

    我们可以实现自己的排序算法,也可以使用Arrays类的排序方法。

    String[] vowels = {"a","i","u","e","o"};
    		
    System.out.println("Before sorting "+Arrays.toString(vowels));
    
    Arrays.sort(vowels);
    		
    System.out.println("After sorting "+Arrays.toString(vowels));

    Output of above code snippet will be:

    上面的代码片段的输出将是:

    Before sorting [a, i, u, e, o]
    After sorting [a, e, i, o, u]

    Note that String implements Comparable interface, so it works for natural sorting. Incase you want to sort by some other way, you can use Arrays.sort() overloaded method by passing a Comparator. Learn about these sorting techniques at Comparable and Comparator in java.

    请注意,String实现了Comparable接口,因此适用于自然排序。 如果要通过其他方式排序,则可以通过传递Comparator来使用Arrays.sort()重载方法。 在Java中的Comparable和Comparator中了解有关这些排序技术的信息。

    将字符串转换为字符串数组 (Convert String to String Array)

    We can convert String to string array using it’s split() method. It’s useful when you get a single string as input with values separated using delimiter character.

    我们可以使用它的split()方法将String转换为字符串数组。 当您获得单个字符串作为输入,并且使用定界符将值分隔开时,这很有用。

    String str = "a,e,i,o,u";
    String[] vowels = str.split(",");
    System.out.println(Arrays.toString(vowels)); //[a, e, i, o, u]

    将字符串数组转换为字符串 (Convert String Array to String)

    We can use Arrays.toString() method to convert String array to String. Note that array doesn’t implement toString() method, so if you will try to get it’s string representation then you will have to rely on Arrays class, or else write your own custom code.

    我们可以使用Arrays.toString()方法将String数组转换为String。 请注意,array不实现toString()方法,因此,如果您尝试获取它的字符串表示形式,则必须依赖Arrays类,或者编写自己的自定义代码。

    String[] vowels = { "a", "e", "i", "o", "u" };
    System.out.println(vowels);
    System.out.println(Arrays.toString(vowels));

    Output will be like below.

    输出将如下所示。

    [Ljava.lang.String;@3d04a311
    [a, e, i, o, u]

    The first output is because of Object class toString() implementation like below.

    第一个输出是由于如下所示的Object类toString()实现。

    public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }

    要列出的Java字符串数组 (Java String Array to List)

    We can get a list representation of string array using Arrays.toList() method. Note that this list is backed by the array and any structural modification will result in java.lang.UnsupportedOperationException.

    我们可以使用Arrays.toList()方法获得字符串数组的列表表示形式。 请注意,此列表由数组支持,任何结构修改都会导致java.lang.UnsupportedOperationException

    String[] vowels = { "a", "e", "i", "o", "u", "a", "o" };
    
    List<String> vowelsList = Arrays.asList(vowels);
    System.out.println("vowelsList = "+vowelsList);
    //vowelsList.add("x"); //java.lang.UnsupportedOperationException
    
    vowelsList.set(0, "x"); //allowed because no structural modification
    System.out.println("vowelsList = "+vowelsList);

    That’s all for java string array.

    Java字符串数组就这些了。

    Reference: Arrays Oracle Documentation

    参考: 阵列Oracle文档

    翻译自: https://www.journaldev.com/17809/java-string-array

    java字符串转字符串数组

    展开全文
  • 不是的,C语言中字符数组既可以保存字符,又可以保存字符串字符数组本意就是是指用来存放字符数据的数组。字符数组的元素是字符类型的。字符数组用于存放字符或字符串。 C语言中字符数组的一般形式为: char 数组...

    C语言中字符数组只能存放字符串?

    不是的,C语言中字符数组既可以保存字符,又可以保存字符串。

    字符数组本意就是是指用来存放字符数据的数组。字符数组的元素是字符类型的。字符数组用于存放字符或字符串。

    C语言中字符数组的一般形式为: char 数组名[数据长度] 。例如:char a[10]; a[0]=‘0’; a[1]=’ 1’; a[2]=‘2’; a[3]=‘3’; a[4]=‘4’; a[5]=‘5’; a[6]=’ 6’; a[7]=‘7’; a[8]=‘8’; a[9]=‘9’; 就定义了a为字符数组,包含10个"0"到“9”的字符元素。

    因此,C语言中字符数组不单单只能保存字符串。

    字符数组百和字符串的唯一区别?

    字符串必须有\0结束
    但字符数组可以没有
    没有的情况只有一个,就是字符吧数组所有的空间占用了。
    可能你不明白,举例说一下,
    申请了一个数组,a[3],有三个元素的度位置
    那么当三个字符都填充到这三个单元的时候,就是如xyz三个字符a[0]=‘x’,a[1]=‘y’,a[2]=‘z’
    那么a这个数组将没有\0的空间,
    这样是可以的,
    但是要是用字符串处理函数,如道puts,strcpy等函数的时候,这样的数组是不能当字符串来处理的,因为没有\0这个结束符,所有可能有很多乱码出现,这是正常的。
    因为这些函回数需要\0来判断字符串的结束位置,但是这样的数组没有\0,所以这些函数处理这样的数组时,判断结束不准确答,会出现乱码

    展开全文
  • 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 结尾的字符串:

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

    一、转换表格

    源格式->目标格式 string char* const char* char[]
    string NULL 直接赋值 直接赋值 直接赋值
    char* strcpy NULL const_cast char*=char
    const char* c_str() 直接赋值 NULL const 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 语言中并不存在字符串这个数据类型,而是使用字符数组保存字符串。那么,字符数组就一定是字符串吗? 对于这个问题,大多教科书中的回答是“是”。其实不然,字符数组字符串是完全不相同的两个概念,千万不要...
  • 和数组形式定义的字符串相同,数组形式定义的字符串数组,存储了字符串字面量的副本,可以直接对这些字符串进行更改 d. 其中每个含有m个元素的数组必须不大不小的将数组填满,如果字符串长度小于m-1,其余位置就补...
  • 一、数组字符串(将数组元素用...二、字符串转数组(将字符串按某个字符切割成若干个字符串,并以数组形式返回) var s = "abc,abcd,aaa"; ss = s.split(",");// 在每个逗号(,)处进行分解。 一个实例: var db
  • 一直以为保存图片postgreSql中表中保存图片的字段类型为bytea,经过反复测试一直没有解决,故采用了TEXT类型来保存图片, 具体方法如下: 保存: BL层: public bool SavePictureToDB() { try { Stream s ...
  • 字符串 ... 创建字符向量 通过将字符序列括在单引号中来创建一个字符向量。 chr = 'Hello, world' ...字符向量为 char 类型的 1×n 数组。在计算机编程中,字符串是表示 1×n 字符数组的常用术 语。但...
  • 字符串数组字符串指针

    千次阅读 2016-01-04 19:01:43
    最近在学指针,感觉内容繁多,概念不好掌握,除了上自己班的编程课,还... 给字符数组赋值分两种情况,单字符赋值和字符串赋值。 单字符赋值:可通过数组下标方式或指针方式,引用数组元素,进行赋值 //数组下标法
  • 在使用Matlab的时候,经常...而实际保存时,希望如下形式保存: 第1个数是:20 第2个数是:30 第3个数是:40 第4个数是:50 第5个数是:60 而后面的 20,30,40,50,60则是由另外一个数值数组 result 提
  • 十一、字符串 ????C语言中的字符串 在C语言中 字符串是这样的: char msg[]={'H','e','l','l','o','\0'};...在C语言中 字符串以字符数组形式存在的 (这才叫字符"串" 哈哈) 数组或指针的形式来访问字符串
  • C++字符串字符数组

    2019-06-19 11:45:46
    在C++中,有两种类型的字符串表示形式: C-风格字符串 C++引入的string类 C-风格字符串 C 风格的字符串起源于C语言,并在C++中继续得到支持。字符串实际上是使用null字符‘\0’终止的一维字符数组。 下面的声明和...
  • C中字符串常量&字符数组&字符常量

    千次阅读 多人点赞 2019-12-17 11:21:42
    在 C 语言中,字符串有两种存储方式,一种是通过字符数组存储,另一种是通过字符指针存储。 一、字符常量: 一个用单引号括起来的单个字符(或字符转义序列或三字母词) 实质(含义):是一个整形值。属于四大...
  • 3.1字符串数组

    2017-04-08 15:40:17
    3.1字符串数组
  • 字符数组: 用来存放字符的数组称为字符数组,例如: char a[10]; //一维字符数组 char b[5][10]; //二维字符数组 char c[20]={'c', ' ', 'p', 'r', 'o', 'g', 'r', 'a','m'};  // 给部分...
  • 1、字符数组的定义与初始化 字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。 char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]str[9]10个元素 ...
  • //实际上是一个隐含创建的类型为char的数组,一个字符串常量就是表示一个数组的首地址 //因此可以将字符串常量赋给字符串指针,由于常量值是不能修改的,应将字符串常量赋给一个指向常量的指针 const char* s1 =
  • 给定一个字符串以字符数组形式给出)和一个偏移量,根据偏移量原地旋转字符串(从左向右旋转) 样例 样例 1: 输入: str=“abcdefg”, offset = 3 输出: str = “efgabcd” 样例解释: 注意是原地旋转,即str旋转后...
  • 字符串本身是存放在该首地址为首的一块连续的内存空间中并‘\0’作为串的结束。字符数组是由于若干个数组元素组成的,它可用来存放整个字符串。 2. 对字符串指针方式 char *ps="C Language"; 可以写为: ...
  • 结构体转为字符串数组

    千次阅读 2018-05-23 13:59:11
    在工作中需要进行发送一包数据,而且数据的格式各不一样,只能定义为结构体的形式,但是发送方式以字符串形式进行发送,这样就需要将结构体类型的变量转换为字符串数组。下面只是,自己定义的结构体进行的转换,...
  • MATLAB字符串数组

    千次阅读 2011-05-14 20:59:00
    4.1 字符串数组4.1.1 字符串入门【 * 例 4.1.1 -1 】先请读者实际操作本例,体会数值量与字符串的区别。clear % 清除所有内存变量a=12345.6789 % 给变量 a 赋数值标量class(a) % 对变量 a 的类别进行判断a_s=size...
  • -------字符串数组字符串函数 一、字符串数组 定义:用于存放字符的数组,可以是一维或者多维。 一般形式:char 数组名[数组长度] 初始化:两种方法 1、先定义后初始化,例如:char ch[5]; ch[5]={'a','b','...
  • Visual Basic快捷教程——数组字符串

    千次阅读 热门讨论 2010-10-18 20:11:00
    字符串可以看成是一种特殊的数组,其中每个元素都是一个字符,所以字符串类型所表示的就是一系列的字符。数组字符串是编程语言中的重要组成部分,也是实际开发中被大量使用的内容,本文主要介绍Visual Basic 2013...
  • Javascript 对字符串数组的操作

    千次阅读 2015-10-10 19:49:47
    JS一些简单的知识可能大家随便搜一下就可以搜,所以本文先着重介绍在JavaScript的数组中进行数组元素查找和替换(指对每个元素的内容查找和替换),然后再介绍一下Js对字符串和数组的基本操作。 一、在...
  • js数组字符串的相互转换方法 1、数组字符串 需要将数组元素用某个字符连接成字符串,示例代码...实现方法为将字符串按某个字符切割成若干个字符串,并以数组形式返回,示例代码如下: var s = "abc,abcd,a...
  • 我们知道,字符数组字符串都可以用于存储文本数据。 任何与字符串相关的问题一定可以从字符串的属性里面找到线索,比如不可变性。 对于String password1 = "1q2w3e";,String实例(本...
  • 第一部分:一维数组 我们之前所学过的数据类型都属于基本数据类型(整型、浮点型、字符型)。...数组中的元素由下标(或索引)标识,下标是从0开始n-1(数组长度为n)的整数。 示例:一个拥有10个元素的i...
  • 就是“123456”这样的一个字付变成一个数组String[] s = new String[]{"1","2","3","4","5"}; 或者把我循环打印出来的结果12345用result+"," 1,2,3,4,5, 存一个String[] s数组里面 求demo啊,求大神指点一下要...
  • 字符数组 char arr[]="hello"; 等同于 char arr[]={'h','e','l','l','o','\0'} strlen(arr)=5 sizeof(str)=6 字符串常量 char *parr="hello" strlen(arr)=5 sizeof(str)=5 字符串常量与函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 206,609
精华内容 82,643
关键字:

以字符串形式保存到字符数组