1. 数组大小

我相信，在C#/Java中，更多的人愿意用List<T>来取代数组，一方面是List提供了较多的方法，另一方面也无需我们去指定数组的大小。

那么在C语言中，我们既然需要必须指定数组的大小，而一般来讲，很多数组大小事我们无法确定并且经常会发生变化的，那么我们最好的方式就是用宏定义来限定数组的大小。


       
  1. #define SIZE 10  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE];  
  6. } 
 
       
 
 
       
如果包含多个数组的话，用宏就很难记忆，那么我们就可以利用sizeof运算符。
 
       

       
  1. int main (void)  
  2. {  
  3.     int a[]={1,3,4,55,6,7,89,9,0};  
  4.     int i ;  
  5.     printf("%d",(int)sizeof(a)/(int)sizeof(a[0]));  
  6.     for(i=0;i<(int)sizeof(a)/(int)sizeof(a[0]);i++)  
  7.     {  
  8.         a[i]=0;  
  9.     }  
  10.     for(i=0;i<(int)sizeof(a)/(int)sizeof(a[0]);i++)  
  11.     {  
  12.         printf("%d\n",a[i]);  
  13.     }  
  14. } 
 
       
注意，我们之前说过，sizeof返回的值是size_t，因此，我们在计算时，最好将其先强制类型转换为我们可以控制的类型。
 
       
 
 
       
2. 数组初始化
 
       
一般情况下，我们初始化数组都是把整数数组初始化为0，那么我们一般会怎么做呢？
 
       

       
  1. #define SIZE 5  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE]={0,0,0,0,0};  
  6. } 
 
       
 
 
       
那么如过SIZE=100怎么办，那么很多人都会这样去做。
 
       

       
  1. #define SIZE 100  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE];  
  6.     int i ;  
  7.     for(i=0;i<SIZE;i++)  
  8.     {  
  9.         a[i]=0;  
  10.     }  
  11. } 
 
       
 
 
       
其实我们完全不用麻烦，这么一句代码就可以搞定了。
 
       

       
  1. #define SIZE 100  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE]={0};  
  6. } 
 
       
 
 
       
在C99中，提供了一种初始化式，使得我们可以这样来写。
 
       

       
  1. #define SIZE 100  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE]={[5]=100,[50]=49};  
  6. } 
 
       
 
 
       
而其他的数字就都默认为0。那么我们来考虑这样一段代码：
 
       

       
  1. #define SIZE 10  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE]={1,2,3,4,5,[0]=6,7,8};  
  6. } 
 
       
那么在C99中，这段代码的结果究竟是什么呢？这个就需要我们来了解一下数组初始化式的原理。
 
       
其实，编译器在初始化式数组列表时，都会记录下一个待初始化的元素的位置，比如说在初始化index=0的元素时，会记录下1，这样以此类推，但是当初始化index=5的时候，首先根据他的初始化式记录下一个待初始化的元素时index=1，然后初始化index=0的元素为6。那么也就是说：最后的结果应该是{6,7,8,4,5,0,0,0,0,0}。
 
       
3. 常量数组
 
       
当数组加上const就变成了常量数组，常量数组主要有两个好处。
 
       
1. 告诉使用者，这个数组是不应该被改变的。
 
       
2. 有助于编译器发现错误。
 
       
4. C99的变长数组
 
       
这是个很爽的东西，我们再也不必担心为数组指定大小而发愁了，指定大了会造成空间的浪费，指定小了又不够用。
 
       
在C99中，他的长度会由程序执行时进行计算。
 
       
方式如下：
 
       

       
  1. int main (void)  
  2. {  
  3.     int size;  
  4.     int a[size];  
  5.     scanf("%d",&size);  
  6. } 
 
       
 
 
       
5. 数组的复制
 
       
很多时候，我们需要把一个数组的元素复制到另一个数组上，我们大多数人第一个想到的就是循环复制。
 
       

       
  1. #define SIZE 10  
  2.  
  3. int main (void)  
  4. {  
  5.     int a[SIZE];  
  6.     int b[SIZE];  
  7.     int i ;  
  8.     for(i=0;i<SIZE;i++)  
  9.     {  
  10.         a[i]=i;  
  11.     }  
  12.     for(i=0;i<SIZE;i++)  
  13.     {  
  14.         b[i]=a[i];  
  15.     }  
  16.     for(i=0;i<SIZE;i++)  
  17.     {  
  18.         printf("%d",b[i]);  
  19.     }  
  20. } 
 
       
 
 
       
其实还有一种更好的方法是使用memcpy方法，这是一个底层函数，它把内存的字节从一个地方复制到另一个地方，效率更高。
 
       

       
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <string.h>  
  4.  
  5. #define SIZE 10  
  6.  
  7. int main (void)  
  8. {  
  9.     int a[SIZE];  
  10.     int b[SIZE];  
  11.     int i ;  
  12.     for(i=0;i<SIZE;i++)  
  13.     {  
  14.         a[i]=i;  
  15.     }  
  16.     memcpy(b,a,sizeof(a));  
  17.     for(i=0;i<SIZE;i++)  
  18.     {  
  19.         printf("%d",b[i]);  
  20.     }  
  21. } 
 
       
 
 
       
 
 
       
 
 
       
本文出自 “kym” 博客，请务必保留此出处http://kymsha.blog.51cto.com/647951/290505