精华内容
下载资源
问答
  • C语言中字符数组初始化的几种方法

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

    欢迎关注我的微信公众号:CurryCoder的程序人生

    在这里插入图片描述

    1.C语言中的字符数组初始化

    • 在C语言中,字符串是当做字符数组来处理的;所以字符串有两种声明方式,一种是字符数组,一种是字符指针。
    • 1.1 直接逐个初始化字符数组:字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。
          char strr[] = {'I',' ','a','m',' ','h','a','p','p','y'};
      
    • 注意:如果花括号中提供的字符个数大于数组长度,则按语法错误处理;若小于数组长度,则只将这些字符数组中前面那些元素,其余的元素自动定为空字符(即’\0’)
    • 1.2 用字符串常量来初始化字符数组:在c语言中,将字符串作为字符数组来处理。因此可以使用字符串来初始化字符数组
          char str[] = {"I am happy"};
          // 也可以去掉{}
          char str[] = "I am happy";
      
    • 注意:上述这种字符数组的整体赋值只能在字符数组初始化时使用,不能用于字符数组的赋值,字符数组的赋值只能对其元素一一赋值,下面的赋值方法是错误的。
          char str[];
          str = "I am happy";  //错误,字符数组的赋值只能按元素一一赋值(错误的原因: C语言并没有提供可以直接操作字符串的运算符;“=”可以用于其他数据类型的赋值,但是不可以直接给字符串赋值
      
    • 这是字符数组初始化的两种方式,但是这两种方式其实是不等价的;它们的数组长度不同.
          #include "iostream"
          #include "cstring"
      
      
          using namespace std;
      
      
      
          int main(){
              /*字符数组初始化*/
              // 第一种初始化的方法
              char str[10] = {'I',' ','a','m',' ','h','a','p','p','y'};  // 少了\0,输出会出现问题
              cout << "str=" << str << ",sizeof(str)=" << sizeof(str) << endl;
              // 第二种初始化的方法
              char str1[] = "I am happy";  // 等价于char str1[] = {"I am happy"};
              char str2[] = "python";
              // char str2[] = {'p', 'y', 't','h','o','n'}与char str2[] = "python"不等价
              // char str2[] = {'p', 'y', 't','h','o','n', '\0'}与char str2="python"等价
              char str3[] = {'p', 'y', 't','h','o','n'};
              char str4[] = {'p', 'y', 't','h','o','n', '\0'};
              
              int num_str2 = sizeof(str2);
              int num_str3 = sizeof(str3);
              int num_str4 = sizeof(str4);
              
              cout << "str2与str3不等价\n";
              cout << "str2 = " << str2 << ",sizeof(str2) = " << num_str2 << endl;
              cout << "str3 = " << str3 << ",sizeof(str3) = " << num_str3 << endl;
              cout << "str2与str4等价\n";
              cout << "str2 = " << str2 << ",sizeof(str2) = " << num_str2 << endl;
              cout << "str4 = " << str4 << ",sizeof(str4) = " << num_str4 << endl;
              return 0;
          }
      
    • 1.3 字符指针:在C语言中我们也可以使用字符指针来存储字符串
    • 字符指针初始化:
          char *str = "python";
      
    • C语言对字符串常量是按照字符数组来处理的,在内存中开辟了一个字符数组用来存放字符串常量,程序在定义字符串指针变量str时,只是把字符串首地址赋值给str。 输出:
          cout << str << endl;
      
    • 系统首先输出str指向的字符,而后自加1,直至遇到’\0’;与数组的输出方式相同。字符指针的赋值:
          char *str;
          str = "python";  // 对于字符指针这种赋值方式是正确的,与字符数组不同
      

    2.总结

    • 在C语言中并没有直接提供字符串的操作,其字符串操作是通过转化为字符串完成的,例如字符数组,字符指针,其本质是对字符的操作。
    • 作为字符数组,与普通数组相同,区别在于它的每一个元素是一个字符,所以不可以直接用“=”对字符数组赋值(parr[]=”python”,是错误的赋值方式),但是可以对每一个元素进行赋值(charr[12]=’\0’是正确的)。
    • 字符串一定是以’\0’结尾的;字符数组和字符指针我们当做字符串整体初始化,系统会自动添加’\0’;对于字符数组,如果采用单个字符的方式进行初始化或者赋值一定要考虑结束符’\0’.

    3.参考博客

    展开全文
  • 字符数组初始化

    千次阅读 2015-03-25 15:53:12
    字符数组的初始化 字符数组的初始化与数值型数组初始化没有本质区别。...用逐个初始化的方法与数值型数组初始化本质上是一样的,同样也可以进行完全赋初值及不完全赋初值,但是不完全赋值时没有赋值的元素被赋

    字符数组的初始化

    字符数组的初始化与数值型数组初始化没有本质区别。但它除了可以逐个给数组元素赋予字符外,也可以直接用字符串对其初始化。
    (1)用字符常量逐个初始化数组。例如:
    char a[8]={'i','l','o','v','e','y','o','u'};
    用逐个初始化的方法与数值型数组初始化本质上是一样的,同样也可以进行完全赋初值及不完全赋初值,但是不完全赋值时没有赋值的元素被赋为空格。
    当对全体元素赋初值时也可以省去长度说明。例如:
    char c[ ]={‘c’,‘ ’,‘p’,‘r’,‘o','g','r','a','m'};
    这时C数组的长度自动定为9。
    (2)字符串常量初始化数组。例如:
    char c[ ]={‘c’,‘ ’,‘p’,‘r’,‘o','g','r','a','m'};
    可写为:
    char c[ ]={"C program"};
    或去掉{}写为:
    char c[ ]="C program";

    字符数组的输入输出

    字符数组的输入
    (1)用getchar()或scanf()的'%c'格式符对数组进行字符赋值。例如,对于数组a[10]:用getchar()赋值:
    for(i=0;i<10;i++)
    a[i]=getchar();
    用scanf()赋值:
    for(i=0;i<10;i++)
    scanf("%c",&a[i]);
    (2)用scanf()的'%s'格式对数组赋值。还是对于数组a[10]:
    scanf("%s",a);

    scanf("%s“,&a[0]);
    输入”C program“并回车时,a数组会自动包含一个以”\0“结尾的字符串”C program“。

    字符数组的输出
    (1)    用putchar()或printf()的‘%c’格式符对数组进行字符赋值。例如,对于数组a[10]:用putchar()赋值:
    for(i=0;i<10;i++)
    a[i]=putchar();
    用printf()赋值:
    for(i=0;i<10;i++)
    printf("%c",a[i]);
    输出结果为:
    c program


    程序
    <span style="font-size:18px;">#include"stdio.h"
    int main()
    {
    	char a[]="China";//用双引号""这种方式定义数组,实际数组元素个数总比双引号里的字符多一个,因为数组会查找'\0'这个结束的标志
    	char b[5]="China";
    	char c[5]={'C','h','i','n','a'};
    	char d[]={'C','h','i','n','a'};
    	printf("a[]:%d\nb[5]:%d\nc[5]:%d\nd[]:%d\n",sizeof(a),sizeof(b),sizeof(c),sizeof(d));
    	printf("a[]:%s\nb[5]:%s\nc[5]:%s\nd[]:%s\n",a,b,c,d);
            return 0;
    }</span>

    运行结果会是什么呢?


    结果分析:
    数组a和b的值很容易想清楚
    数组c和d为什么会越界输出呢?
    因为在c中,以单引号‘’这种方式初始化数组,不可以用printf("%s",数组名);这种方式输出,
    但是用双引号“”这种方式就可以用%s加数组名的方式输出

    展开全文
  • 字符数组初始化相关问题总结

    千次阅读 2017-12-05 20:58:25
    C字符数组初始化相关问题总结 在C语言编程中,当我们声明一个字符串数组的时候,常常需要把它初始化为空串。总结起来有以下三种方式: (1) char str[10]="";(2) char str[10]={'\0'};(3) char str[10]; ...

    C字符串数组初始化相关问题总结


    在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]={11235813213455); //初始化
    2 void main()
    3  {
    4     //...
    5  }

     


      初始化数组的值的个数不能多于数组元素个数,初始化数组的值也不能通过跳过逗号的方式来省略,这在C中是允许的,但在C++中不允许。
      例如,下面的代码对数组进行初始化是错误的:
      

    复制代码
    1        int arrayl[5]={123456}; //error-初始化值个数多于数组元素个数
    2     int array2[5]={1,,234}; //error:初始化值不能省略
    3     int array3[5]={123,}; //error:初始化值不能省略
    4     int array4[5]={}; //error:语法格式错误
    5     void main()
    6     {
    7       //...
    8     }
    复制代码

     


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

    复制代码
     1 //*********************
     2 //**   ch7_2.cpp  **
     3 //*********************
     4     #include <iostream.h>
     5 
     6     int array1[5]={1,2,3};
     7     static int array2[5]={1};
     8 
     9     void main()
    10     {
    11      int arr1[5]={2};
    12      static int arr2[5]={1,2};
    13 
    14      int n;
    15      cout <<"global:\n";
    16      for(n=0; n<5; n++)
    17        cout <<" " <<array1[n];
    18 
    19      cout <<"\nglobal static:\n";
    20      for(n=0; n<5; n++)
    21        cout <<" " <<array2[n];
    22 
    23      cout <<"\nlocal:\n";
    24      for(n=0; n<5; n++)
    25        cout <<" " <<arr1[n];
    26 
    27      cout <<"\nlocal static:\n";
    28      for(n=0; n<5; n++)
    29         cout <<" " <<arr2[n];
    30      cout <<endl;
    31     }
    复制代码

      运行结果为:
        global:
         l  2  3  0  0
        global static:

         1  0  0  0  0
        local:
         2 23567 23567 23567 23567
        local static:
         1  2  0  0  0
      例中,全局数组和全局静态数组的初始化是在主函数运行之前完成的,而局部数组和局部静态数组的初始化是在进入主函数后完成的。
      全局数组arrayl[5]对于初始化表的值按序初始化为1,2,3,还有两个元素的值则按默认初始化为0。
      全局静态数组array2[5]与全局数组的初始化情况一样,初始化表值(1)表示第1个元素的值,而不是指全部数组元素都为1。
      局部数组arrl[5]根据初始化表值的内容按序初始化, 由于初始化表值只有1个,所以还有4个元素的值为不确定。在这里均为数值23567。
      局部静态数组arr2[5]先根据初始化表按序初始化,其余3个数组元素的值默认初始化为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操作解决了该问题。 例如,下面的代码用sizeof确定数组的大小:

    复制代码
     1     //*********************
     2     //** ch7_3.cpp **
     3     //*********************
     4 
     5     #include <iostream.h>
     6 
     7     void main()
     8     {
     9      static int a[]={1,2,4,8,16};
    10      for(int i=0; i<(sizeof(a)/sizeof(int)); i++)
    11       cout <<a[i] <<" ";
    12      cout <<endl;
    13     }
    复制代码

     

      运行结果为:
        1 2 4 8 16
      sizeof操作使for循环自动调整次数。如果要从初始化a数组的集合中增删元素,只需重新编译即可,其他内容无须更动。
      每个数组所占的存储量都可以用sizeof操作来确定! sizeof返回指定项的字节数。sizeof常用于数组,使代码可在16位机器和32位机器之间移植:
      对于字符串的初始化,要注意数组实际分配的空间大小是字符串中字符个数加上末尾的,'\0',结束符。
      例如,下面的代码定义一个字符数组:

        

    复制代码
     1 //*********************
     2 //**   ch7_4.cpp  **
     3 //*********************
     4 
     5     #include <iostream.h>
     6 
     7     void main()
     8     {
     9      char ch[]="how are you";
    10 
    11      cout <<"size of array: " <<sizeof(ch) <<endl;
    12      cout <<"size of string: " <<strlen("how are you")  <<endl;
    13     }
    复制代码

     

      运行结果为:
        size of array:12
        size of string:ll
     例中,数组大小为12,而字符串长度为11。
      省略数组大小只能在有初始化的数组定义中。
      例如,下面的代码将产生一个编译错误:
        int a[];//error:没有确定数组大小
      在定义数组的场合,无论如何,编译器必须知道数组的大小。

    展开全文
  • 字符数组初始化

    千次阅读 2009-07-21 20:19:00
    初始化字符数组时,编译器自动将字符串最后一个字符后面加上/0,以表示字符串的结束。如果数组的大小大于字符串的长度+1,那么把字符串结束后面的元素也都初始化为/0; 看这段程序:定义一个大小为12的字符数组...

    (1)char arr[10]="HI";
    初始化字符串数组时,编译器自动将字符串最后一个字符后面加上'/0',以表示字符串的结束。
    如果数组的大小大于字符串的长度+1,那么把字符串结束后面的元素也都初始化为'/0';
    看这段程序:
    定义一个大小为12的字符串数组
    char str1[12]="jiajia";        
    让一个char型的指针指向这个数组
        char *p1=str1;
    输出这个字符串
        printf("%s/n/n",str1);
    利用指针输出这个字符串数组中每个元素的字符、字符ascii值、字符存储地址
        for(int i=0;i<12;i++)
        {
            printf("%c:%d:%p/n",*p1,*p1,p1);
            p1++;
        }
    可以看出,数组元素的后几位都被初始化成了'/0';使用printf打印字符串数组时,程序遇到第一个'/0'就结束对字符串的读取。

    如果数组的大小小于字符串的长度+1,程序在运行时可能要出现问题,所以应当确保数组的大小要大于字符串长度的大小+1;

    这段程序的字符串长度+1小于数组的大小:
    char str2[12]="hello jiajia";
        char *p2=str2;

        printf("/n/n/n%s/n/n",str2);
       
        for(int i=0;i<28;i++)
        {
            printf("%c:%d:%p/n",*p2,*p2,p2);
            p2++;
        }

    使用printf打印字符串,程序需要找到'/0'才能结束读取,结果找遍整个数组没有找到,只有继续顺着地址寻找,一直找到某个地址上的assii是0的,字符串才读取完毕。所以本段程序在读取完"hello jiajia"之后,后面可能还会有几个随机的字符,就是因为字符串终止于'/0'。

    (2)char arr[]="Hello World!";
    这种初始化方法不用担心数组大小过小的情况,数组的大小由编译器决定。
    (3)char arr[]={'H','e','e','l','o',' ','W','o','r','l','d','/0'};
    同第二种方法结果相同,但显然要麻烦许多。另外,' '代表空格,ascii值是32,'/0'代表字符串结束,ascii值是0;
    (4)char *p="Hello World";
    使用数组的方式初始化。同数组不同之处在于,p是一个变量,可以做递增、递减运算,而arr是数组的首地址,是一个地址常量,不能做递增、递减运算。

    char *name="liujiajia";
        name[0]='L';
        printf("/n%s/n",name);
    name[0]='L';这句代码在最新的c99标准中会引发程序异常。需要注意。


    char *string="c programe";
        char *string2;    
        string2=string;    //将指针string的值赋给string2
        
        printf("/nstring=%s,&string=%p,string=%p/n",string,&string,string);
        printf("/nstring=%s,&string=%p,string=%p/n",string2,&string2,string2);

    上面这段程序最后显示,指针string所指向的地址和指针string2所指向的地址相同,这就说明它们指向的是内存里面同一个字符串,也就是说字符串本身并没有复制,而是产生了一个指向同一个字符串的指针。这样程序的效率会更加的高。如果需要复制字符串可以使用 strcpy() 或 strncpy()。

     

     

    原文:http://www.cnblogs.com/inspurhaitian/archive/2008/09/05/1285207.html

    展开全文
  • 字符数组初始化问题

    2018-01-08 13:29:24
    在C语言编程中,当我们声明一个字符数组的时候,常常需要把它初始化为空串。总结起来有以下三种方式: (1) char a[10]=""; (2) char a[10]={'\0'}; (3) char a[10]; str[0]='\0'; 第1,2种方式是将a数组的所有...
  • 利用字符数组对字符串进行初始化

    千次阅读 2019-09-24 21:21:04
    static void Main(string[] args) { string str = "中国70周年国庆"; Console.WriteLine(str); //利用字符数组对字符串进行初始化 char[] charArray = { 'c', 'h', 'i', 'n','a'...
  • //字符数组的两种赋值方法 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...
  • //字符数组初始化 char c1[3] = {'A','a','c'}; printf(&quot;%d\n&quot;, sizeof(c1)); //3 char c2[10] = { 'A', 'a', 'c'}; printf(&quot;%d\n&quot;, sizeof(c2)); //10 char c3[] = { 'A'...
  • 首先为什么要初始化数组:假如创建... 最为简单的初始化方法就是char a[10] = {0};就可以将所有位置初始化为‘\0’。 当然可能会有一些情况导致这种方法不能初始化,或者字符数组是动态创建的,没有一个可以进行{0}的.
  • C++ 字符数组初始化

    2013-06-13 16:46:01
    字符数组的输入输出可以有两种方法: (1) 逐个字符输入输出,不会在后面自动加\0结束符,需要记录数组长度,对应初始化的例子: const int N=8; char ch[N]={'a','b','c','d','e','f','g','k'}; 此时不会在其后...
  • C++数组初始化方法

    2018-08-06 11:36:18
    定义: int *pia = new int[10]; // array of 10 uninitialized ints 此 new 表达式分配了一个含有 10 个 int 型元素的数组,并返
  • 有几种错误的初始化方法要注意:char str[3] = {"abc", " ", " "}; error : excess elements in char array initializer char str[3] = "abc"; char str[3] = {"abc"}; 这两种不会提示错误,但输出时会乱码。 ...
  • 下表比较了两种不同的方式来初始化字符数组:for循环和memeset()。随着初始化数据量的增加,memset()很清晰的做的更快: 耗时for循环memset10000.0160.017100000.0550.0131000000.4430.02910000004.3370.291 ...
  • 初始化数组字符串储存在静态存储区。但是,程序在开始运行时才会为该数组分配内存(以上面的声明为例,数组形式ar[ ]在计算机的内存中分配为一个内含6个元素的数组(每一个元素对应一个字符,还加上一个末尾的空...
  • 1.字符数组初始化 在C语言中,字符串是当做字符数组来处理的;所以字符串有两种声明方式,一种是字符数组,一种是字符指针。 (1)直接逐个初始化字符数组:字符数组的初始化,最容易理解的方式就是逐个字符赋给...
  • 字符数组初始化及字符串的使用

    千次阅读 2020-10-15 18:55:45
    文章目录字符数组的定义字符数组初始化字符串存放'\0'的作用 字符数组的定义 同整型数组一样: char c[10]; char ch[3][4]; 字符数组初始化 定义数组时初始化,如: char c[10]={'a','b','c','d'}; 如果输出格式为...
  • #include #include int main() { char ar0[] = {'n','a','m','e','i','s','l'};... //初始化字符数组方式2.这里是一个初始化列表,不是字符串常量,以后可以修改其值 char *ar2 = "NAMEISL"; //字符串常量.A
  • 二维vector数组初始化方法

    千次阅读 2020-04-14 21:42:11
    在用devcpp编译程序时发现,二维vector数组如果只定义的话,不指定元素个数也不进行初始化的时候会导致编译出错...二维数组初始化方法目前有以下两种: 第一种初始化方法(以元素类型为int为例) 初始化为1: `vect...
  • 关于字符数组初始化

    千次阅读 2014-07-01 18:28:36
    有两种初始化方法. 方法1:逐个字符赋给数组中各元素.这种方法最容易理解.例如: char c[5]={ 'H','a','p','p','y' }; 把5个字符分别赋给c[0]至c[4].以下是几点说明: (1) 如果大括号内提供的初值个数(即...
  • C语言字符数组初始化

    万次阅读 多人点赞 2012-08-01 09:07:56
    1、字符数组的定义与初始化 字符数组初始化,最容易理解的方式就是逐个字符赋给数组中各元素。char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果...
  • 1.首先定义结构体数组: typedef struct BleAndTspRmtCmd{ char terminal[3]; char note[3]; char rmtCmd[10]; char cmdPropt[24];}; BleAndTspRmtCmd为结构体名,可以通过这个结构体名定义其他结构体变量,...
  • 初始化字符数组方法总结

    千次阅读 2019-07-14 17:14:17
    字符数组建成字符串,由于字符串的应用及其广泛,而且在C语言中目前只有char这一变量类型既可以输出数字又可以输出字符,所以字符数组的变量类型也就只有char了。 方法一:大括号型 特点:1.大括号内从左至右的元素...
  • 字符数组初始化和'/0'

    千次阅读 2010-06-26 08:43:00
    有两种初始化方法. 方法1:逐个字符赋给数组中各元素.这种方法最容易理解.例如: char c[5]={ 'H','a','p','p','y' }; 把5个字符分别赋给c[0]至c[4].以下是几点说明: (1)如果大括号内提供的初值个...
  • 【C++】C++数组初始化方法

    万次阅读 2018-12-17 22:13:55
    定义: int *pia = new int[10];...此 new 表达式分配了一个含有 10 个 int 型元素的数组,并返回指向该数组第一个元素的指针,此返回值初始化了指针 pia。 在自由存储区中创建的数组对...
  • 字符数组在定义的时候最好要初始化。  2 字符数组初始化时,可以用2种形式。 第一种字符数组初始化 [cpp] view plaincopy char a1[4]="abc";  第二种字符数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 403,693
精华内容 161,477
关键字:

对字符类数组初始化正确的方法是