精华内容
下载资源
问答
  • c++字符串数组初始化
    万次阅读 多人点赞
    2020-12-12 22:12:52

    C++字符串数组定义

    在C++中不仅可以用string定义字符串变量,也可以用string定义字符串数组。

    string array[3];
    

    表示定义一个字符串数组,这个数组包含3个字符串元素。

    C++字符串数组初始化

    string array[3]={{"li"},{"zhang"},{"wang"}}
    

    读者在使用字符串数组时应该注意以下几点:

    在一个字符串数组中包含若干个元素,每个元素相当于一个字符串变量。

    并不要求每个字符串元素具有相同的长度,即使对同一个元素而言,它的长度也是可以变化的,当向某一个元素重新赋值,其长度就可能发生变化。

    在字符串数组的每一个元素中存放一个字符串,而不是一个字符,这是字符串数组与字符数组 的区别。

    如果用字符数组存放字符串,一个元素只能存放一个字符,用一个一维字符数组存放一个字符串。

    每一个字符串元素中只包含字符串本身的字符,而不包括\0,用字符串数组存放字符串以及对字符串进行处理是很方便的。

    在C++中定义字符串数组时,编译系统为每一个字符串变量分配4个字节,在存储单元中,并不是直接存放字符串本身,而是存放字符串的地址。

    经典案例:C++实现用字符串数组输出。

    #include<iostream>//预处理
    #include<string> //引入string 
    using namespace std;//命名空间 
    int main()//主函数 
    {
      string array[3]={{"zhangsan"},{"lisi"},{"wangwu"}};//定义字符串数组 
      for(int i=0;i<3;i++)//for循环 
      {
        cout<<array[i]<<endl;//挨个输出字符串变量的值 
      }
      return 0; //函数返回值为0;
    }
    

    执行本程序之后,会输出:

    zhangsan
    lisi
    wangwu
    
    --------------------------------
    Process exited after 1.425 seconds with return value 0
    请按任意键继续. . .
    

    C++字符串数组输出

    更多案例可以go公众号:C语言入门到精通

    更多相关内容
  • C 字符串数组初始化问题

    千次阅读 2021-05-19 09:29:16
    1、定义的时候直接用字符串赋值char a[10]="hello";注意:不能先定义再给它赋值,如char a[10]; a[10]="hello";这样是错误的!2、对数组中字符逐个赋值char a[10]={'h','e','l','l','o'};3、利用strcpychar a[10]; ...

    1、定义的时候直接用字符串赋值

    char a[10]="hello";

    注意:不能先定义再给它赋值,如char a[10]; a[10]="hello";这样是错误的!

    2、对数组中字符逐个赋值

    char a[10]={'h','e','l','l','o'};

    3、利用strcpy

    char a[10]; strcpy(a, "hello");

    易错情况:

    1、char a[10]; a[10]="hello";//一个字符怎么能容纳一个字符串?况且a[10]也是不存在的!

    2、char a[10]; a="hello";//这样的情况easy出现,a尽管是指针,可是它已经指向在堆栈中分配的10个字符空间,如今这个情况a又指向数据区中的hello常量,这里的指针a出现混乱,不同意!

    还有:不能使用关系运算符“==”来比較两个字符串,仅仅能用strcmp() 函数来处理。

    C语言的运算符根本无法操作字符串。在C语言中把字符串当作数组来处理,因此,对字符串的限制方式和对数组的一样,特别是,它们都不能用C语言的运算符进行复制和比較操作。

    直接尝试对字符串进行复制或比較操作会失败。比如,假定str1和str2有例如以下声明:

    char str1[10], str2[10];

    利用=运算符来把字符串拷贝到字符数组中是不可能的:

    str1 = "abc"; /*** WRONG ***/

    str2 = str1; /*** WRONG ***/

    C语言把这些语句解释为一个指针与还有一个指针之间的(非法的)赋值运算。可是,使用=初始化字符数组是合法的:

    char str1[10] = "abc";

    这是由于在声明中,=不是赋值运算符。

    试图使用关系运算符或判等运算符来比較字符串是合法的,但不会产生预期的结果:

    if (str1==str2) ... /*** WRONG ***/

    这条语句把str1和str2作为指针来进行比較,而不是比較两个数组的内容。由于str1和str2有不同的地址,所以表达式str1 == str2的值一定为0。

    动态数组的定义使用:

    数组究竟应该有多大才合适,有时可能不得而知。所以希望可以在执行时具有改变数组大小的能力。

    动态数组就行在不论什么时候改变大小。

    通俗的说静态数组就是在定义数组的时候,由操作系统分配的空间,比方

    int a[10];

    这就是在定义时由系统给你分配了10个int类型的空间,这个空间是能够初始化的,比方

    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    那么在这个定义之后,系统会首先分配10个int类型的存储空间,然后把大括号中面的数字分别的,按顺序放到这10个空间里。你所做的仅仅是写这么一句,而数组赋值的操作就由系统完毕了。当然,初始化与否看你的需求,初始化不是强制性操作,想初始化就初始化,不想也没问题,还是上面的样例继续:

    int a[10];

    这里定义了,可是没初始化,这没有不论什么问题,以后你能够自己往里面赋值,比方

    a[1] = 8;

    a[5] = 3;

    或者

    for(int i = 0; i < 10; i++)

    a[i] = i;

    等等

    对于动态数组,不能被初始化,由于动态数组在定义时仅仅是个指针,比方

    int *a;

    这里变量a仅仅是个指向int类型的指针,而不是数组。动态分配有10个int类型元素的数组,例如以下:

    a = (int * ) malloc(10*sizeof(int));

    非常明显,指针a在定义的时候不能被初始化,比方这样写就是错误的:

    int a = {1,2,3,4,5,6,7,8,9,10}; / 错误! */

    由于a是仅仅有4个字节的指针,没有可用的存储空间给须要初始化的变量。

    在C语言编程中,当我们声明一个字符串数组的时候,常常需要把它初始化为空串。总结起来有以下三种方式:

    (1) char str[10]="";

    (2) char str[10]={'\0'};

    (3) char str[10]; str[0]='\0';

    第(1)(2)种方式是将str数组的所有元素都初始化为'\0',而第(3)种方式是只将str数组的第一个元素初始化为'\0'。如果数组的size非常大,那么前两种方式将会造成很大的开销。

    所以,除非必要(即我们需要将str数组的所有元素都初始化为0的情况),我们都应该选用第(3)种方式来初始化字符串数组。

    1. 基本问题

    数组可以初始化,即在定义时,使它包含程序马上能使用的值。

    例如,下面的代码定义了一个全局数组,并用一组Fibonacci数初始化:

    1 int iArray[10]={1,1,2,3,5,8,13,21,34,55); //初始化

    2 void main()

    3  {

    4     //...

    5  }

    初始化数组的值的个数不能多于数组元素个数,初始化数组的值也不能通过跳过逗号的方式来省略,这在C中是允许的,但在C++中不允许。

    初始化值的个数可少于数组元素个数。当初始化值的个数少于数组元素个数时,前面的按序初始化相应值, 后面的初始化为0(全局或静态数组)或为不确定值(局部数组)。

    2.初始化字符数组

    初始化字符数组有两种方法,一种是:

    char array[10]={"hello"};

    另一种是:

    char array[10]={'h','e','l','l','\0'};

    第一种方法用途较广,初始化时,系统自动在数组没有填值的位置用,'\0'补上。另外, 这种方法中的花括号可以省略,即能表示成:

    char array[10]="hello";

    第二种方法一次一个元素地初始化数组,如同初始化整型数组。这种方法通常用于输入不容易在键盘上生成的那些不可见字符。

    例如,下面的代码中初始化值为若干制表符:

    char chArray[5]={'\t','\t','\t','\t','\0');

    这里不要忘记为最后的,'\0'分配空间。如果要初始化一个字符串"hello",那为它定义的数组至少有6个数组元素。

    例如,下面的代码给数组初始化,但会引起不可预料的错误:

    char array[5]="hello";

    该代码不会引起编译错误,但由于改写了数组空间以外的内存单元,所以是危险的。

    3.省略数组大小

    有初始化的数组定义可以省略方括号中的数组大小。

    例如,下面的代码中数组定义为5个元素:

    int a[]={2,4,6,8,10};

    编译时必须知道数组的大小。通常,声明数组时方括号内的数字决定了数组的大小。有初始化的数组定义又省略方括号中的数组大小时,编译器统计花括号之间的元素个数,以求出数组的大小。

    例如,下面的代码产生相同的结果:

    static int a1[5]={1,2,3,4,5};

    static int a2[]={1,2,3,4,5};

    让编译器得出初始化数组的大小有几个好处。它常常用于初始化一个元素个数在初始化中确定的数组,提供程序员修改元素个数的机会。

    在没有规定数组大小的情况下,怎么知道数组的大小呢? sizeof操作解决了该问题。

    1、字符数组的定义与初始化

    字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。

    char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'};

    即把10个字符分别赋给str[0]到str[9]10个元素

    如果花括号中提供的字符个数大于数组长度,则按语法错误处理;若小于数组长度,则只将这些字符数组中前面那些元素,其余的元素自动定为空字符(即'\0' )。

    2、字符数组与字符串

    在c 语言中,将字符串作为字符数组来处理。(c++中不是)在实际应用中人们关心的是有效字符串的长度而不是字符数组的长度,例如,定义一个字符数组长度为100,而实际有效字符只有40个,为了测定字符串的实际长度,C 语言规定了一个“字符串结束标志”,以字符'\0’代表。如果有一个字符串,其中第10个字符为'\0',则此字符串的有效字符为9个。也就是说,在遇到第一个字符'\0'时,表示字符串结束,由它前面的字符组成字符串。

    系统对字符串常量也自动加一个'\0'作为结束符。例如"C Program”共有9个字符,但在内存中占10个字节,最后一个字节'\0'是系统自动加上的。(通过sizeof()函数可验证)

    有了结束标志'\0'后,字符数组的长度就显得不那么重要了,在程序中往往依靠检测'\0'的位置来判定字符串是否结束,而不是根据数组的长度来决定字符串长度。当然,在定义字符数组时应估计实际字符串长度,保证数组长度始终大于字符串实际长度。(在实际字符串定义中,常常并不指定数组长度,如char str[ ])说明:'\0代表ASCII 码为0的字符,从ASCII 码表中可以查到ASCII 码为0的字符不是一个可以显示的字符,而是一个“空操作符”,即它什么也不干。用它来作为字符串结束标志不会产生附加的操作或增加有效字符,只起一个供辨别的标志。

    对C 语言处理字符串的方法由以上的了解后,再对字符数组初始化的方法补充一种方法——即可以用字符串常量来初始化字符数组:

    char str[ ]={"I am happy"};

    可以省略花括号,如下所示

    char str[ ]="I am happy";

    注意:上述这种字符数组的整体赋值只能在字符数组初始化时使用,不能用于字符数组的赋值,字符数组的赋值只能对其元素一一赋值,下面的赋值方法是错误的

    char str[ ];

    str="I am happy";//错误,字符数组的赋值只能按元素一一赋值

    不是用单个字符作为初值,而是用一个字符串(注意:字符串的两端是用双引号“”而不是单引号‘’括起来的)作为初值。显然,这种方法更直观方便。(注意:数组str 的长度不是10,而是11,这点请务必记住,因为字符串常量"I am happy"的最后由系统自动加上一个'\0')

    因此,上面的初始化与下面的初始化等价

    char str[ ]={'I',' ','a','m',' ','h','a','p','p','y','\0'};

    而不与下面的等价

    char str[ ]={'I',' ','a','m',' ','h','a','p','p','y'};

    前者的长度是11,后者的长度是10.

    说明:字符数组并不要求它的最后一个字符为'\0',甚至可以不包含'\0',向下面这样写是完全合法的。

    char str[5]={'C','h','i','n','a'};

    可见,用两种不同方法初始化字符数组后得到的数组长度是不同的。

    include

    void main(void)

    {

    char c1[]={'I',' ','a','m',' ','h','a','p','p','y'};

    char c2[]="I am happy";

    int i1=sizeof(c1);

    int i2=sizeof(c2);

    printf("%d\n",i1);

    printf("%d\n",i2);

    }

    结果:10 11

    3、字符串的表示形式

    在C 语言中,可以用两种方法表示和存放字符串:

    (1)用字符数组存放一个字符串

    char str[ ]="I love China";

    (2)用字符指针指向一个字符串

    char* str="I love China";

    对于第二种表示方法,有人认为str 是一个字符串变量,以为定义时把字符串常量"I love China"直接赋给该字符串变量,这是不对的。C 语言对字符串常量是按字符数组处理的,在内存中开辟了一个字符数组用来存放字符串常量,程序在定义字符串指针变量str 时只是把字符串首地址(即存放字符串的字符数组的首地址)赋给str。

    两种表示方式的字符串输出都用

    printf("%s\n",str);

    %s 表示输出一个字符串,给出字符指针变量名str(对于第一种表示方法,字符数组名即是字符数组的首地址,与第二种中的指针意义是一致的),则系统先输出它所指向的一个字符数据,然后自动使str 自动加1,使之指向下一个字符,如此,直到遇到字符串结束标识符" \0 "。

    4、对使用字符指针变量和字符数组两种方法表示字符串的讨论

    虽然用字符数组和字符指针变量都能实现字符串的存储和运算,但它们二者之间是有区别的,不应混为一谈。

    4.1、字符数组由若干个元素组成,每个元素放一个字符;而字符指针变量中存放的是地址(字符串/字符数组的首地址),绝不是将字符串放到字符指针变量中(是字符串首地址)

    4.2、赋值方式:

    对字符数组只能对各个元素赋值,不能用以下方法对字符数组赋值

    char str[14];

    str="I love China"; //错误,不是初始化,这是赋值,只能一一进行。

    (但在字符数组初始化时可以,即char str[14]="I love China";)

    而对字符指针变量,采用下面方法赋值:

    char* a;

    a="I love China";//指针赋值,可以

    或者是char* a="I love China"; 都可以

    4.3、对字符指针变量赋初值(初始化):

    char* a="I love China";

    等价于:

    char* a;

    a="I love China";

    而对于字符数组的初始化

    char str[14]="I love China";

    不能等价于:

    char str[14];

    str="I love China"; (这种不是初始化,而是赋值,而对数组这样赋值是不对的)

    4.4、如果定义了一个字符数组,那么它有确定的内存地址,不能进行多次赋值;而定义一个字符指针变量时,它并未指向某个确定的字符数据,并且可以多次赋值。

    5、字符串处理函数

    5.1 字符串连接

    char *strcat(char *str1,const char *2 );

    char *strcat(char *strDestination,const char *strSource );

    功能:函数将字符串str2 连接到str1的末端,并返回指针str1

    注:连接前两个字符串的后面都有一个' \0 ',连接时将字符串1后面的' \0 ‘去掉,只在新串最后保留一个' \0 ‘

    5.2 字符串复制

    char *strcpy(char *str1,const char *2 );

    char *strcpy(char *strDestination,const char *strSource );

    功能:复制字符串strSource 中的字符到字符串strDestination,包括空值结束符。返回值为指针strDestination。

    注:

    1、“字符数组1”必须写成数组名形式,“字符串2"可以是字符数组名,也可以是一个字符串常量

    2、复制时连同字符串后面的' \0 ' 一起复制到数组1中

    3、不能用赋值语句直接将一个字符串常量或者字符数组直接赋给一个字符数组(同普通变量数组是一样的),而只能用strcpy 函数处理。

    4、可以用strcpy 函数将字符串2中的前若干个字符复制到字符数组1中去。

    展开全文
  • 很清楚展现了数组的定义, 初始化, 输入和输出 ,字符数组的应用,以及多维数组应用。
  • (C++)字符数组初始化的两种方法

    千次阅读 2021-03-19 19:32:10
    #include<cstdio> //字符数组的两种赋值方法 int main(){ //1.... char str1[14] = {'I',' ','l','o','v','e',' ','m','y',' ','m','o','...方法二,直接赋值字符串(注意,只有初始化时可以这么做) char str2
    #include<cstdio>
    //字符数组的两种赋值方法 
    
    int main(){
    	
    	//1.方法一
    	char str1[14] = {'I',' ','l','o','v','e',' ','m','y',' ','m','o','m','.'};
    	
    	for(int i = 0;i<=13;i++){
    		printf("%c",str1[i]);
    	}
    	printf("\n");
    	//2.方法二,直接赋值字符串(注意,只有初始化时可以这么做) 
    	char str2[15] = "I love my mom.";
    	for(int j = 0;j<=13;j++){
    		printf("%c",str2[j]);
    	}
    	return 0;
    } 
    

    在这里插入图片描述

    展开全文
  • 1.字符数组初始化里面元素值为多少 (1) 字符数组定义在main函数外面

    1.字符数组未初始化里面元素值为多少
    (1)字符数组定义在main函数外面,s[i]的值为’\0’即为NULL(i=0,1,2,3…), (int)s[i]的值为0。

    #include<iostream>
    using namespace std;
    char s[5];
    int main()
    {
     	for(int i=0; i<5; ++i)
     	{
      		if(s[i]=='\0')//s[i]==0,s[i]==NULL都行 
       			cout << "I'm coming home,Ace!" << endl;
     	}
     	return 0;
    }

    在这里插入图片描述

    #include<iostream>
    using namespace std;
    char s[5];
    int main()
    {
     	for(int i=0; i<5; ++i)
     	{
      		cout << (int)s[i];
     	}
     	return 0;
    }

    在这里插入图片描述
    (2)字符数组定义在main函数里面,输出结果表现为乱码,(int)s[i]的值为随机数。

    #include<iostream>
    using namespace std;
    int main()
    {
     	char s[5];
     	for(int i=0; i<5; ++i)
      		cout << s[i];
     	cout << "End!" << endl;
     	for(int i=0; i<5; ++i)
      		cout << (int)s[i] << ' ';
     	return 0;
    }

    在这里插入图片描述
    2.字符数组在部分初始化后,后面的元素自动赋值为’\0’

    #include<iostream>
    using namespace std;
    int main ()
    {
     	char s[10]="abcde";
            //char s[10]={"abcde"};
            //char s[10]={'a','b','c','d','e'};//三种初始化方式都一样 
        	for(int i=0; i<10; i++)
        	{
            	if(s[i]=='\0')
                		cout << '0';
      		else
                		cout << s[i];
        	}
      	return 0;
    }
    //输出结果为:abcde00000

    注意:

    #include<iostream>
    using namespace std;
    int main() 
    {
        	char s[10];
        	s[0]='a';    //这种类型不属于初始化,而是赋值 
        	s[1]='b';    //等价于未初始化的数组,只是将其前五个数进行了赋值 
        	s[2]='c';    //其余元素仍为乱码 
        	s[3]='d';    //输出(int)s[i]为随机数(前五个数为 abcde 的 ASCII 码)
        	s[4]='e';
        	for(int i=0; i<10; i++)
        	{
         		cout << s[i];
        	}
        	cout << endl;
        	for(int i=0; i<10; i++)
        	{
         		cout << (int)s[i] << ' ';
        	}
        	return 0;
    }
    /*
    输出结果:
        第一行为乱码 
        第二行前五个数为 abcde 的 ASCII码,其余数为随机数 
    */

    在这里插入图片描述
    3.字符数组初始的值全部置为’\0’的办法(即以%c读取为NULL即空,以%d读取为0)
    (1)内存操作库函数memset
    头文件cstring中声明:
    void * memset(void * dest,int ch,int n);
    将从dest开始的n个字节,都设置成ch。返回值是dest。ch只有最低的字节起作用。
    例:将szName的前10个字符,都设置成’a’:
    char szName[200] = “”;
    memset( szName,‘a’,10);
    cout << szName << endl;
    =>aaaaaaaaaa

    #include<iostream>
    #include<cstring>
    using namespace std;
    int main() 
    {	
    	char s[10];
        	memset(s,'\0',10);
        	for(int i=0; i<10; ++i)
        	{
         		if(s[i]=='\0')
          			cout << (int)s[i]; 
        	}
        	return 0;
    }
    //输出为 0000000000

    (2)char s[10]={0},从一开始就全部赋值为0

    #include<iostream>
    using namespace std;
    int main() 
    {
        	char s[10]={0};
        	for(int i=0; i<10; ++i)
        	{
         		if(s[i]=='\0')
          			cout << (int)s[i]; 
        	}
        	return 0;
    }
    //输出为 0000000000 

    这样只要对字符数组进行连续赋值,便很容易通过下列代码遍历输出整个字符数组,而不用管字符数组的长度为多少:

    #include<iostream>
    using namespace std;
    int main() 
    {
        	char s[20]="Cayde 6";
       	int i=0;
        	while(s[i]!='\0')
        	{
         		cout << s[i++];
        	}
        	return 0;
    }
    //输出 Cayde 6 

    参考:https://blog.csdn.net/weixin_38481963/article/details/79477903
    感谢观看!
    在这里插入图片描述

    展开全文
  • 定义时进行初始化: char ch[20]="cpp"; //ok cout << ch << endl; 仅定义不初始化 char ch[20]; ch = "cpp";//出现”表达式必须是可修改的左值“的错误提醒,编译报错“不可指定数据类型”。 ...
  • 字符串数组初始化为空串

    千次阅读 2019-10-28 10:46:36
    (1) char str[10]=""; (2) char str[10]={'\0'}; (3) char str[10]; str[0]='\0';
  • C++字符串数组

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

    千次阅读 2019-03-02 11:14:59
    char str[1024] = {0}; 头文件为#include
  • C++C++数组初始化方法

    万次阅读 多人点赞 2018-12-17 22:13:55
    定义: int *pia = new int[10];...此 new 表达式分配了一个含有 10 个 int 型元素的数组,并返回指向该数组第一个元素的指针,此返回值初始化了指针 pia。 在自由存储区中创建的数组对...
  • 一、字符数组的定义和初始化 字符数组初始化,最容易理解的方式就是逐个字符赋给数组中各元素。 charstr[10]={'I','','a','m','',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果花...
  • C字符串数组初始化相关问题总结 在C语言编程中,当我们声明一个字符串数组的时候,常常需要把它初始化为空串。总结起来有以下三种方式: (1) char str[10]="";(2) char str[10]={'\0'};(3) char str[10]; ...
  • #我看到的一个题目是 循环得到一个字符串,但字符串会有重复,需要去重后才能使用。利用sstream可以做到数组去重。 代码如下: #include <iostream> #include <string> #include <string.h> #...
  • 1、字符数组初始化之前,里面的值是什么? (1)字符数组定义在main函数外面,a[i]的值为’\0’(i=1,2,3…),(int)a[i]的值为0。 int a[5] ,则: a[0] a[1] a[2] a[3] a[4] \0 \0 \0 \0 \0 ...
  • C++字符数组 定义和初始化 赋值和引用
  • 字符数组初始化

    2021-08-27 13:19:38
    编程良好习惯:定义char型数组时赋初值为'\0' 原因:当数组定义不赋值时,不同编译器为这个... 当采用这种方式初始化时,要注意等号后面的字符串长度要小于(等于也不行)字符数组元素个数。 比如array[20]代表数...
  • C++数组初始化方法

    千次阅读 2022-04-25 20:45:12
    定义: int *pia = new int[10]; // array of 10 uninitialized ints 此new表达式分配了一个含有 10 个int型元素的数组,并返回...动态数组初始化: 1. 元素只能初始化为元素类型的默认值,而不能像数组变量一...
  • C++:char数组初始化

    万次阅读 2019-04-04 11:14:00
    char s[10] = "Hello"; // 剩余全用0填充 char s[10] = {'H','e','l','l','o','\0'}; //和上面效果一样 char s[10] = {'H','e'...char s[10] = {0} // 全部初始化为0 char s[10] = "Hello, world.\n"; // 超出部分丢...
  • c+字符串数组_了解C ++字符串数组

    千次阅读 2020-07-19 04:44:52
    c+字符串数组Hey, Folks! So, as programmers, we often deal with Arrays of all data types. We’ll cover C++ string array in today’s article. 嘿伙计! 因此,作为程序员,我们经常处理所有数据类型的数组。 ...
  • 主要介绍了C++字符串以及数组和指针的互相使用讲解,是C++入门学习中的基础知识,需要的朋友可以参考下
  • strlen()很笨,它会在遇到\0之前一直找下去,所以在cstr2中没有\0的时候,它会一直找下去,而那些地方还没有被初始化过,所以就是乱的而且strlen计算出的字符串数组长度是不包含\0的那部分,所以cstr1的长度不是3...
  • C++ 字符串与字符数组 详解

    万次阅读 多人点赞 2018-03-03 19:28:22
    C++中,有两种类型的字符串表示形式: C-风格字符串 C++引入的string类 C-风格字符串 ...C 风格的字符串起源于 C 语言...下面的声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符,所以...
  • C 语言字符数组的定义与初始化

    千次阅读 2020-12-18 18:00:02
    1、字符数组的定义与初始化字符数组初始化,最容易理解的方式就是逐个字符赋给数组中各元素。char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'};即把10个字符分别赋给str[0]到str[9]10个元素如果花括号...
  • C++ 字符数组初始化

    千次阅读 2013-06-13 16:46:01
    (1) 逐个字符输入输出,不会在后面自动加\0结束符,需要记录数组长度,对应初始化的例子: const int N=8; char ch[N]={'a','b','c','d','e','f','g','k'}; 此时不会在其后加\0,输出需要单个字符输出,否则找不...
  • 比如我们常用的数组,其初始化/删除就有非常多的方式,而且这些方式也比较混乱,没有特别的规律,很容易把人给直接绕晕圈了。下面我们来针对数组初始化/删除方式做一个总结,如果有不对或者不全的地方,大家可以...
  • c/c++ 计算字符数组/字符串长度

    千次阅读 2020-04-21 12:47:37
    //假设str为待求的字符串数组名 使用sizeof()操作符 sizeof(str)/sizeof(str[0]); //假设str为待求的字符串数组名 使用length()函数 char a[10] std::cin>>a; length=a.length() 注意: strlen()函数求出的字符串...
  • C++字符串和字符数组

    千次阅读 2019-06-19 11:45:46
    C++中,有两种类型的字符串表示形式: ...下面的声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符,所以字符数组的大小比单词 “Hello” 的字符数多一个。 char greeting[6] = ...
  • C语言中字符数组初始化的几种方法

    万次阅读 多人点赞 2019-04-14 16:39:30
    1.C语言中的字符数组初始化 在C语言中,字符串是当做字符数组来处理的;所以字符串有两种声明方式,一种是字符数组,一种是字符指针。 1.1 直接逐个初始化字符数组:字符数组的初始化,最容易理解的方式就是逐个...
  • C++字符数组字符串

    2019-12-30 19:48:11
    C++字符数组字符串 ** THE FIRET PART 一声明和初始化**: 字符数组的两种方式: 1.`char a[]={‘p’,‘r’,‘e’,‘t’,‘t’,‘y’};//声明字符数组初始化 2.char a[]=’‘pretty’’;//同上 字符串: ...
  • 3:字符串初始化可以对其第一个字节赋值0。  使用strcpy拷贝的字符串不需要进行初始化。  使用strncpy拷贝的字符串,建议不要先进行memset全部清零,而是在strncpy后,根据字符串实际长度,对字符串...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,171
精华内容 58,468
关键字:

c++字符串数组初始化

c++ 订阅