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

在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++中不允许。
　　例如，下面的代码对数组进行初始化是错误的：
　　

1        int arrayl[5]={1，2，3，4，5，6}; //error-初始化值个数多于数组元素个数
2 　　　　int array2[5]={1，，2，3，4}； //error：初始化值不能省略
3 　　　　int array3[5]={1，2，3，}; //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：没有确定数组大小
　　在定义数组的场合，无论如何，编译器必须知道数组的大小。